@fuadnafiz98/grab 0.1.0

package/dist/copy-content-DDha1TvA.d.ts

@@ -0,0 +1,864 @@
+/**
+ * @license MIT
+ *
+ * Copyright (c) 2025 Aiden Bai
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { ReactNode } from "react";
+import ReactReconciler from "react-reconciler";
+
+//#region ../../node_modules/.pnpm/solid-js@1.9.12/node_modules/solid-js/types/reactive/observable.d.ts
+declare global {
+  interface SymbolConstructor {
+    readonly observable: symbol;
+  }
+}
+//#endregion
+//#region ../../node_modules/.pnpm/solid-js@1.9.12/node_modules/solid-js/types/index.d.ts
+declare global {
+  var Solid$$: boolean;
+}
+//#endregion
+//#region src/types.d.ts
+interface Position {
+  x: number;
+  y: number;
+}
+interface ElementAtPointOptions {
+  container?: Element;
+  filter?: (element: Element) => boolean;
+}
+interface ElementBounds {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  borderRadius: string;
+}
+type DeepPartial<T> = { [P in keyof T]?: T[P] extends object ? T[P] extends ((...args: unknown[]) => unknown) ? T[P] : DeepPartial<T[P]> : T[P] };
+interface Theme {
+  /**
+   * Globally toggle the entire overlay
+   * @default true
+   */
+  enabled?: boolean;
+  /**
+   * Base hue (0-360) used to generate colors throughout the interface using HSL color space
+   * @default 0
+   */
+  hue?: number;
+  /**
+   * The highlight box that appears when hovering over an element before selecting it
+   */
+  selectionBox?: {
+    /**
+     * Whether to show the selection highlight
+     * @default true
+     */
+    enabled?: boolean;
+  };
+  /**
+   * The rectangular selection area that appears when clicking and dragging to select multiple elements
+   */
+  dragBox?: {
+    /**
+     * Whether to show the drag selection box
+     * @default true
+     */
+    enabled?: boolean;
+  };
+  /**
+   * Brief flash/highlight boxes that appear on elements immediately after they're successfully grabbed/copied
+   */
+  grabbedBoxes?: {
+    /**
+     * Whether to show these success flash effects
+     * @default true
+     */
+    enabled?: boolean;
+  };
+  /**
+   * The floating label that follows the cursor showing information about the currently hovered element
+   */
+  elementLabel?: {
+    /**
+     * Whether to show the label
+     * @default true
+     */
+    enabled?: boolean;
+  };
+  /**
+   * The floating toolbar that allows toggling React Grab activation
+   */
+  toolbar?: {
+    /**
+     * Whether to show the toolbar
+     * @default true
+     */
+    enabled?: boolean;
+  };
+}
+interface ReactGrabState {
+  isActive: boolean;
+  isDragging: boolean;
+  isCopying: boolean;
+  isPromptMode: boolean;
+  isSelectionBoxVisible: boolean;
+  isDragBoxVisible: boolean;
+  targetElement: Element | null;
+  dragBounds: DragRect | null;
+  /**
+   * Currently visible grabbed boxes (success flash effects).
+   * These are temporary visual indicators shown after elements are grabbed/copied.
+   */
+  grabbedBoxes: Array<{
+    id: string;
+    bounds: OverlayBounds;
+    createdAt: number;
+  }>;
+  labelInstances: Array<{
+    id: string;
+    status: SelectionLabelStatus;
+    tagName: string;
+    componentName?: string;
+    createdAt: number;
+  }>;
+  selectionFilePath: string | null;
+  toolbarState: ToolbarState | null;
+}
+type ElementLabelVariant = "hover" | "processing" | "success";
+interface PromptModeContext {
+  x: number;
+  y: number;
+  targetElement: Element | null;
+}
+interface ElementLabelContext {
+  x: number;
+  y: number;
+  content: string;
+  element?: Element;
+  tagName?: string;
+  componentName?: string;
+  filePath?: string;
+  lineNumber?: number;
+}
+type ActivationKey = string | ((event: KeyboardEvent) => boolean);
+interface AgentContext<T = unknown> {
+  content: string[];
+  prompt: string;
+  options?: T;
+  sessionId?: string;
+}
+type ActivationMode = "toggle" | "hold";
+interface OpenFileActionHooks {
+  onOpenFile: (filePath: string, lineNumber?: number) => boolean | void;
+  transformOpenFileUrl: (url: string, filePath: string, lineNumber?: number) => string;
+}
+interface ActionContextHooks extends OpenFileActionHooks {
+  transformHtmlContent: (html: string, elements: Element[]) => Promise<string>;
+}
+interface ActionContext {
+  element: Element;
+  elements: Element[];
+  filePath?: string;
+  lineNumber?: number;
+  componentName?: string;
+  tagName?: string;
+  enterPromptMode?: () => void;
+  hooks: ActionContextHooks;
+  performWithFeedback: (action: () => Promise<boolean>) => Promise<void>;
+  hideContextMenu: () => void;
+  cleanup: () => void;
+}
+interface ContextMenuActionContext extends ActionContext {
+  copy?: () => void;
+}
+interface ContextMenuAction {
+  id: string;
+  label: string;
+  shortcut?: string;
+  shortcutModifier?: boolean;
+  showInToolbarMenu?: boolean;
+  enabled?: boolean | ((context: ActionContext) => boolean);
+  onAction: (context: ContextMenuActionContext) => void | Promise<void>;
+}
+interface HierarchyItem {
+  tagName: string;
+  componentName?: string;
+  depth: number;
+  isLast: boolean;
+}
+interface HierarchyState {
+  items: HierarchyItem[];
+  activeIndex: number;
+}
+interface PluginHooks {
+  onActivate?: () => void | Promise<void>;
+  onDeactivate?: () => void | Promise<void>;
+  onElementHover?: (element: Element) => void | Promise<void>;
+  onElementSelect?: (element: Element) => boolean | void | Promise<boolean>;
+  onDragStart?: (startX: number, startY: number) => void | Promise<void>;
+  onDragEnd?: (elements: Element[], bounds: DragRect) => void | Promise<void>;
+  onBeforeCopy?: (elements: Element[]) => void | Promise<void>;
+  transformCopyContent?: (content: string, elements: Element[]) => string | Promise<string>;
+  onAfterCopy?: (elements: Element[], success: boolean) => void | Promise<void>;
+  onCopySuccess?: (elements: Element[], content: string, context: CopySuccessContext) => void | Promise<void>;
+  onCopyError?: (error: Error) => void | Promise<void>;
+  onStateChange?: (state: ReactGrabState) => void | Promise<void>;
+  onPromptModeChange?: (isPromptMode: boolean, context: PromptModeContext) => void | Promise<void>;
+  onSelectionBox?: (visible: boolean, bounds: OverlayBounds | null, element: Element | null) => void | Promise<void>;
+  onDragBox?: (visible: boolean, bounds: OverlayBounds | null) => void | Promise<void>;
+  onGrabbedBox?: (bounds: OverlayBounds, element: Element) => void | Promise<void>;
+  onElementLabel?: (visible: boolean, variant: ElementLabelVariant, context: ElementLabelContext) => void | Promise<void>;
+  onContextMenu?: (element: Element, position: Position) => void | Promise<void>;
+  onOpenFile?: (filePath: string, lineNumber?: number) => boolean | void;
+  transformHtmlContent?: (html: string, elements: Element[]) => string | Promise<string>;
+  transformAgentContext?: (context: AgentContext, elements: Element[]) => AgentContext | Promise<AgentContext>;
+  transformActionContext?: (context: ActionContext) => ActionContext;
+  transformOpenFileUrl?: (url: string, filePath: string, lineNumber?: number) => string;
+}
+interface CopySuccessContext {
+  prompt?: string;
+}
+interface PluginConfig {
+  theme?: DeepPartial<Theme>;
+  options?: SettableOptions;
+  actions?: ContextMenuAction[];
+  hooks?: PluginHooks;
+  cleanup?: () => undefined;
+}
+interface Plugin {
+  name: string;
+  theme?: DeepPartial<Theme>;
+  options?: SettableOptions;
+  actions?: ContextMenuAction[];
+  hooks?: PluginHooks;
+  setup?: (api: ReactGrabAPI, hooks: ActionContextHooks) => PluginConfig | void;
+}
+interface Options {
+  enabled?: boolean;
+  /**
+   * Confine React Grab to a single container element instead of the whole page.
+   * Hit-testing, the toolbar viewport, and scroll re-anchoring are scoped to it.
+   * Used by the demo build to scope the showcase to its card.
+   */
+  container?: HTMLElement;
+  activationMode?: ActivationMode;
+  keyHoldDuration?: number;
+  allowActivationInsideInput?: boolean;
+  activationKey?: ActivationKey;
+  getContent?: (elements: Element[]) => Promise<string> | string;
+  /**
+   * Maximum number of source-location lines included in the copied / prompted
+   * context for a grabbed element. Larger apps often render a target through
+   * several wrapper components, so the compact default can point an agent at a
+   * wrapper instead of the meaningful surface. Raise this to opt into a deeper,
+   * more detailed trace. Low-signal library frames are always surfaced for free
+   * and never count against this budget.
+   * @default 3
+   */
+  maxContextLines?: number;
+  /**
+   * Whether to freeze React state updates while React Grab is active.
+   * This prevents UI changes from interfering with element selection.
+   * @default true
+   */
+  freezeReactUpdates?: boolean;
+  /**
+   * Whether to send the anonymous version check to react-grab.com on init.
+   * Set to false to skip the version-check request.
+   * @default true
+   */
+  telemetry?: boolean;
+}
+interface SettableOptions extends Options {
+  enabled?: never;
+  telemetry?: never;
+  container?: never;
+}
+interface SourceInfo {
+  filePath: string;
+  lineNumber: number | null;
+  columnNumber: number | null;
+  componentName: string | null;
+}
+interface SelectedElementPayload {
+  tagName: string;
+  id?: string;
+  className?: string;
+  textContent?: string;
+  componentName?: string;
+  filePath?: string;
+  lineNumber?: number;
+  columnNumber?: number;
+}
+interface ElementSelectedEventDetail {
+  elements: SelectedElementPayload[];
+}
+declare global {
+  interface WindowEventMap {
+    "react-grab:element-selected": CustomEvent<ElementSelectedEventDetail>;
+  }
+}
+interface ToolbarState {
+  edge: "top" | "bottom" | "left" | "right";
+  ratio: number;
+  collapsed: boolean;
+  enabled: boolean;
+  defaultAction?: string;
+}
+interface DropdownAnchor {
+  x: number;
+  y: number;
+  edge: ToolbarState["edge"];
+}
+interface ReactGrabAPI {
+  activate: () => void;
+  deactivate: () => void;
+  toggle: () => void;
+  comment: () => void;
+  isActive: () => boolean;
+  isEnabled: () => boolean;
+  setEnabled: (enabled: boolean) => void;
+  getToolbarState: () => ToolbarState | null;
+  setToolbarState: (state: Partial<ToolbarState>) => void;
+  onToolbarStateChange: (callback: (state: ToolbarState) => void) => () => void;
+  reset: () => void;
+  dispose: () => void;
+  copyElement: (elements: Element | Element[]) => Promise<boolean>;
+  getSource: (element: Element) => Promise<SourceInfo | null>;
+  getStackContext: (element: Element) => Promise<string>;
+  getState: () => ReactGrabState;
+  setOptions: (options: SettableOptions) => void;
+  registerPlugin: (plugin: Plugin) => void;
+  unregisterPlugin: (name: string) => void;
+  getPlugins: () => string[];
+  getDisplayName: (element: Element) => string | null;
+}
+interface OverlayBounds {
+  borderRadius: string;
+  height: number;
+  width: number;
+  x: number;
+  y: number;
+}
+type SelectionLabelStatus = "idle" | "copying" | "copied" | "fading" | "error";
+interface SelectionLabelInstance {
+  id: string;
+  bounds: OverlayBounds;
+  boundsMultiple?: OverlayBounds[];
+  tagName: string;
+  componentName?: string;
+  elementsCount?: number;
+  status: SelectionLabelStatus;
+  statusText?: string;
+  isPromptMode?: boolean;
+  inputValue?: string;
+  createdAt: number;
+  element?: Element;
+  elements?: Element[];
+  mouseX?: number;
+  mouseXOffsetFromCenter?: number;
+  mouseXOffsetRatio?: number;
+  errorMessage?: string;
+  hideArrow?: boolean;
+}
+interface FrozenLabelEntry {
+  tagName: string;
+  componentName?: string;
+  bounds: OverlayBounds;
+  mouseX?: number;
+}
+interface FrozenLabelEntryAccessor {
+  read: () => FrozenLabelEntry | null;
+}
+interface SelectionLabelInstanceAccessor {
+  read: () => SelectionLabelInstance | null;
+}
+interface ReactGrabRendererProps {
+  selectionVisible?: boolean;
+  selectionBounds?: OverlayBounds;
+  selectionBoundsMultiple?: OverlayBounds[];
+  selectionShouldSnap?: boolean;
+  selectionElementsCount?: number;
+  frozenLabelEntryAccessors?: FrozenLabelEntryAccessor[];
+  pendingShiftPreviewEntry?: FrozenLabelEntry;
+  selectionFilePath?: string;
+  selectionTagName?: string;
+  selectionComponentName?: string;
+  selectionLabelVisible?: boolean;
+  selectionLabelStatus?: SelectionLabelStatus;
+  hierarchyState?: HierarchyState;
+  hierarchyMenuPosition?: DropdownAnchor | null;
+  labelInstances?: SelectionLabelInstance[];
+  labelInstanceAccessors?: SelectionLabelInstanceAccessor[];
+  dragVisible?: boolean;
+  dragBounds?: OverlayBounds;
+  grabbedBoxes?: Array<{
+    id: string;
+    bounds: OverlayBounds;
+    createdAt: number;
+  }>;
+  mouseX?: number;
+  isFrozen?: boolean;
+  inputValue?: string;
+  isPromptMode?: boolean;
+  onShowContextMenuInstance?: (instanceId: string) => void;
+  onRetryInstance?: (instanceId: string) => void;
+  onAcknowledgeErrorInstance?: (instanceId: string) => void;
+  onLabelInstanceHoverChange?: (instanceId: string, isHovered: boolean) => void;
+  onInputChange?: (value: string) => void;
+  onInputSubmit?: () => void;
+  selectionLabelShakeCount?: number;
+  onConfirmDismiss?: () => void;
+  onOpenSelectionFile?: () => void;
+  discardPrompt?: SelectionDiscardPrompt;
+  toolbarVisible?: boolean;
+  isActive?: boolean;
+  onToggleActive?: () => void;
+  activeActionId?: string | null;
+  enabled?: boolean;
+  shakeCount?: number;
+  onToolbarStateChange?: (state: ToolbarState) => void;
+  onSubscribeToToolbarStateChanges?: (callback: (state: ToolbarState) => void) => () => void;
+  onToolbarSelectHoverChange?: (isHovered: boolean) => void;
+  onToolbarRef?: (element: HTMLDivElement) => void;
+  contextMenuPosition?: Position | null;
+  contextMenuBounds?: OverlayBounds | null;
+  contextMenuTagName?: string;
+  contextMenuComponentName?: string;
+  contextMenuHasFilePath?: boolean;
+  actions?: ContextMenuAction[];
+  actionContext?: ActionContext;
+  onContextMenuDismiss?: () => void;
+  onContextMenuHide?: () => void;
+  toolbarMenuPosition?: DropdownAnchor | null;
+  toolbarMenuActions?: ContextMenuAction[];
+  defaultActionId?: string;
+  defaultActionLabel?: string;
+  onSetDefaultAction?: (actionId: string) => void;
+  onToggleToolbarMenu?: () => void;
+  onToolbarMenuDismiss?: () => void;
+}
+interface GrabbedBox {
+  id: string;
+  bounds: OverlayBounds;
+  createdAt: number;
+  element?: Element;
+}
+interface Rect {
+  left: number;
+  top: number;
+  right: number;
+  bottom: number;
+}
+interface DragRect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+interface SelectionDiscardPrompt {
+  isKeyboardSelection?: boolean;
+  label?: string;
+  cancelOnEscape?: boolean;
+  onConfirm?: () => void;
+  onCancel?: () => void;
+  onCopy?: () => void;
+}
+interface SourceLocation extends SourceInfo {
+  columnNumber: number | null;
+}
+interface ReactGrabStackFrame {
+  functionName?: string;
+  fileName?: string;
+  lineNumber?: number;
+  columnNumber?: number;
+  isServer?: boolean;
+  isSymbolicated?: boolean;
+}
+interface ReactGrabEntry {
+  tagName?: string;
+  componentName?: string;
+  content: string;
+  commentText?: string;
+  source?: SourceLocation | null;
+  stackContext?: string;
+  frames?: ReactGrabStackFrame[];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bippy@0.7.2_@types+react@19.2.14_react@19.2.6/node_modules/bippy/dist/errors.d.ts
+interface ReactWorkTagMap {
+  ActivityComponent: number;
+  CacheComponent: number;
+  ClassComponent: number;
+  ContextConsumer: number;
+  ContextProvider: number;
+  CoroutineComponent: number;
+  CoroutineHandlerPhase: number;
+  DehydratedSuspenseComponent: number;
+  ForwardRef: number;
+  Fragment: number;
+  FunctionComponent: number;
+  HostComponent: number;
+  HostHoistable: number;
+  HostPortal: number;
+  HostRoot: number;
+  HostSingleton: number;
+  HostText: number;
+  IncompleteClassComponent: number;
+  IncompleteFunctionComponent: number;
+  IndeterminateComponent: number;
+  LazyComponent: number;
+  LegacyHiddenComponent: number;
+  MemoComponent: number;
+  Mode: number;
+  OffscreenComponent: number;
+  Profiler: number;
+  ScopeComponent: number;
+  SimpleMemoComponent: number;
+  SuspenseComponent: number;
+  SuspenseListComponent: number;
+  Throw: number;
+  TracingMarkerComponent: number;
+  ViewTransitionComponent: number;
+  YieldComponent: number;
+}
+declare const reactWorkTagsByVersion: {
+  readonly "16.0.0": {
+    readonly ActivityComponent: -1;
+    readonly CacheComponent: -1;
+    readonly ClassComponent: 2;
+    readonly ContextConsumer: 12;
+    readonly ContextProvider: 13;
+    readonly CoroutineComponent: 7;
+    readonly CoroutineHandlerPhase: 8;
+    readonly DehydratedSuspenseComponent: -1;
+    readonly ForwardRef: 14;
+    readonly Fragment: 10;
+    readonly FunctionComponent: 1;
+    readonly HostComponent: 5;
+    readonly HostHoistable: -1;
+    readonly HostPortal: 4;
+    readonly HostRoot: 3;
+    readonly HostSingleton: -1;
+    readonly HostText: 6;
+    readonly IncompleteClassComponent: -1;
+    readonly IncompleteFunctionComponent: -1;
+    readonly IndeterminateComponent: 0;
+    readonly LazyComponent: -1;
+    readonly LegacyHiddenComponent: -1;
+    readonly MemoComponent: -1;
+    readonly Mode: 11;
+    readonly OffscreenComponent: -1;
+    readonly Profiler: 15;
+    readonly ScopeComponent: -1;
+    readonly SimpleMemoComponent: -1;
+    readonly SuspenseComponent: 16;
+    readonly SuspenseListComponent: -1;
+    readonly Throw: -1;
+    readonly TracingMarkerComponent: -1;
+    readonly ViewTransitionComponent: -1;
+    readonly YieldComponent: 9;
+  };
+  readonly "16.4.3-alpha": {
+    readonly ActivityComponent: -1;
+    readonly CacheComponent: -1;
+    readonly ClassComponent: 2;
+    readonly ContextConsumer: 11;
+    readonly ContextProvider: 12;
+    readonly CoroutineComponent: -1;
+    readonly CoroutineHandlerPhase: -1;
+    readonly DehydratedSuspenseComponent: -1;
+    readonly ForwardRef: 13;
+    readonly Fragment: 9;
+    readonly FunctionComponent: 0;
+    readonly HostComponent: 7;
+    readonly HostHoistable: -1;
+    readonly HostPortal: 6;
+    readonly HostRoot: 5;
+    readonly HostSingleton: -1;
+    readonly HostText: 8;
+    readonly IncompleteClassComponent: -1;
+    readonly IncompleteFunctionComponent: -1;
+    readonly IndeterminateComponent: 4;
+    readonly LazyComponent: -1;
+    readonly LegacyHiddenComponent: -1;
+    readonly MemoComponent: -1;
+    readonly Mode: 10;
+    readonly OffscreenComponent: -1;
+    readonly Profiler: 15;
+    readonly ScopeComponent: -1;
+    readonly SimpleMemoComponent: -1;
+    readonly SuspenseComponent: 16;
+    readonly SuspenseListComponent: -1;
+    readonly Throw: -1;
+    readonly TracingMarkerComponent: -1;
+    readonly ViewTransitionComponent: -1;
+    readonly YieldComponent: -1;
+  };
+  readonly "16.6.0-beta.0": {
+    readonly ActivityComponent: -1;
+    readonly CacheComponent: -1;
+    readonly ClassComponent: 1;
+    readonly ContextConsumer: 9;
+    readonly ContextProvider: 10;
+    readonly CoroutineComponent: -1;
+    readonly CoroutineHandlerPhase: -1;
+    readonly DehydratedSuspenseComponent: 18;
+    readonly ForwardRef: 11;
+    readonly Fragment: 7;
+    readonly FunctionComponent: 0;
+    readonly HostComponent: 5;
+    readonly HostHoistable: -1;
+    readonly HostPortal: 4;
+    readonly HostRoot: 3;
+    readonly HostSingleton: -1;
+    readonly HostText: 6;
+    readonly IncompleteClassComponent: 17;
+    readonly IncompleteFunctionComponent: -1;
+    readonly IndeterminateComponent: 2;
+    readonly LazyComponent: 16;
+    readonly LegacyHiddenComponent: -1;
+    readonly MemoComponent: 14;
+    readonly Mode: 8;
+    readonly OffscreenComponent: -1;
+    readonly Profiler: 12;
+    readonly ScopeComponent: -1;
+    readonly SimpleMemoComponent: 15;
+    readonly SuspenseComponent: 13;
+    readonly SuspenseListComponent: 19;
+    readonly Throw: -1;
+    readonly TracingMarkerComponent: -1;
+    readonly ViewTransitionComponent: -1;
+    readonly YieldComponent: -1;
+  };
+  readonly "17.0.0-alpha": {
+    readonly ActivityComponent: -1;
+    readonly CacheComponent: -1;
+    readonly ClassComponent: 1;
+    readonly ContextConsumer: 9;
+    readonly ContextProvider: 10;
+    readonly CoroutineComponent: -1;
+    readonly CoroutineHandlerPhase: -1;
+    readonly DehydratedSuspenseComponent: 18;
+    readonly ForwardRef: 11;
+    readonly Fragment: 7;
+    readonly FunctionComponent: 0;
+    readonly HostComponent: 5;
+    readonly HostHoistable: -1;
+    readonly HostPortal: 4;
+    readonly HostRoot: 3;
+    readonly HostSingleton: -1;
+    readonly HostText: 6;
+    readonly IncompleteClassComponent: 17;
+    readonly IncompleteFunctionComponent: -1;
+    readonly IndeterminateComponent: 2;
+    readonly LazyComponent: 16;
+    readonly LegacyHiddenComponent: 24;
+    readonly MemoComponent: 14;
+    readonly Mode: 8;
+    readonly OffscreenComponent: 23;
+    readonly Profiler: 12;
+    readonly ScopeComponent: 21;
+    readonly SimpleMemoComponent: 15;
+    readonly SuspenseComponent: 13;
+    readonly SuspenseListComponent: 19;
+    readonly Throw: -1;
+    readonly TracingMarkerComponent: -1;
+    readonly ViewTransitionComponent: -1;
+    readonly YieldComponent: -1;
+  };
+  readonly "17.0.2": {
+    readonly ActivityComponent: 31;
+    readonly CacheComponent: 24;
+    readonly ClassComponent: 1;
+    readonly ContextConsumer: 9;
+    readonly ContextProvider: 10;
+    readonly CoroutineComponent: -1;
+    readonly CoroutineHandlerPhase: -1;
+    readonly DehydratedSuspenseComponent: 18;
+    readonly ForwardRef: 11;
+    readonly Fragment: 7;
+    readonly FunctionComponent: 0;
+    readonly HostComponent: 5;
+    readonly HostHoistable: 26;
+    readonly HostPortal: 4;
+    readonly HostRoot: 3;
+    readonly HostSingleton: 27;
+    readonly HostText: 6;
+    readonly IncompleteClassComponent: 17;
+    readonly IncompleteFunctionComponent: 28;
+    readonly IndeterminateComponent: 2;
+    readonly LazyComponent: 16;
+    readonly LegacyHiddenComponent: 23;
+    readonly MemoComponent: 14;
+    readonly Mode: 8;
+    readonly OffscreenComponent: 22;
+    readonly Profiler: 12;
+    readonly ScopeComponent: 21;
+    readonly SimpleMemoComponent: 15;
+    readonly SuspenseComponent: 13;
+    readonly SuspenseListComponent: 19;
+    readonly Throw: 29;
+    readonly TracingMarkerComponent: 25;
+    readonly ViewTransitionComponent: 30;
+    readonly YieldComponent: -1;
+  };
+};
+type ReactWorkTagVersion = keyof typeof reactWorkTagsByVersion;
+type ReactWorkTag = Exclude<(typeof reactWorkTagsByVersion)[ReactWorkTagVersion][keyof ReactWorkTagMap], -1>;
+//#endregion
+//#region src/react-internals/types.d.ts
+type WorkTag = ReactReconciler.WorkTag | ReactWorkTag;
+interface Source extends ReactReconciler.Source {}
+interface ContextDependency<T> extends Omit<ReactReconciler.ContextDependency<T>, "observedBits"> {
+  memoizedValue?: T;
+  observedBits?: number;
+}
+interface DebugThenableState {
+  thenables?: unknown[];
+}
+interface Dependencies extends Omit<ReactReconciler.Dependencies, "firstContext"> {
+  _debugThenableState?: DebugThenableState | unknown[];
+  firstContext: ContextDependency<unknown> | null;
+}
+interface ServerComponentInfo {
+  name?: string;
+  env?: string;
+  owner?: Fiber | ServerComponentInfo | null;
+  debugStack?: Error | null;
+}
+interface ReactDebugInfo {
+  debugLocation?: unknown;
+  env?: string;
+  name?: string;
+}
+interface ReactMemoCache {
+  data: unknown[][];
+  index: number;
+}
+interface FiberDebugSource extends Source {
+  columnNumber?: number;
+}
+interface FiberUpdateQueue {
+  [key: string]: unknown;
+  memoCache?: ReactMemoCache;
+}
+interface Fiber<T = unknown> extends Omit<ReactReconciler.Fiber, "alternate" | "_debugOwner" | "_debugSource" | "child" | "deletions" | "dependencies" | "memoizedProps" | "memoizedState" | "pendingProps" | "return" | "sibling" | "stateNode" | "tag" | "updateQueue"> {
+  _debugInfo?: ReactDebugInfo[];
+  _debugOwner?: Fiber | ServerComponentInfo | null;
+  _debugSource?: FiberDebugSource | null;
+  _debugStack?: Error & {
+    stack: string;
+  };
+  alternate: Fiber | null;
+  child: Fiber | null;
+  deletions: Fiber[] | null;
+  dependencies: Dependencies | null;
+  effectTag?: number;
+  memoizedProps: Props;
+  memoizedState: MemoizedState | null;
+  pendingProps: Props;
+  return: Fiber | null;
+  sibling: Fiber | null;
+  stateNode: T;
+  tag: WorkTag;
+  updateQueue: FiberUpdateQueue | null;
+}
+interface FiberRoot {
+  current: Fiber;
+}
+interface MemoizedState {
+  [key: string]: unknown;
+  memoizedState: unknown;
+  next: MemoizedState | null;
+}
+interface Props {
+  [key: string]: unknown;
+}
+interface ReactDevToolsEventHandler {
+  (data: unknown): void;
+}
+interface ReactDevToolsGlobalHook {
+  _instrumentationIsActive?: boolean;
+  _instrumentationSource?: string;
+  checkDCE: (fn: unknown) => void;
+  emit?: (event: string, data?: unknown) => void;
+  getFiberRoots?: (rendererID: number) => Set<FiberRoot>;
+  hasUnsupportedRendererAttached: boolean;
+  inject: (renderer: ReactRenderer) => number;
+  off?: (event: string, handler: ReactDevToolsEventHandler) => void;
+  on: (event: string, handler: ReactDevToolsEventHandler) => void;
+  onCommitFiberRoot: (rendererID: number, root: FiberRoot, priority: number | void, didError?: boolean) => void;
+  onCommitFiberUnmount: (rendererID: number, fiber: Fiber) => void;
+  onPostCommitFiberRoot: (rendererID: number, root: FiberRoot) => void;
+  onScheduleFiberRoot?: (rendererID: number, root: FiberRoot, children: ReactNode) => void;
+  renderers: Map<number, ReactRenderer>;
+  sub?: (event: string, handler: ReactDevToolsEventHandler) => () => void;
+  supportsFiber: boolean;
+  supportsFlight: boolean;
+}
+interface LegacyDispatcherRef {
+  current: unknown;
+}
+interface CurrentDispatcherRef {
+  H: unknown;
+}
+type RendererDispatcherRef = CurrentDispatcherRef | LegacyDispatcherRef;
+interface ReactRenderer extends Omit<ReactReconciler.DevToolsConfig<unknown, unknown, unknown>, "findFiberByHostInstance"> {
+  currentDispatcherRef?: RendererDispatcherRef | null;
+  findFiberByHostInstance?: (hostInstance: unknown) => Fiber | null;
+  getCurrentFiber?: () => Fiber | null;
+  overrideContext?: (fiber: Fiber, contextType: unknown, path: string[], value: unknown) => void;
+  overrideHookState?: (fiber: Fiber, id: number, path: string[], value: unknown) => void;
+  overrideHookStateDeletePath?: (fiber: Fiber, id: number, path: Array<number | string>) => void;
+  overrideHookStateRenamePath?: (fiber: Fiber, id: number, oldPath: Array<number | string>, newPath: Array<number | string>) => void;
+  overrideProps?: (fiber: Fiber, path: string[], value: unknown) => void;
+  overridePropsDeletePath?: (fiber: Fiber, path: Array<number | string>) => void;
+  overridePropsRenamePath?: (fiber: Fiber, oldPath: Array<number | string>, newPath: Array<number | string>) => void;
+  reconcilerVersion?: string;
+  scheduleRetry?: (fiber: Fiber) => void;
+  scheduleRoot?: (root: FiberRoot, element: React.ReactNode) => void;
+  scheduleUpdate?: (fiber: Fiber) => void;
+  setErrorHandler?: (newShouldErrorImpl: (fiber: Fiber) => boolean | null) => void;
+  setSuspenseHandler?: (newShouldSuspendImpl: (fiber: Fiber) => boolean) => void;
+}
+declare global {
+  var __REACT_DEVTOOLS_GLOBAL_HOOK__: ReactDevToolsGlobalHook | undefined;
+} //#endregion
+//#region src/react-internals/index.d.ts
+//#endregion
+//#region ../../node_modules/.pnpm/bippy@0.7.2_@types+react@19.2.14_react@19.2.6/node_modules/bippy/dist/source.d.ts
+//#region src/source/parse-stack.d.ts
+interface StackFrame {
+  columnNumber?: number;
+  lineNumber?: number;
+  enclosingLineNumber?: number;
+  enclosingColumnNumber?: number;
+  fileName?: string;
+  functionName?: string;
+  source?: string;
+  isServer?: boolean;
+  isSymbolicated?: boolean;
+  isIgnoreListed?: boolean;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/bippy@0.7.2_@types+react@19.2.14_react@19.2.6/node_modules/bippy/dist/index.d.ts
+/**
+ * Returns `true` if bippy's instrumentation is active.
+ */
+declare const isInstrumentationActive: () => boolean;
+//#endregion
+//#region src/utils/copy-content.d.ts
+interface CopyContentOptions {
+  componentName?: string;
+  tagName?: string;
+  commentText?: string;
+  entries?: ReactGrabEntry[];
+}
+declare const copyContent: (content: string, options?: CopyContentOptions) => boolean;
+//#endregion
+export { ReactGrabState as A, Plugin as C, PromptModeContext as D, Position as E, Theme as F, ToolbarState as I, SelectedElementPayload as M, SettableOptions as N, ReactGrabAPI as O, SourceInfo as P, OverlayBounds as S, PluginHooks as T, ElementLabelVariant as _, ActionContext as a, OpenFileActionHooks as b, AgentContext as c, CopySuccessContext as d, DeepPartial as f, ElementLabelContext as g, ElementBounds as h, Fiber as i, Rect as j, ReactGrabRendererProps as k, ContextMenuAction as l, ElementAtPointOptions as m, isInstrumentationActive as n, ActionContextHooks as o, DragRect as p, StackFrame as r, ActivationMode as s, copyContent as t, ContextMenuActionContext as u, ElementSelectedEventDetail as v, PluginConfig as w, Options as x, GrabbedBox as y };