diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 000000000..d5a5e965a
Binary files /dev/null and b/.DS_Store differ
diff --git a/node_modules/.package-lock.json b/node_modules/.package-lock.json
new file mode 100644
index 000000000..cb60e0e66
--- /dev/null
+++ b/node_modules/.package-lock.json
@@ -0,0 +1,53 @@
+{
+ "name": "LittleBits",
+ "lockfileVersion": 3,
+ "requires": true,
+ "packages": {
+ "node_modules/@types/react": {
+ "version": "19.1.8",
+ "resolved": "https://registry.npmjs.org/@types/react/-/react-19.1.8.tgz",
+ "integrity": "sha512-AwAfQ2Wa5bCx9WP8nZL2uMZWod7J7/JSplxbTmBQ5ms6QpqNYm672H0Vu9ZVKVngQ+ii4R/byguVEUZQyeg44g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "csstype": "^3.0.2"
+ }
+ },
+ "node_modules/@types/react-dom": {
+ "version": "19.1.6",
+ "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.1.6.tgz",
+ "integrity": "sha512-4hOiT/dwO8Ko0gV1m/TJZYk3y0KBnY9vzDh7W+DH17b2HFSOGgdj33dhihPeuy3l0q23+4e+hoXHV6hCC4dCXw==",
+ "dev": true,
+ "license": "MIT",
+ "peerDependencies": {
+ "@types/react": "^19.0.0"
+ }
+ },
+ "node_modules/csstype": {
+ "version": "3.1.3",
+ "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
+ "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/lucide-react": {
+ "version": "0.525.0",
+ "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-0.525.0.tgz",
+ "integrity": "sha512-Tm1txJ2OkymCGkvwoHt33Y2JpN5xucVq1slHcgE6Lk0WjDfjgKWor5CdVER8U6DvcfMwh4M8XxmpTiyzfmfDYQ==",
+ "license": "ISC",
+ "peerDependencies": {
+ "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+ }
+ },
+ "node_modules/react": {
+ "version": "19.1.0",
+ "resolved": "https://registry.npmjs.org/react/-/react-19.1.0.tgz",
+ "integrity": "sha512-FS+XFBNvn3GTAWq26joslQgWNoFu08F4kl0J4CgdNKADkdSGXQyTCnKteIAJy96Br6YbpEU1LSzV5dYtjMkMDg==",
+ "license": "MIT",
+ "peer": true,
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ }
+ }
+}
diff --git a/node_modules/@types/react-dom/LICENSE b/node_modules/@types/react-dom/LICENSE
new file mode 100644
index 000000000..9e841e7a2
--- /dev/null
+++ b/node_modules/@types/react-dom/LICENSE
@@ -0,0 +1,21 @@
+ MIT License
+
+ Copyright (c) Microsoft Corporation.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE
diff --git a/node_modules/@types/react-dom/README.md b/node_modules/@types/react-dom/README.md
new file mode 100644
index 000000000..29b8f0b90
--- /dev/null
+++ b/node_modules/@types/react-dom/README.md
@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/react-dom`
+
+# Summary
+This package contains type definitions for react-dom (https://react.dev/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react-dom.
+
+### Additional Details
+ * Last updated: Wed, 04 Jun 2025 12:44:27 GMT
+ * Dependencies: none
+ * Peer dependencies: [@types/react](https://npmjs.com/package/@types/react)
+
+# Credits
+These definitions were written by [Asana](https://asana.com), [AssureSign](http://www.assuresign.com), [Microsoft](https://microsoft.com), [MartynasZilinskas](https://github.com/MartynasZilinskas), [Josh Rutherford](https://github.com/theruther4d), [Jessica Franco](https://github.com/Jessidhia), and [Sebastian Silbermann](https://github.com/eps1lon).
diff --git a/node_modules/@types/react-dom/canary.d.ts b/node_modules/@types/react-dom/canary.d.ts
new file mode 100644
index 000000000..ba961bf58
--- /dev/null
+++ b/node_modules/@types/react-dom/canary.d.ts
@@ -0,0 +1,32 @@
+/**
+ * These are types for things that are present in the upcoming React 18 release.
+ *
+ * Once React 18 is released they can just be moved to the main index file.
+ *
+ * To load the types declared here in an actual project, there are three ways. The easiest one,
+ * if your `tsconfig.json` already has a `"types"` array in the `"compilerOptions"` section,
+ * is to add `"react-dom/canary"` to the `"types"` array.
+ *
+ * Alternatively, a specific import syntax can to be used from a typescript file.
+ * This module does not exist in reality, which is why the {} is important:
+ *
+ * ```ts
+ * import {} from 'react-dom/canary'
+ * ```
+ *
+ * It is also possible to include it through a triple-slash reference:
+ *
+ * ```ts
+ * ///
+ * ```
+ *
+ * Either the import or the reference only needs to appear once, anywhere in the project.
+ */
+
+// See https://github.com/facebook/react/blob/main/packages/react-dom/index.js to see how the exports are declared,
+// but confirm with published source code (e.g. https://unpkg.com/react-dom@canary) that these exports end up in the published code
+
+import React = require("react");
+import ReactDOM = require(".");
+
+export {};
diff --git a/node_modules/@types/react-dom/client.d.ts b/node_modules/@types/react-dom/client.d.ts
new file mode 100644
index 000000000..90f941ae5
--- /dev/null
+++ b/node_modules/@types/react-dom/client.d.ts
@@ -0,0 +1,105 @@
+/**
+ * WARNING: This entrypoint is only available starting with `react-dom@18.0.0-rc.1`
+ */
+
+// See https://github.com/facebook/react/blob/main/packages/react-dom/client.js to see how the exports are declared,
+
+import React = require("react");
+
+export {};
+
+declare const REACT_FORM_STATE_SIGIL: unique symbol;
+export interface ReactFormState {
+ [REACT_FORM_STATE_SIGIL]: never;
+}
+
+export interface HydrationOptions {
+ formState?: ReactFormState | null;
+ /**
+ * Prefix for `useId`.
+ */
+ identifierPrefix?: string;
+ onUncaughtError?:
+ | ((error: unknown, errorInfo: { componentStack?: string | undefined }) => void)
+ | undefined;
+ onRecoverableError?: (error: unknown, errorInfo: ErrorInfo) => void;
+ onCaughtError?:
+ | ((
+ error: unknown,
+ errorInfo: {
+ componentStack?: string | undefined;
+ errorBoundary?: React.Component | undefined;
+ },
+ ) => void)
+ | undefined;
+}
+
+export interface RootOptions {
+ /**
+ * Prefix for `useId`.
+ */
+ identifierPrefix?: string;
+ onUncaughtError?:
+ | ((error: unknown, errorInfo: { componentStack?: string | undefined }) => void)
+ | undefined;
+ onRecoverableError?: (error: unknown, errorInfo: ErrorInfo) => void;
+ onCaughtError?:
+ | ((
+ error: unknown,
+ errorInfo: {
+ componentStack?: string | undefined;
+ errorBoundary?: React.Component | undefined;
+ },
+ ) => void)
+ | undefined;
+}
+
+export interface ErrorInfo {
+ componentStack?: string;
+}
+
+export interface Root {
+ render(children: React.ReactNode): void;
+ unmount(): void;
+}
+
+/**
+ * Different release channels declare additional types of ReactNode this particular release channel accepts.
+ * App or library types should never augment this interface.
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_CREATE_ROOT_CONTAINERS {}
+
+export type Container =
+ | Element
+ | DocumentFragment
+ | Document
+ | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_CREATE_ROOT_CONTAINERS[
+ keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_CREATE_ROOT_CONTAINERS
+ ];
+
+/**
+ * createRoot lets you create a root to display React components inside a browser DOM node.
+ *
+ * @see {@link https://react.dev/reference/react-dom/client/createRoot API Reference for `createRoot`}
+ */
+export function createRoot(container: Container, options?: RootOptions): Root;
+
+/**
+ * Same as `createRoot()`, but is used to hydrate a container whose HTML contents were rendered by ReactDOMServer.
+ *
+ * React will attempt to attach event listeners to the existing markup.
+ *
+ * **Example Usage**
+ *
+ * ```jsx
+ * hydrateRoot(document.querySelector('#root'), )
+ * ```
+ *
+ * @see https://reactjs.org/docs/react-dom-client.html#hydrateroot
+ */
+export function hydrateRoot(
+ container: Element | Document,
+ initialChildren: React.ReactNode,
+ options?: HydrationOptions,
+): Root;
diff --git a/node_modules/@types/react-dom/experimental.d.ts b/node_modules/@types/react-dom/experimental.d.ts
new file mode 100644
index 000000000..a0182f2a5
--- /dev/null
+++ b/node_modules/@types/react-dom/experimental.d.ts
@@ -0,0 +1,86 @@
+/**
+ * These are types for things that are present in the `experimental` builds of React but not yet
+ * on a stable build.
+ *
+ * Once they are promoted to stable they can just be moved to the main index file.
+ *
+ * To load the types declared here in an actual project, there are three ways. The easiest one,
+ * if your `tsconfig.json` already has a `"types"` array in the `"compilerOptions"` section,
+ * is to add `"react-dom/experimental"` to the `"types"` array.
+ *
+ * Alternatively, a specific import syntax can to be used from a typescript file.
+ * This module does not exist in reality, which is why the {} is important:
+ *
+ * ```ts
+ * import {} from 'react-dom/experimental'
+ * ```
+ *
+ * It is also possible to include it through a triple-slash reference:
+ *
+ * ```ts
+ * ///
+ * ```
+ *
+ * Either the import or the reference only needs to appear once, anywhere in the project.
+ */
+
+// See https://github.com/facebook/react/blob/main/packages/react-dom/index.experimental.js to see how the exports are declared,
+// but confirm with published source code (e.g. https://unpkg.com/react-dom@experimental) that these exports end up in the published code
+
+import React = require("react");
+import ReactDOM = require("./canary");
+
+export {};
+
+declare const UNDEFINED_VOID_ONLY: unique symbol;
+type VoidOrUndefinedOnly = void | { [UNDEFINED_VOID_ONLY]: never };
+
+declare module "." {
+}
+
+declare module "react" {
+ interface ViewTransitionPseudoElement extends Animatable {
+ getComputedStyle: () => CSSStyleDeclaration;
+ }
+
+ interface ViewTransitionInstance {
+ group: ViewTransitionPseudoElement;
+ imagePair: ViewTransitionPseudoElement;
+ old: ViewTransitionPseudoElement;
+ new: ViewTransitionPseudoElement;
+ }
+
+ // eslint-disable-next-line @typescript-eslint/no-empty-interface
+ interface GestureProvider extends AnimationTimeline {}
+
+ // @enableFragmentRefs
+ interface FragmentInstance {
+ blur: () => void;
+ focus: (focusOptions?: FocusOptions | undefined) => void;
+ focusLast: (focusOptions?: FocusOptions | undefined) => void;
+ observeUsing(observer: IntersectionObserver | ResizeObserver): void;
+ unobserveUsing(observer: IntersectionObserver | ResizeObserver): void;
+ getClientRects(): Array;
+ getRootNode(getRootNodeOptions?: GetRootNodeOptions | undefined): Document | ShadowRoot | FragmentInstance;
+ addEventListener(
+ type: string,
+ listener: EventListener,
+ optionsOrUseCapture?: Parameters[2],
+ ): void;
+ removeEventListener(
+ type: string,
+ listener: EventListener,
+ optionsOrUseCapture?: Parameters[2],
+ ): void;
+ }
+}
+
+declare module "./client" {
+ type TransitionIndicatorCleanup = () => VoidOrUndefinedOnly;
+ interface RootOptions {
+ onDefaultTransitionIndicator?: (() => void | TransitionIndicatorCleanup) | undefined;
+ }
+ interface HydrationOptions {
+ onDefaultTransitionIndicator?: (() => void | TransitionIndicatorCleanup) | undefined;
+ }
+}
diff --git a/node_modules/@types/react-dom/index.d.ts b/node_modules/@types/react-dom/index.d.ts
new file mode 100644
index 000000000..76efddd22
--- /dev/null
+++ b/node_modules/@types/react-dom/index.d.ts
@@ -0,0 +1,128 @@
+// NOTE: Users of the `experimental` builds of React should add a reference
+// to 'react-dom/experimental' in their project. See experimental.d.ts's top comment
+// for reference and documentation on how exactly to do it.
+
+export as namespace ReactDOM;
+
+import { Key, ReactNode, ReactPortal } from "react";
+
+export function createPortal(
+ children: ReactNode,
+ container: Element | DocumentFragment,
+ key?: Key | null,
+): ReactPortal;
+
+export const version: string;
+
+export function flushSync(fn: () => R): R;
+
+export function unstable_batchedUpdates(callback: (a: A) => R, a: A): R;
+export function unstable_batchedUpdates(callback: () => R): R;
+
+export interface FormStatusNotPending {
+ pending: false;
+ data: null;
+ method: null;
+ action: null;
+}
+
+export interface FormStatusPending {
+ pending: true;
+ data: FormData;
+ method: string;
+ action: string | ((formData: FormData) => void | Promise);
+}
+
+export type FormStatus = FormStatusPending | FormStatusNotPending;
+
+export function useFormStatus(): FormStatus;
+
+export function useFormState(
+ action: (state: Awaited) => State | Promise,
+ initialState: Awaited,
+ permalink?: string,
+): [state: Awaited, dispatch: () => void, isPending: boolean];
+export function useFormState(
+ action: (state: Awaited, payload: Payload) => State | Promise,
+ initialState: Awaited,
+ permalink?: string,
+): [state: Awaited, dispatch: (payload: Payload) => void, isPending: boolean];
+
+export function prefetchDNS(href: string): void;
+
+export interface PreconnectOptions {
+ // Don't create a helper type.
+ // It would have to be in module scope to be inlined in TS tooltips.
+ // But then it becomes part of the public API.
+ // TODO: Upstream to microsoft/TypeScript-DOM-lib-generator -> w3c/webref
+ // since the spec has a notion of a dedicated type: https://html.spec.whatwg.org/multipage/urls-and-fetching.html#cors-settings-attribute
+ crossOrigin?: "anonymous" | "use-credentials" | "" | undefined;
+}
+export function preconnect(href: string, options?: PreconnectOptions): void;
+
+export type PreloadAs =
+ | "audio"
+ | "document"
+ | "embed"
+ | "fetch"
+ | "font"
+ | "image"
+ | "object"
+ | "track"
+ | "script"
+ | "style"
+ | "video"
+ | "worker";
+export interface PreloadOptions {
+ as: PreloadAs;
+ crossOrigin?: "anonymous" | "use-credentials" | "" | undefined;
+ fetchPriority?: "high" | "low" | "auto" | undefined;
+ // TODO: These should only be allowed with `as: 'image'` but it's not trivial to write tests against the full TS support matrix.
+ imageSizes?: string | undefined;
+ imageSrcSet?: string | undefined;
+ integrity?: string | undefined;
+ type?: string | undefined;
+ nonce?: string | undefined;
+ referrerPolicy?: ReferrerPolicy | undefined;
+ media?: string | undefined;
+}
+export function preload(href: string, options?: PreloadOptions): void;
+
+// https://html.spec.whatwg.org/multipage/links.html#link-type-modulepreload
+export type PreloadModuleAs = RequestDestination;
+export interface PreloadModuleOptions {
+ /**
+ * @default "script"
+ */
+ as: PreloadModuleAs;
+ crossOrigin?: "anonymous" | "use-credentials" | "" | undefined;
+ integrity?: string | undefined;
+ nonce?: string | undefined;
+}
+export function preloadModule(href: string, options?: PreloadModuleOptions): void;
+
+export type PreinitAs = "script" | "style";
+export interface PreinitOptions {
+ as: PreinitAs;
+ crossOrigin?: "anonymous" | "use-credentials" | "" | undefined;
+ fetchPriority?: "high" | "low" | "auto" | undefined;
+ precedence?: string | undefined;
+ integrity?: string | undefined;
+ nonce?: string | undefined;
+}
+export function preinit(href: string, options?: PreinitOptions): void;
+
+// Will be expanded to include all of https://github.com/tc39/proposal-import-attributes
+export type PreinitModuleAs = "script";
+export interface PreinitModuleOptions {
+ /**
+ * @default "script"
+ */
+ as?: PreinitModuleAs;
+ crossOrigin?: "anonymous" | "use-credentials" | "" | undefined;
+ integrity?: string | undefined;
+ nonce?: string | undefined;
+}
+export function preinitModule(href: string, options?: PreinitModuleOptions): void;
+
+export function requestFormReset(form: HTMLFormElement): void;
diff --git a/node_modules/@types/react-dom/package.json b/node_modules/@types/react-dom/package.json
new file mode 100644
index 000000000..0b69ec0c5
--- /dev/null
+++ b/node_modules/@types/react-dom/package.json
@@ -0,0 +1,128 @@
+{
+ "name": "@types/react-dom",
+ "version": "19.1.6",
+ "description": "TypeScript definitions for react-dom",
+ "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react-dom",
+ "license": "MIT",
+ "contributors": [
+ {
+ "name": "Asana",
+ "url": "https://asana.com"
+ },
+ {
+ "name": "AssureSign",
+ "url": "http://www.assuresign.com"
+ },
+ {
+ "name": "Microsoft",
+ "url": "https://microsoft.com"
+ },
+ {
+ "name": "MartynasZilinskas",
+ "githubUsername": "MartynasZilinskas",
+ "url": "https://github.com/MartynasZilinskas"
+ },
+ {
+ "name": "Josh Rutherford",
+ "githubUsername": "theruther4d",
+ "url": "https://github.com/theruther4d"
+ },
+ {
+ "name": "Jessica Franco",
+ "githubUsername": "Jessidhia",
+ "url": "https://github.com/Jessidhia"
+ },
+ {
+ "name": "Sebastian Silbermann",
+ "githubUsername": "eps1lon",
+ "url": "https://github.com/eps1lon"
+ }
+ ],
+ "main": "",
+ "types": "index.d.ts",
+ "exports": {
+ ".": {
+ "types": {
+ "default": "./index.d.ts"
+ }
+ },
+ "./client": {
+ "types": {
+ "default": "./client.d.ts"
+ }
+ },
+ "./canary": {
+ "types": {
+ "default": "./canary.d.ts"
+ }
+ },
+ "./server": {
+ "types": {
+ "default": "./server.d.ts"
+ }
+ },
+ "./server.browser": {
+ "types": {
+ "default": "./server.browser.d.ts"
+ }
+ },
+ "./server.bun": {
+ "types": {
+ "default": "./server.bun.d.ts"
+ }
+ },
+ "./server.edge": {
+ "types": {
+ "default": "./server.edge.d.ts"
+ }
+ },
+ "./server.node": {
+ "types": {
+ "default": "./server.node.d.ts"
+ }
+ },
+ "./static": {
+ "types": {
+ "default": "./static.d.ts"
+ }
+ },
+ "./static.browser": {
+ "types": {
+ "default": "./static.browser.d.ts"
+ }
+ },
+ "./static.edge": {
+ "types": {
+ "default": "./static.edge.d.ts"
+ }
+ },
+ "./static.node": {
+ "types": {
+ "default": "./static.node.d.ts"
+ }
+ },
+ "./experimental": {
+ "types": {
+ "default": "./experimental.d.ts"
+ }
+ },
+ "./test-utils": {
+ "types": {
+ "default": "./test-utils/index.d.ts"
+ }
+ },
+ "./package.json": "./package.json"
+ },
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+ "directory": "types/react-dom"
+ },
+ "scripts": {},
+ "dependencies": {},
+ "peerDependencies": {
+ "@types/react": "^19.0.0"
+ },
+ "typesPublisherContentHash": "7b56a76f96eb2aa35d120d8e3b6f3d4d931764fe44b89b21cd496919cab0e223",
+ "typeScriptVersion": "5.1"
+}
\ No newline at end of file
diff --git a/node_modules/@types/react-dom/server.browser.d.ts b/node_modules/@types/react-dom/server.browser.d.ts
new file mode 100644
index 000000000..f2e3bc930
--- /dev/null
+++ b/node_modules/@types/react-dom/server.browser.d.ts
@@ -0,0 +1 @@
+export { renderToReadableStream, renderToStaticMarkup, renderToString } from "./server";
diff --git a/node_modules/@types/react-dom/server.bun.d.ts b/node_modules/@types/react-dom/server.bun.d.ts
new file mode 100644
index 000000000..f2e3bc930
--- /dev/null
+++ b/node_modules/@types/react-dom/server.bun.d.ts
@@ -0,0 +1 @@
+export { renderToReadableStream, renderToStaticMarkup, renderToString } from "./server";
diff --git a/node_modules/@types/react-dom/server.d.ts b/node_modules/@types/react-dom/server.d.ts
new file mode 100644
index 000000000..c298f6db2
--- /dev/null
+++ b/node_modules/@types/react-dom/server.d.ts
@@ -0,0 +1,114 @@
+// forward declarations
+declare global {
+ namespace NodeJS {
+ // eslint-disable-next-line @typescript-eslint/no-empty-interface
+ interface ReadableStream {}
+
+ // eslint-disable-next-line @typescript-eslint/no-empty-interface
+ interface WritableStream {}
+ }
+
+ /**
+ * Stub for https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
+ */
+ // eslint-disable-next-line @typescript-eslint/no-empty-interface
+ interface AbortSignal {}
+
+ /**
+ * Stub for https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream
+ */
+ // eslint-disable-next-line @typescript-eslint/no-empty-interface
+ interface ReadableStream {}
+}
+
+import { ReactNode } from "react";
+import { ErrorInfo } from "./client";
+
+export type BootstrapScriptDescriptor = {
+ src: string;
+ integrity?: string | undefined;
+ crossOrigin?: string | undefined;
+};
+
+export interface RenderToPipeableStreamOptions {
+ identifierPrefix?: string;
+ namespaceURI?: string;
+ nonce?: string;
+ bootstrapScriptContent?: string;
+ bootstrapScripts?: Array;
+ bootstrapModules?: Array;
+ progressiveChunkSize?: number;
+ onShellReady?: () => void;
+ onShellError?: (error: unknown) => void;
+ onAllReady?: () => void;
+ onError?: (error: unknown, errorInfo: ErrorInfo) => string | void;
+}
+
+export interface PipeableStream {
+ abort: (reason?: unknown) => void;
+ pipe: (destination: Writable) => Writable;
+}
+
+export interface ServerOptions {
+ identifierPrefix?: string;
+}
+
+/**
+ * Only available in the environments with [Node.js Streams](https://nodejs.dev/learn/nodejs-streams).
+ *
+ * @see [API](https://reactjs.org/docs/react-dom-server.html#rendertopipeablestream)
+ *
+ * @param children
+ * @param options
+ */
+export function renderToPipeableStream(children: ReactNode, options?: RenderToPipeableStreamOptions): PipeableStream;
+
+/**
+ * Render a React element to its initial HTML. This should only be used on the server.
+ * React will return an HTML string. You can use this method to generate HTML on the server
+ * and send the markup down on the initial request for faster page loads and to allow search
+ * engines to crawl your pages for SEO purposes.
+ *
+ * If you call `ReactDOMClient.hydrateRoot()` on a node that already has this server-rendered markup,
+ * React will preserve it and only attach event handlers, allowing you
+ * to have a very performant first-load experience.
+ */
+export function renderToString(element: ReactNode, options?: ServerOptions): string;
+
+/**
+ * Similar to `renderToString`, except this doesn't create extra DOM attributes
+ * such as `data-reactid`, that React uses internally. This is useful if you want
+ * to use React as a simple static page generator, as stripping away the extra
+ * attributes can save lots of bytes.
+ */
+export function renderToStaticMarkup(element: ReactNode, options?: ServerOptions): string;
+
+export interface RenderToReadableStreamOptions {
+ identifierPrefix?: string;
+ namespaceURI?: string;
+ nonce?: string;
+ bootstrapScriptContent?: string;
+ bootstrapScripts?: Array;
+ bootstrapModules?: Array;
+ progressiveChunkSize?: number;
+ signal?: AbortSignal;
+ onError?: (error: unknown, errorInfo: ErrorInfo) => string | void;
+}
+
+export interface ReactDOMServerReadableStream extends ReadableStream {
+ allReady: Promise;
+}
+
+/**
+ * Only available in the environments with [Web Streams](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API) (this includes browsers, Deno, and some modern edge runtimes).
+ *
+ * @see [API](https://reactjs.org/docs/react-dom-server.html#rendertoreadablestream)
+ */
+export function renderToReadableStream(
+ children: ReactNode,
+ options?: RenderToReadableStreamOptions,
+): Promise;
+
+export const version: string;
+
+export as namespace ReactDOMServer;
diff --git a/node_modules/@types/react-dom/server.edge.d.ts b/node_modules/@types/react-dom/server.edge.d.ts
new file mode 100644
index 000000000..f2e3bc930
--- /dev/null
+++ b/node_modules/@types/react-dom/server.edge.d.ts
@@ -0,0 +1 @@
+export { renderToReadableStream, renderToStaticMarkup, renderToString } from "./server";
diff --git a/node_modules/@types/react-dom/server.node.d.ts b/node_modules/@types/react-dom/server.node.d.ts
new file mode 100644
index 000000000..5f426f2a6
--- /dev/null
+++ b/node_modules/@types/react-dom/server.node.d.ts
@@ -0,0 +1 @@
+export { renderToPipeableStream, renderToStaticMarkup, renderToString } from "./server";
diff --git a/node_modules/@types/react-dom/static.browser.d.ts b/node_modules/@types/react-dom/static.browser.d.ts
new file mode 100644
index 000000000..cd2d05ff5
--- /dev/null
+++ b/node_modules/@types/react-dom/static.browser.d.ts
@@ -0,0 +1 @@
+export { prerender, version } from "./static";
diff --git a/node_modules/@types/react-dom/static.d.ts b/node_modules/@types/react-dom/static.d.ts
new file mode 100644
index 000000000..ef52180c8
--- /dev/null
+++ b/node_modules/@types/react-dom/static.d.ts
@@ -0,0 +1,78 @@
+// forward declarations
+declare global {
+ namespace NodeJS {
+ // eslint-disable-next-line @typescript-eslint/no-empty-interface
+ interface ReadableStream {}
+ }
+
+ /**
+ * Stub for https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
+ */
+ // eslint-disable-next-line @typescript-eslint/no-empty-interface
+ interface AbortSignal {}
+
+ /**
+ * Stub for https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream
+ */
+ // eslint-disable-next-line @typescript-eslint/no-empty-interface
+ interface ReadableStream {}
+
+ /**
+ * Stub for https://developer.mozilla.org/en-US/docs/Web/API/Uint8Array
+ */
+ // eslint-disable-next-line @typescript-eslint/no-empty-interface
+ interface Uint8Array {}
+}
+
+import { ReactNode } from "react";
+import { ErrorInfo } from "./client";
+
+export type BootstrapScriptDescriptor = {
+ src: string;
+ integrity?: string | undefined;
+ crossOrigin?: string | undefined;
+};
+
+export interface PrerenderOptions {
+ bootstrapScriptContent?: string;
+ bootstrapScripts?: Array;
+ bootstrapModules?: Array;
+ identifierPrefix?: string;
+ namespaceURI?: string;
+ onError?: (error: unknown, errorInfo: ErrorInfo) => string | void;
+ progressiveChunkSize?: number;
+ signal?: AbortSignal;
+}
+
+export interface PrerenderResult {
+ prelude: ReadableStream;
+}
+
+/**
+ * Only available in the environments with [Web Streams](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API) (this includes browsers, Deno, and some modern edge runtimes).
+ *
+ * @see [API](https://react.dev/reference/react-dom/static/prerender)
+ */
+export function prerender(
+ reactNode: ReactNode,
+ options?: PrerenderOptions,
+): Promise;
+
+export interface PrerenderToNodeStreamResult {
+ prelude: NodeJS.ReadableStream;
+}
+
+/**
+ * Only available in the environments with [Node.js Streams](https://nodejs.dev/learn/nodejs-streams).
+ *
+ * @see [API](https://react.dev/reference/react-dom/static/prerenderToNodeStream)
+ *
+ * @param children
+ * @param options
+ */
+export function prerenderToNodeStream(
+ reactNode: ReactNode,
+ options?: PrerenderOptions,
+): Promise;
+
+export const version: string;
diff --git a/node_modules/@types/react-dom/static.edge.d.ts b/node_modules/@types/react-dom/static.edge.d.ts
new file mode 100644
index 000000000..cd2d05ff5
--- /dev/null
+++ b/node_modules/@types/react-dom/static.edge.d.ts
@@ -0,0 +1 @@
+export { prerender, version } from "./static";
diff --git a/node_modules/@types/react-dom/static.node.d.ts b/node_modules/@types/react-dom/static.node.d.ts
new file mode 100644
index 000000000..cb7017ebf
--- /dev/null
+++ b/node_modules/@types/react-dom/static.node.d.ts
@@ -0,0 +1 @@
+export { prerenderToNodeStream, version } from "./static";
diff --git a/node_modules/@types/react-dom/test-utils/index.d.ts b/node_modules/@types/react-dom/test-utils/index.d.ts
new file mode 100644
index 000000000..7e211ea0b
--- /dev/null
+++ b/node_modules/@types/react-dom/test-utils/index.d.ts
@@ -0,0 +1,7 @@
+export {};
+
+export {
+ /**
+ * @deprecated Import `act` from `react` instead.
+ */ act,
+} from "react";
diff --git a/node_modules/@types/react/LICENSE b/node_modules/@types/react/LICENSE
new file mode 100644
index 000000000..9e841e7a2
--- /dev/null
+++ b/node_modules/@types/react/LICENSE
@@ -0,0 +1,21 @@
+ MIT License
+
+ Copyright (c) Microsoft Corporation.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE
diff --git a/node_modules/@types/react/README.md b/node_modules/@types/react/README.md
new file mode 100644
index 000000000..f44aac784
--- /dev/null
+++ b/node_modules/@types/react/README.md
@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/react`
+
+# Summary
+This package contains type definitions for react (https://react.dev/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react.
+
+### Additional Details
+ * Last updated: Wed, 11 Jun 2025 13:41:16 GMT
+ * Dependencies: [csstype](https://npmjs.com/package/csstype)
+
+# Credits
+These definitions were written by [Asana](https://asana.com), [AssureSign](http://www.assuresign.com), [Microsoft](https://microsoft.com), [John Reilly](https://github.com/johnnyreilly), [Benoit Benezech](https://github.com/bbenezech), [Patricio Zavolinsky](https://github.com/pzavolinsky), [Eric Anderson](https://github.com/ericanderson), [Dovydas Navickas](https://github.com/DovydasNavickas), [Josh Rutherford](https://github.com/theruther4d), [Guilherme Hübner](https://github.com/guilhermehubner), [Ferdy Budhidharma](https://github.com/ferdaber), [Johann Rakotoharisoa](https://github.com/jrakotoharisoa), [Olivier Pascal](https://github.com/pascaloliv), [Martin Hochel](https://github.com/hotell), [Frank Li](https://github.com/franklixuefei), [Jessica Franco](https://github.com/Jessidhia), [Saransh Kataria](https://github.com/saranshkataria), [Kanitkorn Sujautra](https://github.com/lukyth), [Sebastian Silbermann](https://github.com/eps1lon), [Kyle Scully](https://github.com/zieka), [Cong Zhang](https://github.com/dancerphil), [Dimitri Mitropoulos](https://github.com/dimitropoulos), [JongChan Choi](https://github.com/disjukr), [Victor Magalhães](https://github.com/vhfmag), [Priyanshu Rav](https://github.com/priyanshurav), [Dmitry Semigradsky](https://github.com/Semigradsky), and [Matt Pocock](https://github.com/mattpocock).
diff --git a/node_modules/@types/react/canary.d.ts b/node_modules/@types/react/canary.d.ts
new file mode 100644
index 000000000..9215a16bb
--- /dev/null
+++ b/node_modules/@types/react/canary.d.ts
@@ -0,0 +1,35 @@
+/**
+ * These are types for things that are present in the React `canary` release channel.
+ *
+ * To load the types declared here in an actual project, there are three ways. The easiest one,
+ * if your `tsconfig.json` already has a `"types"` array in the `"compilerOptions"` section,
+ * is to add `"react/canary"` to the `"types"` array.
+ *
+ * Alternatively, a specific import syntax can to be used from a typescript file.
+ * This module does not exist in reality, which is why the {} is important:
+ *
+ * ```ts
+ * import {} from 'react/canary'
+ * ```
+ *
+ * It is also possible to include it through a triple-slash reference:
+ *
+ * ```ts
+ * ///
+ * ```
+ *
+ * Either the import or the reference only needs to appear once, anywhere in the project.
+ */
+
+// See https://github.com/facebook/react/blob/main/packages/react/src/React.js to see how the exports are declared,
+
+import React = require(".");
+
+export {};
+
+declare const UNDEFINED_VOID_ONLY: unique symbol;
+type VoidOrUndefinedOnly = void | { [UNDEFINED_VOID_ONLY]: never };
+
+declare module "." {
+ export function unstable_useCacheRefresh(): () => void;
+}
diff --git a/node_modules/@types/react/compiler-runtime.d.ts b/node_modules/@types/react/compiler-runtime.d.ts
new file mode 100644
index 000000000..a98a26e64
--- /dev/null
+++ b/node_modules/@types/react/compiler-runtime.d.ts
@@ -0,0 +1,4 @@
+// Not meant to be used directly
+// Omitting all exports so that they don't appear in IDE autocomplete.
+
+export {};
diff --git a/node_modules/@types/react/experimental.d.ts b/node_modules/@types/react/experimental.d.ts
new file mode 100644
index 000000000..c690165a0
--- /dev/null
+++ b/node_modules/@types/react/experimental.d.ts
@@ -0,0 +1,243 @@
+/**
+ * These are types for things that are present in the `experimental` builds of React but not yet
+ * on a stable build.
+ *
+ * Once they are promoted to stable they can just be moved to the main index file.
+ *
+ * To load the types declared here in an actual project, there are three ways. The easiest one,
+ * if your `tsconfig.json` already has a `"types"` array in the `"compilerOptions"` section,
+ * is to add `"react/experimental"` to the `"types"` array.
+ *
+ * Alternatively, a specific import syntax can to be used from a typescript file.
+ * This module does not exist in reality, which is why the {} is important:
+ *
+ * ```ts
+ * import {} from 'react/experimental'
+ * ```
+ *
+ * It is also possible to include it through a triple-slash reference:
+ *
+ * ```ts
+ * ///
+ * ```
+ *
+ * Either the import or the reference only needs to appear once, anywhere in the project.
+ */
+
+// See https://github.com/facebook/react/blob/master/packages/react/src/React.js to see how the exports are declared,
+// and https://github.com/facebook/react/blob/master/packages/shared/ReactFeatureFlags.js to verify which APIs are
+// flagged experimental or not. Experimental APIs will be tagged with `__EXPERIMENTAL__`.
+//
+// For the inputs of types exported as simply a fiber tag, the `beginWork` function of ReactFiberBeginWork.js
+// is a good place to start looking for details; it generally calls prop validation functions or delegates
+// all tasks done as part of the render phase (the concurrent part of the React update cycle).
+//
+// Suspense-related handling can be found in ReactFiberThrow.js.
+
+import React = require("./canary");
+
+export {};
+
+declare const UNDEFINED_VOID_ONLY: unique symbol;
+type VoidOrUndefinedOnly = void | { [UNDEFINED_VOID_ONLY]: never };
+
+declare module "." {
+ export interface SuspenseProps {
+ /**
+ * The presence of this prop indicates that the content is computationally expensive to render.
+ * In other words, the tree is CPU bound and not I/O bound (e.g. due to fetching data).
+ * @see {@link https://github.com/facebook/react/pull/19936}
+ */
+ unstable_expectedLoadTime?: number | undefined;
+ }
+
+ export type SuspenseListRevealOrder = "forwards" | "backwards" | "together" | "independent";
+ export type SuspenseListTailMode = "collapsed" | "hidden" | "visible";
+
+ export interface SuspenseListCommonProps {
+ }
+
+ interface DirectionalSuspenseListProps extends SuspenseListCommonProps {
+ /**
+ * Note that SuspenseList require more than one child;
+ * it is a runtime warning to provide only a single child.
+ *
+ * It does, however, allow those children to be wrapped inside a single
+ * level of ``.
+ */
+ children: Iterable | AsyncIterable;
+ /**
+ * Defines the order in which the `SuspenseList` children should be revealed.
+ */
+ revealOrder: "forwards" | "backwards" | "unstable_legacy-backwards";
+ /**
+ * Dictates how unloaded items in a SuspenseList is shown.
+ *
+ * - By default, `SuspenseList` will show all fallbacks in the list.
+ * - `collapsed` shows only the next fallback in the list.
+ * - `hidden` doesn't show any unloaded items.
+ * - `visible` shows all fallbacks in the list.
+ */
+ tail: SuspenseListTailMode;
+ }
+
+ interface NonDirectionalSuspenseListProps extends SuspenseListCommonProps {
+ children: ReactNode;
+ /**
+ * Defines the order in which the `SuspenseList` children should be revealed.
+ */
+ revealOrder: Exclude | undefined;
+ /**
+ * The tail property is invalid when not using the `forwards` or `backwards` reveal orders.
+ */
+ tail?: never;
+ }
+
+ export type SuspenseListProps = DirectionalSuspenseListProps | NonDirectionalSuspenseListProps;
+
+ /**
+ * `SuspenseList` helps coordinate many components that can suspend by orchestrating the order
+ * in which these components are revealed to the user.
+ *
+ * When multiple components need to fetch data, this data may arrive in an unpredictable order.
+ * However, if you wrap these items in a `SuspenseList`, React will not show an item in the list
+ * until previous items have been displayed (this behavior is adjustable).
+ *
+ * @see https://reactjs.org/docs/concurrent-mode-reference.html#suspenselist
+ * @see https://reactjs.org/docs/concurrent-mode-patterns.html#suspenselist
+ */
+ export const unstable_SuspenseList: ExoticComponent;
+
+ // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+ export function experimental_useEffectEvent(event: T): T;
+
+ type Reference = object;
+ type TaintableUniqueValue = string | bigint | ArrayBufferView;
+ function experimental_taintUniqueValue(
+ message: string | undefined,
+ lifetime: Reference,
+ value: TaintableUniqueValue,
+ ): void;
+ function experimental_taintObjectReference(message: string | undefined, object: Reference): void;
+
+ export interface ViewTransitionInstance {
+ /**
+ * The {@link ViewTransitionProps name} that was used in the corresponding {@link ViewTransition} component or `"auto"` if the `name` prop was omitted.
+ */
+ name: string;
+ }
+
+ export type ViewTransitionClassPerType = Record<"default" | (string & {}), "none" | "auto" | (string & {})>;
+ export type ViewTransitionClass = ViewTransitionClassPerType | ViewTransitionClassPerType[string];
+
+ export interface ViewTransitionProps {
+ children?: ReactNode | undefined;
+ /**
+ * Assigns the {@link https://developer.chrome.com/blog/view-transitions-update-io24#view-transition-class `view-transition-class`} class to the underlying DOM node.
+ */
+ default?: ViewTransitionClass | undefined;
+ /**
+ * Combined with {@link className} if this `` or its parent Component is mounted and there's no other with the same name being deleted.
+ * `"none"` is a special value that deactivates the view transition name under that condition.
+ */
+ enter?: ViewTransitionClass | undefined;
+ /**
+ * Combined with {@link className} if this `` or its parent Component is unmounted and there's no other with the same name being deleted.
+ * `"none"` is a special value that deactivates the view transition name under that condition.
+ */
+ exit?: ViewTransitionClass | undefined;
+ /**
+ * "auto" will automatically assign a view-transition-name to the inner DOM node.
+ * That way you can add a View Transition to a Component without controlling its DOM nodes styling otherwise.
+ *
+ * A difference between this and the browser's built-in view-transition-name: auto is that switching the DOM nodes within the `` component preserves the same name so this example cross-fades between the DOM nodes instead of causing an exit and enter.
+ * @default "auto"
+ */
+ name?: "auto" | (string & {}) | undefined;
+ /**
+ * The `` or its parent Component is mounted and there's no other `` with the same name being deleted.
+ */
+ onEnter?: (instance: ViewTransitionInstance, types: Array) => void;
+ /**
+ * The `` or its parent Component is unmounted and there's no other `` with the same name being deleted.
+ */
+ onExit?: (instance: ViewTransitionInstance, types: Array) => void;
+ /**
+ * This `` is being mounted and another `` instance with the same name is being unmounted elsewhere.
+ */
+ onShare?: (instance: ViewTransitionInstance, types: Array) => void;
+ /**
+ * The content of `` has changed either due to DOM mutations or because an inner child `` has resized.
+ */
+ onUpdate?: (instance: ViewTransitionInstance, types: Array) => void;
+ ref?: Ref | undefined;
+ /**
+ * Combined with {@link className} if this `` is being mounted and another instance with the same name is being unmounted elsewhere.
+ * `"none"` is a special value that deactivates the view transition name under that condition.
+ */
+ share?: ViewTransitionClass | undefined;
+ /**
+ * Combined with {@link className} if the content of this `` has changed either due to DOM mutations or because an inner child has resized.
+ * `"none"` is a special value that deactivates the view transition name under that condition.
+ */
+ update?: ViewTransitionClass | undefined;
+ }
+
+ /**
+ * Opt-in for using {@link https://developer.mozilla.org/en-US/docs/Web/API/View_Transition_API View Transitions} in React.
+ * View Transitions only trigger for async updates like {@link startTransition}, {@link useDeferredValue}, Actions or <{@link Suspense}> revealing from fallback to content.
+ * Synchronous updates provide an opt-out but also guarantee that they commit immediately which View Transitions can't.
+ *
+ * @see {@link https://github.com/facebook/react/pull/31975}
+ */
+ export const unstable_ViewTransition: ExoticComponent;
+
+ export function unstable_addTransitionType(type: string): void;
+
+ // @enableGestureTransition
+ // Implemented by the specific renderer e.g. `react-dom`.
+ // Keep in mind that augmented interfaces merge their JSDoc so if you put
+ // JSDoc here and in the renderer, the IDE will display both.
+ export interface GestureProvider {}
+ export interface GestureOptions {
+ rangeStart?: number | undefined;
+ rangeEnd?: number | undefined;
+ }
+ /** */
+ export function unstable_startGestureTransition(
+ provider: GestureProvider,
+ scope: () => void,
+ options?: GestureOptions,
+ ): () => void;
+
+ // @enableFragmentRefs
+ export interface FragmentInstance {}
+
+ export interface FragmentProps {
+ ref?: Ref | undefined;
+ }
+
+ // @enableActivity
+ export interface ActivityProps {
+ /**
+ * @default "visible"
+ */
+ mode?:
+ | "hidden"
+ | "visible"
+ | undefined;
+ children: ReactNode;
+ }
+
+ /** */
+ export const unstable_Activity: ExoticComponent;
+
+ // @enableSrcObject
+ interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_IMG_SRC_TYPES {
+ srcObject: Blob;
+ }
+
+ interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_MEDIA_SRC_TYPES {
+ srcObject: Blob | MediaSource | MediaStream;
+ }
+}
diff --git a/node_modules/@types/react/global.d.ts b/node_modules/@types/react/global.d.ts
new file mode 100644
index 000000000..6770d08e3
--- /dev/null
+++ b/node_modules/@types/react/global.d.ts
@@ -0,0 +1,165 @@
+/*
+React projects that don't include the DOM library need these interfaces to compile.
+React Native applications use React, but there is no DOM available. The JavaScript runtime
+is ES6/ES2015 only. These definitions allow such projects to compile with only `--lib ES6`.
+
+Warning: all of these interfaces are empty. If you want type definitions for various properties
+(such as HTMLInputElement.prototype.value), you need to add `--lib DOM` (via command line or tsconfig.json).
+*/
+
+interface Event {}
+interface AnimationEvent extends Event {}
+interface ClipboardEvent extends Event {}
+interface CompositionEvent extends Event {}
+interface DragEvent extends Event {}
+interface FocusEvent extends Event {}
+interface InputEvent extends Event {}
+interface KeyboardEvent extends Event {}
+interface MouseEvent extends Event {}
+interface TouchEvent extends Event {}
+interface PointerEvent extends Event {}
+interface ToggleEvent extends Event {}
+interface TransitionEvent extends Event {}
+interface UIEvent extends Event {}
+interface WheelEvent extends Event {}
+
+interface EventTarget {}
+interface Document {}
+interface DataTransfer {}
+interface StyleMedia {}
+
+interface Element {}
+interface DocumentFragment {}
+
+interface HTMLElement extends Element {}
+interface HTMLAnchorElement extends HTMLElement {}
+interface HTMLAreaElement extends HTMLElement {}
+interface HTMLAudioElement extends HTMLElement {}
+interface HTMLBaseElement extends HTMLElement {}
+interface HTMLBodyElement extends HTMLElement {}
+interface HTMLBRElement extends HTMLElement {}
+interface HTMLButtonElement extends HTMLElement {}
+interface HTMLCanvasElement extends HTMLElement {}
+interface HTMLDataElement extends HTMLElement {}
+interface HTMLDataListElement extends HTMLElement {}
+interface HTMLDetailsElement extends HTMLElement {}
+interface HTMLDialogElement extends HTMLElement {}
+interface HTMLDivElement extends HTMLElement {}
+interface HTMLDListElement extends HTMLElement {}
+interface HTMLEmbedElement extends HTMLElement {}
+interface HTMLFieldSetElement extends HTMLElement {}
+interface HTMLFormElement extends HTMLElement {}
+interface HTMLHeadingElement extends HTMLElement {}
+interface HTMLHeadElement extends HTMLElement {}
+interface HTMLHRElement extends HTMLElement {}
+interface HTMLHtmlElement extends HTMLElement {}
+interface HTMLIFrameElement extends HTMLElement {}
+interface HTMLImageElement extends HTMLElement {}
+interface HTMLInputElement extends HTMLElement {}
+interface HTMLModElement extends HTMLElement {}
+interface HTMLLabelElement extends HTMLElement {}
+interface HTMLLegendElement extends HTMLElement {}
+interface HTMLLIElement extends HTMLElement {}
+interface HTMLLinkElement extends HTMLElement {}
+interface HTMLMapElement extends HTMLElement {}
+interface HTMLMetaElement extends HTMLElement {}
+interface HTMLMeterElement extends HTMLElement {}
+interface HTMLObjectElement extends HTMLElement {}
+interface HTMLOListElement extends HTMLElement {}
+interface HTMLOptGroupElement extends HTMLElement {}
+interface HTMLOptionElement extends HTMLElement {}
+interface HTMLOutputElement extends HTMLElement {}
+interface HTMLParagraphElement extends HTMLElement {}
+interface HTMLParamElement extends HTMLElement {}
+interface HTMLPreElement extends HTMLElement {}
+interface HTMLProgressElement extends HTMLElement {}
+interface HTMLQuoteElement extends HTMLElement {}
+interface HTMLSlotElement extends HTMLElement {}
+interface HTMLScriptElement extends HTMLElement {}
+interface HTMLSelectElement extends HTMLElement {}
+interface HTMLSourceElement extends HTMLElement {}
+interface HTMLSpanElement extends HTMLElement {}
+interface HTMLStyleElement extends HTMLElement {}
+interface HTMLTableElement extends HTMLElement {}
+interface HTMLTableColElement extends HTMLElement {}
+interface HTMLTableDataCellElement extends HTMLElement {}
+interface HTMLTableHeaderCellElement extends HTMLElement {}
+interface HTMLTableRowElement extends HTMLElement {}
+interface HTMLTableSectionElement extends HTMLElement {}
+interface HTMLTemplateElement extends HTMLElement {}
+interface HTMLTextAreaElement extends HTMLElement {}
+interface HTMLTimeElement extends HTMLElement {}
+interface HTMLTitleElement extends HTMLElement {}
+interface HTMLTrackElement extends HTMLElement {}
+interface HTMLUListElement extends HTMLElement {}
+interface HTMLVideoElement extends HTMLElement {}
+interface HTMLWebViewElement extends HTMLElement {}
+
+interface SVGElement extends Element {}
+interface SVGSVGElement extends SVGElement {}
+interface SVGCircleElement extends SVGElement {}
+interface SVGClipPathElement extends SVGElement {}
+interface SVGDefsElement extends SVGElement {}
+interface SVGDescElement extends SVGElement {}
+interface SVGEllipseElement extends SVGElement {}
+interface SVGFEBlendElement extends SVGElement {}
+interface SVGFEColorMatrixElement extends SVGElement {}
+interface SVGFEComponentTransferElement extends SVGElement {}
+interface SVGFECompositeElement extends SVGElement {}
+interface SVGFEConvolveMatrixElement extends SVGElement {}
+interface SVGFEDiffuseLightingElement extends SVGElement {}
+interface SVGFEDisplacementMapElement extends SVGElement {}
+interface SVGFEDistantLightElement extends SVGElement {}
+interface SVGFEDropShadowElement extends SVGElement {}
+interface SVGFEFloodElement extends SVGElement {}
+interface SVGFEFuncAElement extends SVGElement {}
+interface SVGFEFuncBElement extends SVGElement {}
+interface SVGFEFuncGElement extends SVGElement {}
+interface SVGFEFuncRElement extends SVGElement {}
+interface SVGFEGaussianBlurElement extends SVGElement {}
+interface SVGFEImageElement extends SVGElement {}
+interface SVGFEMergeElement extends SVGElement {}
+interface SVGFEMergeNodeElement extends SVGElement {}
+interface SVGFEMorphologyElement extends SVGElement {}
+interface SVGFEOffsetElement extends SVGElement {}
+interface SVGFEPointLightElement extends SVGElement {}
+interface SVGFESpecularLightingElement extends SVGElement {}
+interface SVGFESpotLightElement extends SVGElement {}
+interface SVGFETileElement extends SVGElement {}
+interface SVGFETurbulenceElement extends SVGElement {}
+interface SVGFilterElement extends SVGElement {}
+interface SVGForeignObjectElement extends SVGElement {}
+interface SVGGElement extends SVGElement {}
+interface SVGImageElement extends SVGElement {}
+interface SVGLineElement extends SVGElement {}
+interface SVGLinearGradientElement extends SVGElement {}
+interface SVGMarkerElement extends SVGElement {}
+interface SVGMaskElement extends SVGElement {}
+interface SVGMetadataElement extends SVGElement {}
+interface SVGPathElement extends SVGElement {}
+interface SVGPatternElement extends SVGElement {}
+interface SVGPolygonElement extends SVGElement {}
+interface SVGPolylineElement extends SVGElement {}
+interface SVGRadialGradientElement extends SVGElement {}
+interface SVGRectElement extends SVGElement {}
+interface SVGSetElement extends SVGElement {}
+interface SVGStopElement extends SVGElement {}
+interface SVGSwitchElement extends SVGElement {}
+interface SVGSymbolElement extends SVGElement {}
+interface SVGTextElement extends SVGElement {}
+interface SVGTextPathElement extends SVGElement {}
+interface SVGTSpanElement extends SVGElement {}
+interface SVGUseElement extends SVGElement {}
+interface SVGViewElement extends SVGElement {}
+
+interface FormData {}
+interface Text {}
+interface TouchList {}
+interface WebGLRenderingContext {}
+interface WebGL2RenderingContext {}
+
+interface TrustedHTML {}
+
+interface Blob {}
+interface MediaStream {}
+interface MediaSource {}
diff --git a/node_modules/@types/react/index.d.ts b/node_modules/@types/react/index.d.ts
new file mode 100644
index 000000000..403c8ec58
--- /dev/null
+++ b/node_modules/@types/react/index.d.ts
@@ -0,0 +1,4252 @@
+// NOTE: Users of the `experimental` builds of React should add a reference
+// to 'react/experimental' in their project. See experimental.d.ts's top comment
+// for reference and documentation on how exactly to do it.
+
+///
+
+import * as CSS from "csstype";
+
+type NativeAnimationEvent = AnimationEvent;
+type NativeClipboardEvent = ClipboardEvent;
+type NativeCompositionEvent = CompositionEvent;
+type NativeDragEvent = DragEvent;
+type NativeFocusEvent = FocusEvent;
+type NativeInputEvent = InputEvent;
+type NativeKeyboardEvent = KeyboardEvent;
+type NativeMouseEvent = MouseEvent;
+type NativeTouchEvent = TouchEvent;
+type NativePointerEvent = PointerEvent;
+type NativeToggleEvent = ToggleEvent;
+type NativeTransitionEvent = TransitionEvent;
+type NativeUIEvent = UIEvent;
+type NativeWheelEvent = WheelEvent;
+
+/**
+ * Used to represent DOM API's where users can either pass
+ * true or false as a boolean or as its equivalent strings.
+ */
+type Booleanish = boolean | "true" | "false";
+
+/**
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/crossorigin MDN}
+ */
+type CrossOrigin = "anonymous" | "use-credentials" | "" | undefined;
+
+declare const UNDEFINED_VOID_ONLY: unique symbol;
+
+/**
+ * @internal Use `Awaited` instead
+ */
+// Helper type to enable `Awaited`.
+// Must be a copy of the non-thenables of `ReactNode`.
+type AwaitedReactNode =
+ | React.ReactElement
+ | string
+ | number
+ | bigint
+ | Iterable
+ | React.ReactPortal
+ | boolean
+ | null
+ | undefined
+ | React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_REACT_NODES[
+ keyof React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_REACT_NODES
+ ];
+
+/**
+ * The function returned from an effect passed to {@link React.useEffect useEffect},
+ * which can be used to clean up the effect when the component unmounts.
+ *
+ * @see {@link https://react.dev/reference/react/useEffect React Docs}
+ */
+type Destructor = () => void | { [UNDEFINED_VOID_ONLY]: never };
+type VoidOrUndefinedOnly = void | { [UNDEFINED_VOID_ONLY]: never };
+
+// eslint-disable-next-line @definitelytyped/export-just-namespace
+export = React;
+export as namespace React;
+
+declare namespace React {
+ //
+ // React Elements
+ // ----------------------------------------------------------------------
+
+ /**
+ * Used to retrieve the possible components which accept a given set of props.
+ *
+ * Can be passed no type parameters to get a union of all possible components
+ * and tags.
+ *
+ * Is a superset of {@link ComponentType}.
+ *
+ * @template P The props to match against. If not passed, defaults to any.
+ * @template Tag An optional tag to match against. If not passed, attempts to match against all possible tags.
+ *
+ * @example
+ *
+ * ```tsx
+ * // All components and tags (img, embed etc.)
+ * // which accept `src`
+ * type SrcComponents = ElementType<{ src: any }>;
+ * ```
+ *
+ * @example
+ *
+ * ```tsx
+ * // All components
+ * type AllComponents = ElementType;
+ * ```
+ *
+ * @example
+ *
+ * ```tsx
+ * // All custom components which match `src`, and tags which
+ * // match `src`, narrowed down to just `audio` and `embed`
+ * type SrcComponents = ElementType<{ src: any }, 'audio' | 'embed'>;
+ * ```
+ */
+ type ElementType
=
+ | { [K in Tag]: P extends JSX.IntrinsicElements[K] ? K : never }[Tag]
+ | ComponentType
;
+
+ /**
+ * Represents any user-defined component, either as a function or a class.
+ *
+ * Similar to {@link JSXElementConstructor}, but with extra properties like
+ * {@link FunctionComponent.defaultProps defaultProps }.
+ *
+ * @template P The props the component accepts.
+ *
+ * @see {@link ComponentClass}
+ * @see {@link FunctionComponent}
+ */
+ type ComponentType
= ComponentClass
| FunctionComponent
;
+
+ /**
+ * Represents any user-defined component, either as a function or a class.
+ *
+ * Similar to {@link ComponentType}, but without extra properties like
+ * {@link FunctionComponent.defaultProps defaultProps }.
+ *
+ * @template P The props the component accepts.
+ */
+ type JSXElementConstructor
=
+ | ((
+ props: P,
+ ) => ReactNode | Promise)
+ // constructor signature must match React.Component
+ | (new(props: P, context: any) => Component);
+
+ /**
+ * Created by {@link createRef}, or {@link useRef} when passed `null`.
+ *
+ * @template T The type of the ref's value.
+ *
+ * @example
+ *
+ * ```tsx
+ * const ref = createRef();
+ *
+ * ref.current = document.createElement('div'); // Error
+ * ```
+ */
+ interface RefObject {
+ /**
+ * The current value of the ref.
+ */
+ current: T;
+ }
+
+ interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES {
+ }
+ /**
+ * A callback fired whenever the ref's value changes.
+ *
+ * @template T The type of the ref's value.
+ *
+ * @see {@link https://react.dev/reference/react-dom/components/common#ref-callback React Docs}
+ *
+ * @example
+ *
+ * ```tsx
+ *
console.log(node)} />
+ * ```
+ */
+ type RefCallback = {
+ bivarianceHack(
+ instance: T | null,
+ ):
+ | void
+ | (() => VoidOrUndefinedOnly)
+ | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[
+ keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES
+ ];
+ }["bivarianceHack"];
+
+ /**
+ * A union type of all possible shapes for React refs.
+ *
+ * @see {@link RefCallback}
+ * @see {@link RefObject}
+ */
+
+ type Ref = RefCallback | RefObject | null;
+ /**
+ * @deprecated Use `Ref` instead. String refs are no longer supported.
+ * If you're typing a library with support for React versions with string refs, use `RefAttributes['ref']` instead.
+ */
+ type LegacyRef = Ref;
+ /**
+ * @deprecated Use `ComponentRef` instead
+ *
+ * Retrieves the type of the 'ref' prop for a given component type or tag name.
+ *
+ * @template C The component type.
+ *
+ * @example
+ *
+ * ```tsx
+ * type MyComponentRef = React.ElementRef;
+ * ```
+ *
+ * @example
+ *
+ * ```tsx
+ * type DivRef = React.ElementRef<'div'>;
+ * ```
+ */
+ type ElementRef<
+ C extends
+ | ForwardRefExoticComponent
+ | { new(props: any, context: any): Component }
+ | ((props: any) => ReactNode)
+ | keyof JSX.IntrinsicElements,
+ > = ComponentRef;
+
+ type ComponentState = any;
+
+ /**
+ * A value which uniquely identifies a node among items in an array.
+ *
+ * @see {@link https://react.dev/learn/rendering-lists#keeping-list-items-in-order-with-key React Docs}
+ */
+ type Key = string | number | bigint;
+
+ /**
+ * @internal The props any component can receive.
+ * You don't have to add this type. All components automatically accept these props.
+ * ```tsx
+ * const Component = () => ;
+ *
+ * ```
+ *
+ * WARNING: The implementation of a component will never have access to these attributes.
+ * The following example would be incorrect usage because {@link Component} would never have access to `key`:
+ * ```tsx
+ * const Component = (props: React.Attributes) => props.key;
+ * ```
+ */
+ interface Attributes {
+ key?: Key | null | undefined;
+ }
+ /**
+ * The props any component accepting refs can receive.
+ * Class components, built-in browser components (e.g. `div`) and forwardRef components can receive refs and automatically accept these props.
+ * ```tsx
+ * const Component = forwardRef(() => );
+ * console.log(current)} />
+ * ```
+ *
+ * You only need this type if you manually author the types of props that need to be compatible with legacy refs.
+ * ```tsx
+ * interface Props extends React.RefAttributes {}
+ * declare const Component: React.FunctionComponent;
+ * ```
+ *
+ * Otherwise it's simpler to directly use {@link Ref} since you can safely use the
+ * props type to describe to props that a consumer can pass to the component
+ * as well as describing the props the implementation of a component "sees".
+ * {@link RefAttributes} is generally not safe to describe both consumer and seen props.
+ *
+ * ```tsx
+ * interface Props extends {
+ * ref?: React.Ref | undefined;
+ * }
+ * declare const Component: React.FunctionComponent;
+ * ```
+ *
+ * WARNING: The implementation of a component will not have access to the same type in versions of React supporting string refs.
+ * The following example would be incorrect usage because {@link Component} would never have access to a `ref` with type `string`
+ * ```tsx
+ * const Component = (props: React.RefAttributes) => props.ref;
+ * ```
+ */
+ interface RefAttributes extends Attributes {
+ /**
+ * Allows getting a ref to the component instance.
+ * Once the component unmounts, React will set `ref.current` to `null`
+ * (or call the ref with `null` if you passed a callback ref).
+ *
+ * @see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}
+ */
+ ref?: Ref | undefined;
+ }
+
+ /**
+ * Represents the built-in attributes available to class components.
+ */
+ interface ClassAttributes extends RefAttributes {
+ }
+
+ /**
+ * Represents a JSX element.
+ *
+ * Where {@link ReactNode} represents everything that can be rendered, `ReactElement`
+ * only represents JSX.
+ *
+ * @template P The type of the props object
+ * @template T The type of the component or tag
+ *
+ * @example
+ *
+ * ```tsx
+ * const element: ReactElement = ;
+ * ```
+ */
+ interface ReactElement<
+ P = unknown,
+ T extends string | JSXElementConstructor = string | JSXElementConstructor,
+ > {
+ type: T;
+ props: P;
+ key: string | null;
+ }
+
+ /**
+ * @deprecated
+ */
+ interface ReactComponentElement<
+ T extends keyof JSX.IntrinsicElements | JSXElementConstructor,
+ P = Pick, Exclude, "key" | "ref">>,
+ > extends ReactElement> {}
+
+ /**
+ * @deprecated Use `ReactElement>`
+ */
+ interface FunctionComponentElement
extends ReactElement> {
+ /**
+ * @deprecated Use `element.props.ref` instead.
+ */
+ ref?: ("ref" extends keyof P ? P extends { ref?: infer R | undefined } ? R : never : never) | undefined;
+ }
+
+ /**
+ * @deprecated Use `ReactElement>`
+ */
+ type CElement> = ComponentElement;
+ /**
+ * @deprecated Use `ReactElement>`
+ */
+ interface ComponentElement> extends ReactElement> {
+ /**
+ * @deprecated Use `element.props.ref` instead.
+ */
+ ref?: Ref | undefined;
+ }
+
+ /**
+ * @deprecated Use {@link ComponentElement} instead.
+ */
+ type ClassicElement
, T extends SVGElement>(
+ element: ReactSVGElement,
+ props?: P,
+ ...children: ReactNode[]
+ ): ReactSVGElement;
+ // DOM Element (has to be the last, because type checking stops at first overload that fits)
+ function cloneElement
;
+
+ /**
+ * Describes the props accepted by a Context {@link Provider}.
+ *
+ * @template T The type of the value the context provides.
+ */
+ interface ProviderProps {
+ value: T;
+ children?: ReactNode | undefined;
+ }
+
+ /**
+ * Describes the props accepted by a Context {@link Consumer}.
+ *
+ * @template T The type of the value the context provides.
+ */
+ interface ConsumerProps {
+ children: (value: T) => ReactNode;
+ }
+
+ /**
+ * An object masquerading as a component. These are created by functions
+ * like {@link forwardRef}, {@link memo}, and {@link createContext}.
+ *
+ * In order to make TypeScript work, we pretend that they are normal
+ * components.
+ *
+ * But they are, in fact, not callable - instead, they are objects which
+ * are treated specially by the renderer.
+ *
+ * @template P The props the component accepts.
+ */
+ interface ExoticComponent
{
+ (props: P): ReactNode;
+ readonly $$typeof: symbol;
+ }
+
+ /**
+ * An {@link ExoticComponent} with a `displayName` property applied to it.
+ *
+ * @template P The props the component accepts.
+ */
+ interface NamedExoticComponent
extends ExoticComponent
{
+ /**
+ * Used in debugging messages. You might want to set it
+ * explicitly if you want to display a different name for
+ * debugging purposes.
+ *
+ * @see {@link https://legacy.reactjs.org/docs/react-component.html#displayname Legacy React Docs}
+ */
+ displayName?: string | undefined;
+ }
+
+ /**
+ * An {@link ExoticComponent} with a `propTypes` property applied to it.
+ *
+ * @template P The props the component accepts.
+ */
+ interface ProviderExoticComponent
extends ExoticComponent
{
+ }
+
+ /**
+ * Used to retrieve the type of a context object from a {@link Context}.
+ *
+ * @template C The context object.
+ *
+ * @example
+ *
+ * ```tsx
+ * import { createContext } from 'react';
+ *
+ * const MyContext = createContext({ foo: 'bar' });
+ *
+ * type ContextType = ContextType;
+ * // ContextType = { foo: string }
+ * ```
+ */
+ type ContextType> = C extends Context ? T : never;
+
+ /**
+ * Wraps your components to specify the value of this context for all components inside.
+ *
+ * @see {@link https://react.dev/reference/react/createContext#provider React Docs}
+ *
+ * @example
+ *
+ * ```tsx
+ * import { createContext } from 'react';
+ *
+ * const ThemeContext = createContext('light');
+ *
+ * function App() {
+ * return (
+ *
+ *
+ *
+ * );
+ * }
+ * ```
+ */
+ type Provider = ProviderExoticComponent>;
+
+ /**
+ * The old way to read context, before {@link useContext} existed.
+ *
+ * @see {@link https://react.dev/reference/react/createContext#consumer React Docs}
+ *
+ * @example
+ *
+ * ```tsx
+ * import { UserContext } from './user-context';
+ *
+ * function Avatar() {
+ * return (
+ *
+ * {user => }
+ *
+ * );
+ * }
+ * ```
+ */
+ type Consumer = ExoticComponent>;
+
+ /**
+ * Context lets components pass information deep down without explicitly
+ * passing props.
+ *
+ * Created from {@link createContext}
+ *
+ * @see {@link https://react.dev/learn/passing-data-deeply-with-context React Docs}
+ * @see {@link https://react-typescript-cheatsheet.netlify.app/docs/basic/getting-started/context/ React TypeScript Cheatsheet}
+ *
+ * @example
+ *
+ * ```tsx
+ * import { createContext } from 'react';
+ *
+ * const ThemeContext = createContext('light');
+ * ```
+ */
+ interface Context extends Provider {
+ Provider: Provider;
+ Consumer: Consumer;
+ /**
+ * Used in debugging messages. You might want to set it
+ * explicitly if you want to display a different name for
+ * debugging purposes.
+ *
+ * @see {@link https://legacy.reactjs.org/docs/react-component.html#displayname Legacy React Docs}
+ */
+ displayName?: string | undefined;
+ }
+
+ /**
+ * Lets you create a {@link Context} that components can provide or read.
+ *
+ * @param defaultValue The value you want the context to have when there is no matching
+ * {@link Provider} in the tree above the component reading the context. This is meant
+ * as a "last resort" fallback.
+ *
+ * @see {@link https://react.dev/reference/react/createContext#reference React Docs}
+ * @see {@link https://react-typescript-cheatsheet.netlify.app/docs/basic/getting-started/context/ React TypeScript Cheatsheet}
+ *
+ * @example
+ *
+ * ```tsx
+ * import { createContext } from 'react';
+ *
+ * const ThemeContext = createContext('light');
+ * function App() {
+ * return (
+ *
+ *
+ *
+ * );
+ * }
+ * ```
+ */
+ function createContext(
+ // If you thought this should be optional, see
+ // https://github.com/DefinitelyTyped/DefinitelyTyped/pull/24509#issuecomment-382213106
+ defaultValue: T,
+ ): Context;
+
+ function isValidElement
(object: {} | null | undefined): object is ReactElement
;
+
+ const Children: {
+ map(
+ children: C | readonly C[],
+ fn: (child: C, index: number) => T,
+ ): C extends null | undefined ? C : Array>;
+ forEach(children: C | readonly C[], fn: (child: C, index: number) => void): void;
+ count(children: any): number;
+ only(children: C): C extends any[] ? never : C;
+ toArray(children: ReactNode | ReactNode[]): Array>;
+ };
+
+ export interface FragmentProps {
+ children?: React.ReactNode;
+ }
+ /**
+ * Lets you group elements without a wrapper node.
+ *
+ * @see {@link https://react.dev/reference/react/Fragment React Docs}
+ *
+ * @example
+ *
+ * ```tsx
+ * import { Fragment } from 'react';
+ *
+ *
+ *
+ *
+ * ```
+ */
+ const Fragment: ExoticComponent;
+
+ /**
+ * Lets you find common bugs in your components early during development.
+ *
+ * @see {@link https://react.dev/reference/react/StrictMode React Docs}
+ *
+ * @example
+ *
+ * ```tsx
+ * import { StrictMode } from 'react';
+ *
+ *
+ *
+ *
+ * ```
+ */
+ const StrictMode: ExoticComponent<{ children?: ReactNode | undefined }>;
+
+ /**
+ * The props accepted by {@link Suspense}.
+ *
+ * @see {@link https://react.dev/reference/react/Suspense React Docs}
+ */
+ interface SuspenseProps {
+ children?: ReactNode | undefined;
+
+ /** A fallback react tree to show when a Suspense child (like React.lazy) suspends */
+ fallback?: ReactNode;
+
+ /**
+ * A name for this Suspense boundary for instrumentation purposes.
+ * The name will help identify this boundary in React DevTools.
+ */
+ name?: string | undefined;
+ }
+
+ /**
+ * Lets you display a fallback until its children have finished loading.
+ *
+ * @see {@link https://react.dev/reference/react/Suspense React Docs}
+ *
+ * @example
+ *
+ * ```tsx
+ * import { Suspense } from 'react';
+ *
+ * }>
+ *
+ *
+ * ```
+ */
+ const Suspense: ExoticComponent;
+ const version: string;
+
+ /**
+ * The callback passed to {@link ProfilerProps.onRender}.
+ *
+ * @see {@link https://react.dev/reference/react/Profiler#onrender-callback React Docs}
+ */
+ type ProfilerOnRenderCallback = (
+ /**
+ * The string id prop of the {@link Profiler} tree that has just committed. This lets
+ * you identify which part of the tree was committed if you are using multiple
+ * profilers.
+ *
+ * @see {@link https://react.dev/reference/react/Profiler#onrender-callback React Docs}
+ */
+ id: string,
+ /**
+ * This lets you know whether the tree has just been mounted for the first time
+ * or re-rendered due to a change in props, state, or hooks.
+ *
+ * @see {@link https://react.dev/reference/react/Profiler#onrender-callback React Docs}
+ */
+ phase: "mount" | "update" | "nested-update",
+ /**
+ * The number of milliseconds spent rendering the {@link Profiler} and its descendants
+ * for the current update. This indicates how well the subtree makes use of
+ * memoization (e.g. {@link memo} and {@link useMemo}). Ideally this value should decrease
+ * significantly after the initial mount as many of the descendants will only need to
+ * re-render if their specific props change.
+ *
+ * @see {@link https://react.dev/reference/react/Profiler#onrender-callback React Docs}
+ */
+ actualDuration: number,
+ /**
+ * The number of milliseconds estimating how much time it would take to re-render the entire
+ * {@link Profiler} subtree without any optimizations. It is calculated by summing up the most
+ * recent render durations of each component in the tree. This value estimates a worst-case
+ * cost of rendering (e.g. the initial mount or a tree with no memoization). Compare
+ * {@link actualDuration} against it to see if memoization is working.
+ *
+ * @see {@link https://react.dev/reference/react/Profiler#onrender-callback React Docs}
+ */
+ baseDuration: number,
+ /**
+ * A numeric timestamp for when React began rendering the current update.
+ *
+ * @see {@link https://react.dev/reference/react/Profiler#onrender-callback React Docs}
+ */
+ startTime: number,
+ /**
+ * A numeric timestamp for when React committed the current update. This value is shared
+ * between all profilers in a commit, enabling them to be grouped if desirable.
+ *
+ * @see {@link https://react.dev/reference/react/Profiler#onrender-callback React Docs}
+ */
+ commitTime: number,
+ ) => void;
+
+ /**
+ * The props accepted by {@link Profiler}.
+ *
+ * @see {@link https://react.dev/reference/react/Profiler React Docs}
+ */
+ interface ProfilerProps {
+ children?: ReactNode | undefined;
+ id: string;
+ onRender: ProfilerOnRenderCallback;
+ }
+
+ /**
+ * Lets you measure rendering performance of a React tree programmatically.
+ *
+ * @see {@link https://react.dev/reference/react/Profiler#onrender-callback React Docs}
+ *
+ * @example
+ *
+ * ```tsx
+ *
+ *
+ *
+ * ```
+ */
+ const Profiler: ExoticComponent;
+
+ //
+ // Component API
+ // ----------------------------------------------------------------------
+
+ type ReactInstance = Component | Element;
+
+ // Base component for plain JS classes
+ interface Component
extends ComponentLifecycle {}
+ class Component {
+ /**
+ * If set, `this.context` will be set at runtime to the current value of the given Context.
+ *
+ * @example
+ *
+ * ```ts
+ * type MyContext = number
+ * const Ctx = React.createContext(0)
+ *
+ * class Foo extends React.Component {
+ * static contextType = Ctx
+ * context!: React.ContextType
+ * render () {
+ * return <>My context's value: {this.context};
+ * }
+ * }
+ * ```
+ *
+ * @see {@link https://react.dev/reference/react/Component#static-contexttype}
+ */
+ static contextType?: Context | undefined;
+
+ /**
+ * Ignored by React.
+ * @deprecated Only kept in types for backwards compatibility. Will be removed in a future major release.
+ */
+ static propTypes?: any;
+
+ /**
+ * If using React Context, re-declare this in your class to be the
+ * `React.ContextType` of your `static contextType`.
+ * Should be used with type annotation or static contextType.
+ *
+ * @example
+ * ```ts
+ * static contextType = MyContext
+ * // For TS pre-3.7:
+ * context!: React.ContextType
+ * // For TS 3.7 and above:
+ * declare context: React.ContextType
+ * ```
+ *
+ * @see {@link https://react.dev/reference/react/Component#context React Docs}
+ */
+ context: unknown;
+
+ // Keep in sync with constructor signature of JSXElementConstructor and ComponentClass.
+ constructor(props: P);
+ /**
+ * @param props
+ * @param context value of the parent {@link https://react.dev/reference/react/Component#context Context} specified
+ * in `contextType`.
+ */
+ // TODO: Ideally we'd infer the constructor signatur from `contextType`.
+ // Might be hard to ship without breaking existing code.
+ constructor(props: P, context: any);
+
+ // We MUST keep setState() as a unified signature because it allows proper checking of the method return type.
+ // See: https://github.com/DefinitelyTyped/DefinitelyTyped/issues/18365#issuecomment-351013257
+ // Also, the ` | S` allows intellisense to not be dumbisense
+ setState(
+ state: ((prevState: Readonly, props: Readonly
{
+ (props: P): ReactNode | Promise;
+ /**
+ * Ignored by React.
+ * @deprecated Only kept in types for backwards compatibility. Will be removed in a future major release.
+ */
+ propTypes?: any;
+ /**
+ * Used in debugging messages. You might want to set it
+ * explicitly if you want to display a different name for
+ * debugging purposes.
+ *
+ * @see {@link https://legacy.reactjs.org/docs/react-component.html#displayname Legacy React Docs}
+ *
+ * @example
+ *
+ * ```tsx
+ *
+ * const MyComponent: FC = () => {
+ * return
Hello!
+ * }
+ *
+ * MyComponent.displayName = 'MyAwesomeComponent'
+ * ```
+ */
+ displayName?: string | undefined;
+ }
+
+ /**
+ * The type of the ref received by a {@link ForwardRefRenderFunction}.
+ *
+ * @see {@link ForwardRefRenderFunction}
+ */
+ // Making T nullable is assuming the refs will be managed by React or the component impl will write it somewhere else.
+ // But this isn't necessarily true. We haven't heard complains about it yet and hopefully `forwardRef` is removed from React before we do.
+ type ForwardedRef = ((instance: T | null) => void) | RefObject | null;
+
+ /**
+ * The type of the function passed to {@link forwardRef}. This is considered different
+ * to a normal {@link FunctionComponent} because it receives an additional argument,
+ *
+ * @param props Props passed to the component, if any.
+ * @param ref A ref forwarded to the component of type {@link ForwardedRef}.
+ *
+ * @template T The type of the forwarded ref.
+ * @template P The type of the props the component accepts.
+ *
+ * @see {@link https://react-typescript-cheatsheet.netlify.app/docs/basic/getting-started/forward_and_create_ref/ React TypeScript Cheatsheet}
+ * @see {@link forwardRef}
+ */
+ interface ForwardRefRenderFunction {
+ (props: P, ref: ForwardedRef): ReactNode;
+ /**
+ * Used in debugging messages. You might want to set it
+ * explicitly if you want to display a different name for
+ * debugging purposes.
+ *
+ * Will show `ForwardRef(${Component.displayName || Component.name})`
+ * in devtools by default, but can be given its own specific name.
+ *
+ * @see {@link https://legacy.reactjs.org/docs/react-component.html#displayname Legacy React Docs}
+ */
+ displayName?: string | undefined;
+ /**
+ * Ignored by React.
+ * @deprecated Only kept in types for backwards compatibility. Will be removed in a future major release.
+ */
+ propTypes?: any;
+ }
+
+ /**
+ * Represents a component class in React.
+ *
+ * @template P The props the component accepts.
+ * @template S The internal state of the component.
+ */
+ interface ComponentClass
extends StaticLifecycle {
+ // constructor signature must match React.Component
+ new(
+ props: P,
+ /**
+ * Value of the parent {@link https://react.dev/reference/react/Component#context Context} specified
+ * in `contextType`.
+ */
+ context?: any,
+ ): Component;
+ /**
+ * Ignored by React.
+ * @deprecated Only kept in types for backwards compatibility. Will be removed in a future major release.
+ */
+ propTypes?: any;
+ contextType?: Context | undefined;
+ defaultProps?: Partial
| undefined;
+ /**
+ * Used in debugging messages. You might want to set it
+ * explicitly if you want to display a different name for
+ * debugging purposes.
+ *
+ * @see {@link https://legacy.reactjs.org/docs/react-component.html#displayname Legacy React Docs}
+ */
+ displayName?: string | undefined;
+ }
+
+ /**
+ * @deprecated Use `ClassicComponentClass` from `create-react-class`
+ *
+ * @see {@link https://legacy.reactjs.org/docs/react-without-es6.html Legacy React Docs}
+ * @see {@link https://www.npmjs.com/package/create-react-class `create-react-class` on npm}
+ */
+ interface ClassicComponentClass
extends ComponentClass
{
+ new(props: P): ClassicComponent;
+ getDefaultProps?(): P;
+ }
+
+ /**
+ * Used in {@link createElement} and {@link createFactory} to represent
+ * a class.
+ *
+ * An intersection type is used to infer multiple type parameters from
+ * a single argument, which is useful for many top-level API defs.
+ * See {@link https://github.com/Microsoft/TypeScript/issues/7234 this GitHub issue}
+ * for more info.
+ */
+ type ClassType, C extends ComponentClass
> =
+ & C
+ & (new(props: P, context: any) => T);
+
+ //
+ // Component Specs and Lifecycle
+ // ----------------------------------------------------------------------
+
+ // This should actually be something like `Lifecycle | DeprecatedLifecycle`,
+ // as React will _not_ call the deprecated lifecycle methods if any of the new lifecycle
+ // methods are present.
+ interface ComponentLifecycle extends NewLifecycle, DeprecatedLifecycle {
+ /**
+ * Called immediately after a component is mounted. Setting state here will trigger re-rendering.
+ */
+ componentDidMount?(): void;
+ /**
+ * Called to determine whether the change in props and state should trigger a re-render.
+ *
+ * `Component` always returns true.
+ * `PureComponent` implements a shallow comparison on props and state and returns true if any
+ * props or states have changed.
+ *
+ * If false is returned, {@link Component.render}, `componentWillUpdate`
+ * and `componentDidUpdate` will not be called.
+ */
+ shouldComponentUpdate?(nextProps: Readonly
, nextState: Readonly, nextContext: any): boolean;
+ /**
+ * Called immediately before a component is destroyed. Perform any necessary cleanup in this method, such as
+ * cancelled network requests, or cleaning up any DOM elements created in `componentDidMount`.
+ */
+ componentWillUnmount?(): void;
+ /**
+ * Catches exceptions generated in descendant components. Unhandled exceptions will cause
+ * the entire component tree to unmount.
+ */
+ componentDidCatch?(error: Error, errorInfo: ErrorInfo): void;
+ }
+
+ // Unfortunately, we have no way of declaring that the component constructor must implement this
+ interface StaticLifecycle {
+ getDerivedStateFromProps?: GetDerivedStateFromProps | undefined;
+ getDerivedStateFromError?: GetDerivedStateFromError | undefined;
+ }
+
+ type GetDerivedStateFromProps =
+ /**
+ * Returns an update to a component's state based on its new props and old state.
+ *
+ * Note: its presence prevents any of the deprecated lifecycle methods from being invoked
+ */
+ (nextProps: Readonly
, prevState: S) => Partial | null;
+
+ type GetDerivedStateFromError =
+ /**
+ * This lifecycle is invoked after an error has been thrown by a descendant component.
+ * It receives the error that was thrown as a parameter and should return a value to update state.
+ *
+ * Note: its presence prevents any of the deprecated lifecycle methods from being invoked
+ */
+ (error: any) => Partial | null;
+
+ // This should be "infer SS" but can't use it yet
+ interface NewLifecycle {
+ /**
+ * Runs before React applies the result of {@link Component.render render} to the document, and
+ * returns an object to be given to {@link componentDidUpdate}. Useful for saving
+ * things such as scroll position before {@link Component.render render} causes changes to it.
+ *
+ * Note: the presence of this method prevents any of the deprecated
+ * lifecycle events from running.
+ */
+ getSnapshotBeforeUpdate?(prevProps: Readonly
, prevState: Readonly): SS | null;
+ /**
+ * Called immediately after updating occurs. Not called for the initial render.
+ *
+ * The snapshot is only present if {@link getSnapshotBeforeUpdate} is present and returns non-null.
+ */
+ componentDidUpdate?(prevProps: Readonly
, prevState: Readonly, snapshot?: SS): void;
+ }
+
+ interface DeprecatedLifecycle {
+ /**
+ * Called immediately before mounting occurs, and before {@link Component.render}.
+ * Avoid introducing any side-effects or subscriptions in this method.
+ *
+ * Note: the presence of {@link NewLifecycle.getSnapshotBeforeUpdate getSnapshotBeforeUpdate}
+ * or {@link StaticLifecycle.getDerivedStateFromProps getDerivedStateFromProps} prevents
+ * this from being invoked.
+ *
+ * @deprecated 16.3, use {@link ComponentLifecycle.componentDidMount componentDidMount} or the constructor instead; will stop working in React 17
+ * @see {@link https://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#initializing-state}
+ * @see {@link https://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path}
+ */
+ componentWillMount?(): void;
+ /**
+ * Called immediately before mounting occurs, and before {@link Component.render}.
+ * Avoid introducing any side-effects or subscriptions in this method.
+ *
+ * This method will not stop working in React 17.
+ *
+ * Note: the presence of {@link NewLifecycle.getSnapshotBeforeUpdate getSnapshotBeforeUpdate}
+ * or {@link StaticLifecycle.getDerivedStateFromProps getDerivedStateFromProps} prevents
+ * this from being invoked.
+ *
+ * @deprecated 16.3, use {@link ComponentLifecycle.componentDidMount componentDidMount} or the constructor instead
+ * @see {@link https://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#initializing-state}
+ * @see {@link https://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path}
+ */
+ UNSAFE_componentWillMount?(): void;
+ /**
+ * Called when the component may be receiving new props.
+ * React may call this even if props have not changed, so be sure to compare new and existing
+ * props if you only want to handle changes.
+ *
+ * Calling {@link Component.setState} generally does not trigger this method.
+ *
+ * Note: the presence of {@link NewLifecycle.getSnapshotBeforeUpdate getSnapshotBeforeUpdate}
+ * or {@link StaticLifecycle.getDerivedStateFromProps getDerivedStateFromProps} prevents
+ * this from being invoked.
+ *
+ * @deprecated 16.3, use static {@link StaticLifecycle.getDerivedStateFromProps getDerivedStateFromProps} instead; will stop working in React 17
+ * @see {@link https://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#updating-state-based-on-props}
+ * @see {@link https://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path}
+ */
+ componentWillReceiveProps?(nextProps: Readonly
, nextContext: any): void;
+ /**
+ * Called when the component may be receiving new props.
+ * React may call this even if props have not changed, so be sure to compare new and existing
+ * props if you only want to handle changes.
+ *
+ * Calling {@link Component.setState} generally does not trigger this method.
+ *
+ * This method will not stop working in React 17.
+ *
+ * Note: the presence of {@link NewLifecycle.getSnapshotBeforeUpdate getSnapshotBeforeUpdate}
+ * or {@link StaticLifecycle.getDerivedStateFromProps getDerivedStateFromProps} prevents
+ * this from being invoked.
+ *
+ * @deprecated 16.3, use static {@link StaticLifecycle.getDerivedStateFromProps getDerivedStateFromProps} instead
+ * @see {@link https://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#updating-state-based-on-props}
+ * @see {@link https://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path}
+ */
+ UNSAFE_componentWillReceiveProps?(nextProps: Readonly
, nextContext: any): void;
+ /**
+ * Called immediately before rendering when new props or state is received. Not called for the initial render.
+ *
+ * Note: You cannot call {@link Component.setState} here.
+ *
+ * Note: the presence of {@link NewLifecycle.getSnapshotBeforeUpdate getSnapshotBeforeUpdate}
+ * or {@link StaticLifecycle.getDerivedStateFromProps getDerivedStateFromProps} prevents
+ * this from being invoked.
+ *
+ * @deprecated 16.3, use getSnapshotBeforeUpdate instead; will stop working in React 17
+ * @see {@link https://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#reading-dom-properties-before-an-update}
+ * @see {@link https://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path}
+ */
+ componentWillUpdate?(nextProps: Readonly
, nextState: Readonly, nextContext: any): void;
+ /**
+ * Called immediately before rendering when new props or state is received. Not called for the initial render.
+ *
+ * Note: You cannot call {@link Component.setState} here.
+ *
+ * This method will not stop working in React 17.
+ *
+ * Note: the presence of {@link NewLifecycle.getSnapshotBeforeUpdate getSnapshotBeforeUpdate}
+ * or {@link StaticLifecycle.getDerivedStateFromProps getDerivedStateFromProps} prevents
+ * this from being invoked.
+ *
+ * @deprecated 16.3, use getSnapshotBeforeUpdate instead
+ * @see {@link https://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#reading-dom-properties-before-an-update}
+ * @see {@link https://legacy.reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path}
+ */
+ UNSAFE_componentWillUpdate?(nextProps: Readonly
, nextState: Readonly, nextContext: any): void;
+ }
+
+ function createRef(): RefObject;
+
+ /**
+ * The type of the component returned from {@link forwardRef}.
+ *
+ * @template P The props the component accepts, if any.
+ *
+ * @see {@link ExoticComponent}
+ */
+ interface ForwardRefExoticComponent
extends NamedExoticComponent
{
+ /**
+ * Ignored by React.
+ * @deprecated Only kept in types for backwards compatibility. Will be removed in a future major release.
+ */
+ propTypes?: any;
+ }
+
+ /**
+ * Lets your component expose a DOM node to a parent component
+ * using a ref.
+ *
+ * @see {@link https://react.dev/reference/react/forwardRef React Docs}
+ * @see {@link https://react-typescript-cheatsheet.netlify.app/docs/basic/getting-started/forward_and_create_ref/ React TypeScript Cheatsheet}
+ *
+ * @param render See the {@link ForwardRefRenderFunction}.
+ *
+ * @template T The type of the DOM node.
+ * @template P The props the component accepts, if any.
+ *
+ * @example
+ *
+ * ```tsx
+ * interface Props {
+ * children?: ReactNode;
+ * type: "submit" | "button";
+ * }
+ *
+ * export const FancyButton = forwardRef((props, ref) => (
+ *
+ * ));
+ * ```
+ */
+ function forwardRef(
+ render: ForwardRefRenderFunction>,
+ ): ForwardRefExoticComponent & RefAttributes>;
+
+ /**
+ * Omits the 'ref' attribute from the given props object.
+ *
+ * @template Props The props object type.
+ */
+ type PropsWithoutRef =
+ // Omit would not be sufficient for this. We'd like to avoid unnecessary mapping and need a distributive conditional to support unions.
+ // see: https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types
+ // https://github.com/Microsoft/TypeScript/issues/28339
+ Props extends any ? ("ref" extends keyof Props ? Omit : Props) : Props;
+ /**
+ * Ensures that the props do not include string ref, which cannot be forwarded
+ * @deprecated Use `Props` directly. `PropsWithRef` is just an alias for `Props`
+ */
+ type PropsWithRef = Props;
+
+ type PropsWithChildren
= P & { children?: ReactNode | undefined };
+
+ /**
+ * Used to retrieve the props a component accepts. Can either be passed a string,
+ * indicating a DOM element (e.g. 'div', 'span', etc.) or the type of a React
+ * component.
+ *
+ * It's usually better to use {@link ComponentPropsWithRef} or {@link ComponentPropsWithoutRef}
+ * instead of this type, as they let you be explicit about whether or not to include
+ * the `ref` prop.
+ *
+ * @see {@link https://react-typescript-cheatsheet.netlify.app/docs/react-types/componentprops/ React TypeScript Cheatsheet}
+ *
+ * @example
+ *
+ * ```tsx
+ * // Retrieves the props an 'input' element accepts
+ * type InputProps = React.ComponentProps<'input'>;
+ * ```
+ *
+ * @example
+ *
+ * ```tsx
+ * const MyComponent = (props: { foo: number, bar: string }) =>
;
+ *
+ * // Retrieves the props 'MyComponent' accepts
+ * type MyComponentProps = React.ComponentProps;
+ * ```
+ */
+ type ComponentProps> = T extends
+ JSXElementConstructor ? Props
+ : T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T]
+ : {};
+
+ /**
+ * Used to retrieve the props a component accepts with its ref. Can either be
+ * passed a string, indicating a DOM element (e.g. 'div', 'span', etc.) or the
+ * type of a React component.
+ *
+ * @see {@link https://react-typescript-cheatsheet.netlify.app/docs/react-types/componentprops/ React TypeScript Cheatsheet}
+ *
+ * @example
+ *
+ * ```tsx
+ * // Retrieves the props an 'input' element accepts
+ * type InputProps = React.ComponentPropsWithRef<'input'>;
+ * ```
+ *
+ * @example
+ *
+ * ```tsx
+ * const MyComponent = (props: { foo: number, bar: string }) => ;
+ *
+ * // Retrieves the props 'MyComponent' accepts
+ * type MyComponentPropsWithRef = React.ComponentPropsWithRef;
+ * ```
+ */
+ type ComponentPropsWithRef = T extends JSXElementConstructor
+ // If it's a class i.e. newable we're dealing with a class component
+ ? T extends abstract new(args: any) => any ? PropsWithoutRef & RefAttributes>
+ : Props
+ : ComponentProps;
+ /**
+ * Used to retrieve the props a custom component accepts with its ref.
+ *
+ * Unlike {@link ComponentPropsWithRef}, this only works with custom
+ * components, i.e. components you define yourself. This is to improve
+ * type-checking performance.
+ *
+ * @example
+ *
+ * ```tsx
+ * const MyComponent = (props: { foo: number, bar: string }) => ;
+ *
+ * // Retrieves the props 'MyComponent' accepts
+ * type MyComponentPropsWithRef = React.CustomComponentPropsWithRef;
+ * ```
+ */
+ type CustomComponentPropsWithRef = T extends JSXElementConstructor
+ // If it's a class i.e. newable we're dealing with a class component
+ ? T extends abstract new(args: any) => any ? PropsWithoutRef & RefAttributes>
+ : Props
+ : never;
+
+ /**
+ * Used to retrieve the props a component accepts without its ref. Can either be
+ * passed a string, indicating a DOM element (e.g. 'div', 'span', etc.) or the
+ * type of a React component.
+ *
+ * @see {@link https://react-typescript-cheatsheet.netlify.app/docs/react-types/componentprops/ React TypeScript Cheatsheet}
+ *
+ * @example
+ *
+ * ```tsx
+ * // Retrieves the props an 'input' element accepts
+ * type InputProps = React.ComponentPropsWithoutRef<'input'>;
+ * ```
+ *
+ * @example
+ *
+ * ```tsx
+ * const MyComponent = (props: { foo: number, bar: string }) => ;
+ *
+ * // Retrieves the props 'MyComponent' accepts
+ * type MyComponentPropsWithoutRef = React.ComponentPropsWithoutRef;
+ * ```
+ */
+ type ComponentPropsWithoutRef = PropsWithoutRef>;
+
+ /**
+ * Retrieves the type of the 'ref' prop for a given component type or tag name.
+ *
+ * @template C The component type.
+ *
+ * @example
+ *
+ * ```tsx
+ * type MyComponentRef = React.ComponentRef;
+ * ```
+ *
+ * @example
+ *
+ * ```tsx
+ * type DivRef = React.ComponentRef<'div'>;
+ * ```
+ */
+ type ComponentRef = ComponentPropsWithRef extends RefAttributes ? Method
+ : never;
+
+ // will show `Memo(${Component.displayName || Component.name})` in devtools by default,
+ // but can be given its own specific name
+ type MemoExoticComponent> = NamedExoticComponent> & {
+ readonly type: T;
+ };
+
+ /**
+ * Lets you skip re-rendering a component when its props are unchanged.
+ *
+ * @see {@link https://react.dev/reference/react/memo React Docs}
+ *
+ * @param Component The component to memoize.
+ * @param propsAreEqual A function that will be used to determine if the props have changed.
+ *
+ * @example
+ *
+ * ```tsx
+ * import { memo } from 'react';
+ *
+ * const SomeComponent = memo(function SomeComponent(props: { foo: string }) {
+ * // ...
+ * });
+ * ```
+ */
+ function memo