@depup/sentry__react 10.44.0-depup.0

package/build/types-ts3.8/reactrouter-compat-utils/lazy-routes.d.ts

@@ -0,0 +1,18 @@
+import { Span } from '@sentry/core';
+import { Location, RouteObject } from '../types';
+/**
+ * Creates a proxy wrapper for an async handler function.
+ * Captures both the location and the active span at invocation time to ensure
+ * the correct span is updated when the handler resolves.
+ */
+export declare function createAsyncHandlerProxy(originalFunction: (...args: unknown[]) => unknown, route: RouteObject, handlerKey: string, processResolvedRoutes: (resolvedRoutes: RouteObject[], parentRoute?: RouteObject, currentLocation?: Location, capturedSpan?: Span) => void): (...args: unknown[]) => unknown;
+/**
+ * Handles the result of an async handler function call.
+ * Passes the captured span through to ensure the correct span is updated.
+ */
+export declare function handleAsyncHandlerResult(result: unknown, route: RouteObject, handlerKey: string, processResolvedRoutes: (resolvedRoutes: RouteObject[], parentRoute?: RouteObject, currentLocation?: Location, capturedSpan?: Span) => void, currentLocation: Location | null, capturedSpan: Span | undefined): void;
+/**
+ * Recursively checks a route for async handlers and sets up Proxies to add discovered child routes to allRoutes when called.
+ */
+export declare function checkRouteForAsyncHandler(route: RouteObject, processResolvedRoutes: (resolvedRoutes: RouteObject[], parentRoute?: RouteObject, currentLocation?: Location, capturedSpan?: Span) => void): void;
+//# sourceMappingURL=lazy-routes.d.ts.map

package/build/types-ts3.8/reactrouter-compat-utils/route-manifest.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Strip the basename from a pathname if exists.
+ *
+ * Vendored and modified from `react-router`
+ * https://github.com/remix-run/react-router/blob/462bb712156a3f739d6139a0f14810b76b002df6/packages/router/utils.ts#L1038
+ */
+export declare function stripBasenameFromPathname(pathname: string, basename: string): string;
+/**
+ * Matches a pathname against a route manifest and returns the matching pattern.
+ * Optionally strips a basename prefix before matching.
+ */
+export declare function matchRouteManifest(pathname: string, manifest: string[], basename?: string): string | null;
+//# sourceMappingURL=route-manifest.d.ts.map

package/build/types-ts3.8/reactrouter-compat-utils/utils.d.ts

@@ -0,0 +1,77 @@
+import { Span, TransactionSource } from '@sentry/core';
+import { Location, MatchRoutes, RouteMatch, RouteObject } from '../types';
+interface NavigationContext {
+    token: object;
+    targetPath: string | undefined;
+    span: Span | undefined;
+}
+/**
+ * Pushes a navigation context and returns a unique token for cleanup.
+ * The token uses object identity for uniqueness (no counter needed).
+ */
+export declare function setNavigationContext(targetPath: string | undefined, span: Span | undefined): object;
+/**
+ * Clears the navigation context if it's on top of the stack (LIFO).
+ * If our context is not on top (out-of-order completion), we leave it -
+ * it will be cleaned up by overflow protection when the stack fills up.
+ */
+export declare function clearNavigationContext(token: object): void;
+/** Gets the current (most recent) navigation context if inside a patchRoutesOnNavigation call. */
+export declare function getNavigationContext(): NavigationContext | null;
+/**
+ * Initialize function to set dependencies that the router utilities need.
+ * Must be called before using any of the exported utility functions.
+ */
+export declare function initializeRouterUtils(matchRoutes: MatchRoutes, stripBasename?: boolean): void;
+/**
+ * Checks if a path ends with a wildcard character (*).
+ */
+export declare function pathEndsWithWildcard(path: string): boolean;
+/** Checks if transaction name has wildcard (/* or ends with *). */
+export declare function transactionNameHasWildcard(name: string): boolean;
+/**
+ * Checks if a path is a wildcard and has child routes.
+ */
+export declare function pathIsWildcardAndHasChildren(path: string, branch: RouteMatch<string>): boolean;
+/** Check if route is in descendant route (<Routes> within <Routes>) */
+export declare function routeIsDescendant(route: RouteObject): boolean;
+/**
+ * Returns the number of URL segments in the given URL string.
+ * Splits at '/' or '\/' to handle regex URLs correctly.
+ *
+ * @param url - The URL string to segment.
+ * @returns The number of segments in the URL.
+ */
+export declare function getNumberOfUrlSegments(url: string): number;
+/**
+ * Ensures a path string starts with a forward slash.
+ */
+export declare function prefixWithSlash(path: string): string;
+/**
+ * Rebuilds the route path from all available routes by matching against the current location.
+ */
+export declare function rebuildRoutePathFromAllRoutes(allRoutes: RouteObject[], location: Location): string;
+/**
+ * Checks if the current location is inside a descendant route (route with splat parameter).
+ */
+export declare function locationIsInsideDescendantRoute(location: Location, routes: RouteObject[]): boolean;
+/**
+ * Gets a normalized route name and transaction source from the current routes and location.
+ */
+export declare function getNormalizedName(routes: RouteObject[], location: Location, branches: RouteMatch[], basename?: string): [
+    string,
+    TransactionSource
+];
+/**
+ * Shared helper function to resolve route name and source
+ */
+export declare function resolveRouteNameAndSource(location: Location, routes: RouteObject[], allRoutes: RouteObject[], branches: RouteMatch[], basename?: string, lazyRouteManifest?: string[], enableAsyncRouteHandlers?: boolean): [
+    string,
+    TransactionSource
+];
+/**
+ * Gets the active root span if it's a pageload or navigation span.
+ */
+export declare function getActiveRootSpan(): Span | undefined;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/build/types-ts3.8/reactrouter.d.ts

@@ -0,0 +1,41 @@
+import { browserTracingIntegration } from '@sentry/browser';
+import { Integration } from '@sentry/core';
+import { ReactElement } from 'react';
+import * as React from 'react';
+import { Action, Location } from './types';
+type Match = {
+    path: string;
+    url: string;
+    params: Record<string, any>;
+    isExact: boolean;
+};
+export type RouterHistory = {
+    location?: Location;
+    listen?(cb: (location: Location, action: Action) => void): void;
+} & Record<string, any>;
+export type RouteConfig = {
+    [propName: string]: unknown;
+    path?: string | string[];
+    exact?: boolean;
+    component?: ReactElement;
+    routes?: RouteConfig[];
+};
+export type MatchPath = (pathname: string, props: string | string[] | any, parent?: Match | null) => Match | null;
+interface ReactRouterOptions {
+    history: RouterHistory;
+    routes?: RouteConfig[];
+    matchPath?: MatchPath;
+}
+/**
+ * A browser tracing integration that uses React Router v4 to instrument navigations.
+ * Expects `history` (and optionally `routes` and `matchPath`) to be passed as options.
+ */
+export declare function reactRouterV4BrowserTracingIntegration(options: Parameters<typeof browserTracingIntegration>[0] & ReactRouterOptions): Integration;
+/**
+ * A browser tracing integration that uses React Router v5 to instrument navigations.
+ * Expects `history` (and optionally `routes` and `matchPath`) to be passed as options.
+ */
+export declare function reactRouterV5BrowserTracingIntegration(options: Parameters<typeof browserTracingIntegration>[0] & ReactRouterOptions): Integration;
+export declare function withSentryRouting<P extends Record<string, any>, R extends React.ComponentType<P>>(Route: R): R;
+export {};
+//# sourceMappingURL=reactrouter.d.ts.map

package/build/types-ts3.8/reactrouterv3.d.ts

@@ -0,0 +1,29 @@
+import { browserTracingIntegration } from '@sentry/browser';
+import { Integration } from '@sentry/core';
+import { Location } from './types';
+type HistoryV3 = {
+    location?: Location;
+    listen?(cb: (location: Location) => void): void;
+} & Record<string, any>;
+export type Route = {
+    path?: string;
+    childRoutes?: Route[];
+};
+export type Match = (props: {
+    location: Location;
+    routes: Route[];
+}, cb: (error?: Error, _redirectLocation?: Location, renderProps?: {
+    routes?: Route[];
+}) => void) => void;
+interface ReactRouterOptions {
+    history: HistoryV3;
+    routes: Route[];
+    match: Match;
+}
+/**
+ * A browser tracing integration that uses React Router v3 to instrument navigations.
+ * Expects `history` (and optionally `routes` and `matchPath`) to be passed as options.
+ */
+export declare function reactRouterV3BrowserTracingIntegration(options: Parameters<typeof browserTracingIntegration>[0] & ReactRouterOptions): Integration;
+export {};
+//# sourceMappingURL=reactrouterv3.d.ts.map

package/build/types-ts3.8/reactrouterv6.d.ts

@@ -0,0 +1,32 @@
+import { browserTracingIntegration } from '@sentry/browser';
+import { Integration } from '@sentry/core';
+import { ReactRouterOptions } from './reactrouter-compat-utils';
+import { CreateRouterFunction, Router, RouterState, UseRoutes } from './types';
+/**
+ * A browser tracing integration that uses React Router v6 to instrument navigations.
+ * Expects `useEffect`, `useLocation`, `useNavigationType`, `createRoutesFromChildren` and `matchRoutes` to be passed as options.
+ */
+export declare function reactRouterV6BrowserTracingIntegration(options: Parameters<typeof browserTracingIntegration>[0] & ReactRouterOptions): Integration;
+/**
+ * A wrapper function that adds Sentry routing instrumentation to a React Router v6 useRoutes hook.
+ * This is used to automatically capture route changes as transactions when using the useRoutes hook.
+ */
+export declare function wrapUseRoutesV6(origUseRoutes: UseRoutes): UseRoutes;
+/**
+ * A wrapper function that adds Sentry routing instrumentation to a React Router v6 createBrowserRouter function.
+ * This is used to automatically capture route changes as transactions when using the createBrowserRouter API.
+ */
+export declare function wrapCreateBrowserRouterV6<TState extends RouterState = RouterState, TRouter extends Router<TState> = Router<TState>>(createRouterFunction: CreateRouterFunction<TState, TRouter>): CreateRouterFunction<TState, TRouter>;
+/**
+ * A wrapper function that adds Sentry routing instrumentation to a React Router v6 createMemoryRouter function.
+ * This is used to automatically capture route changes as transactions when using the createMemoryRouter API.
+ * The difference between createBrowserRouter and createMemoryRouter is that with createMemoryRouter,
+ * optional `initialEntries` are also taken into account.
+ */
+export declare function wrapCreateMemoryRouterV6<TState extends RouterState = RouterState, TRouter extends Router<TState> = Router<TState>>(createMemoryRouterFunction: CreateRouterFunction<TState, TRouter>): CreateRouterFunction<TState, TRouter>;
+/**
+ * A higher-order component that adds Sentry routing instrumentation to a React Router v6 Route component.
+ * This is used to automatically capture route changes as transactions.
+ */
+export declare function withSentryReactRouterV6Routing<P extends Record<string, any>, R extends React.FC<P>>(routes: R): R;
+//# sourceMappingURL=reactrouterv6.d.ts.map

package/build/types-ts3.8/reactrouterv7.d.ts

@@ -0,0 +1,32 @@
+import { browserTracingIntegration } from '@sentry/browser';
+import { Integration } from '@sentry/core';
+import { ReactRouterOptions } from './reactrouter-compat-utils';
+import { CreateRouterFunction, Router, RouterState, UseRoutes } from './types';
+/**
+ * A browser tracing integration that uses React Router v7 to instrument navigations.
+ * Expects `useEffect`, `useLocation`, `useNavigationType`, `createRoutesFromChildren` and `matchRoutes` to be passed as options.
+ */
+export declare function reactRouterV7BrowserTracingIntegration(options: Parameters<typeof browserTracingIntegration>[0] & ReactRouterOptions): Integration;
+/**
+ * A higher-order component that adds Sentry routing instrumentation to a React Router v7 Route component.
+ * This is used to automatically capture route changes as transactions.
+ */
+export declare function withSentryReactRouterV7Routing<P extends Record<string, any>, R extends React.FC<P>>(routes: R): R;
+/**
+ * A wrapper function that adds Sentry routing instrumentation to a React Router v7 createBrowserRouter function.
+ * This is used to automatically capture route changes as transactions when using the createBrowserRouter API.
+ */
+export declare function wrapCreateBrowserRouterV7<TState extends RouterState = RouterState, TRouter extends Router<TState> = Router<TState>>(createRouterFunction: CreateRouterFunction<TState, TRouter>): CreateRouterFunction<TState, TRouter>;
+/**
+ * A wrapper function that adds Sentry routing instrumentation to a React Router v7 createMemoryRouter function.
+ * This is used to automatically capture route changes as transactions when using the createMemoryRouter API.
+ * The difference between createBrowserRouter and createMemoryRouter is that with createMemoryRouter,
+ * optional `initialEntries` are also taken into account.
+ */
+export declare function wrapCreateMemoryRouterV7<TState extends RouterState = RouterState, TRouter extends Router<TState> = Router<TState>>(createMemoryRouterFunction: CreateRouterFunction<TState, TRouter>): CreateRouterFunction<TState, TRouter>;
+/**
+ * A wrapper function that adds Sentry routing instrumentation to a React Router v7 useRoutes hook.
+ * This is used to automatically capture route changes as transactions when using the useRoutes hook.
+ */
+export declare function wrapUseRoutesV7(origUseRoutes: UseRoutes): UseRoutes;
+//# sourceMappingURL=reactrouterv7.d.ts.map

package/build/types-ts3.8/redux.d.ts

@@ -0,0 +1,38 @@
+import { Scope } from '@sentry/core';
+interface Action<T = any> {
+    type: T;
+}
+interface AnyAction extends Action {
+    [extraProps: string]: any;
+}
+export interface SentryEnhancerOptions<S = any> {
+    /**
+     * Redux state in attachments or not.
+     * @default true
+     */
+    attachReduxState?: boolean;
+    /**
+     * Transforms the state before attaching it to an event.
+     * Use this to remove any private data before sending it to Sentry.
+     * Return null to not attach the state.
+     */
+    stateTransformer(state: S | undefined): (S & any) | null;
+    /**
+     * Transforms the action before sending it as a breadcrumb.
+     * Use this to remove any private data before sending it to Sentry.
+     * Return null to not send the breadcrumb.
+     */
+    actionTransformer(action: AnyAction): AnyAction | null;
+    /**
+     * Called on every state update, configure the Sentry Scope with the redux state.
+     */
+    configureScopeWithState?(scope: Scope, state: S): void;
+}
+/**
+ * Creates an enhancer that would be passed to Redux's createStore to log actions and the latest state to Sentry.
+ *
+ * @param enhancerOptions Options to pass to the enhancer
+ */
+declare function createReduxEnhancer(enhancerOptions?: Partial<SentryEnhancerOptions>): any;
+export { createReduxEnhancer };
+//# sourceMappingURL=redux.d.ts.map

package/build/types-ts3.8/sdk.d.ts

@@ -0,0 +1,7 @@
+import { BrowserOptions } from '@sentry/browser';
+import { Client } from '@sentry/core';
+/**
+ * Inits the React SDK
+ */
+export declare function init(options: BrowserOptions): Client | undefined;
+//# sourceMappingURL=sdk.d.ts.map

package/build/types-ts3.8/tanstackrouter.d.ts

@@ -0,0 +1,13 @@
+import { browserTracingIntegration as originalBrowserTracingIntegration } from '@sentry/browser';
+import { Integration } from '@sentry/core';
+/**
+ * A custom browser tracing integration for TanStack Router.
+ *
+ * The minimum compatible version of `@tanstack/react-router` is `1.64.0`.
+ *
+ * @param router A TanStack Router `Router` instance that should be used for routing instrumentation.
+ * @param options Sentry browser tracing configuration.
+ */
+export declare function tanstackRouterBrowserTracingIntegration(router: any, // This is `any` because we don't want any type mismatches if TanStack Router changes their types
+options?: Parameters<typeof originalBrowserTracingIntegration>[0]): Integration;
+//# sourceMappingURL=tanstackrouter.d.ts.map

package/build/types-ts3.8/types.d.ts

@@ -0,0 +1,163 @@
+import { ReactElement } from 'react';
+export type Action = 'PUSH' | 'REPLACE' | 'POP';
+export type Location = {
+    pathname: string;
+    action?: Action;
+} & Record<string, any>;
+export interface NonIndexRouteObject {
+    caseSensitive?: boolean;
+    children?: RouteObject[];
+    handle?: Record<string, any>;
+    element?: React.ReactNode | null;
+    errorElement?: React.ReactNode | null;
+    index?: any;
+    path?: string;
+}
+export interface IndexRouteObject {
+    caseSensitive?: boolean;
+    children?: undefined;
+    handle?: Record<string, any>;
+    element?: React.ReactNode | null;
+    errorElement?: React.ReactNode | null;
+    index: any;
+    path?: string;
+}
+export type RouteObject = (IndexRouteObject | NonIndexRouteObject) & Record<string, any>;
+export type Params<Key extends string = string> = {
+    readonly [key in Key]: string | undefined;
+};
+export type UseRoutes = (routes: RouteObject[], locationArg?: Partial<Location> | string) => React.ReactElement | null;
+export interface RouteMatch<ParamKey extends string = string> {
+    /**
+     * The names and values of dynamic parameters in the URL.
+     */
+    params: Params<ParamKey>;
+    /**
+     * The portion of the URL pathname that was matched.
+     */
+    pathname: string;
+    /**
+     * The portion of the URL pathname that was matched before child routes.
+     */
+    pathnameBase: string;
+    /**
+     * The route object that was used to match.
+     */
+    route: RouteObject;
+}
+export type UseEffect = (cb: () => void, deps: unknown[]) => void;
+export type UseLocation = () => Location;
+export type UseNavigationType = () => Action;
+export type RouteObjectArrayAlias = any;
+export type RouteMatchAlias = any;
+export type CreateRoutesFromChildren = (children: ReactElement[]) => RouteObjectArrayAlias;
+export type MatchRoutes = (routes: RouteObjectArrayAlias, location: Location, basename?: string) => RouteMatchAlias[] | null;
+export type ShouldRevalidateFunction = (args: any) => boolean;
+interface DataFunctionArgs {
+    request: Request;
+    params: Params;
+}
+type LoaderFunctionArgs = DataFunctionArgs;
+type ActionFunctionArgs = DataFunctionArgs;
+export interface LoaderFunction {
+    (args: LoaderFunctionArgs): Promise<Response> | Response | Promise<any> | any;
+}
+export interface ActionFunction {
+    (args: ActionFunctionArgs): Promise<Response> | Response | Promise<any> | any;
+}
+declare type AgnosticBaseRouteObject = {
+    caseSensitive?: boolean;
+    path?: string;
+    id?: string;
+    loader?: LoaderFunction;
+    action?: ActionFunction;
+    hasErrorBoundary?: boolean;
+    shouldRevalidate?: ShouldRevalidateFunction;
+    handle?: any;
+};
+export declare type AgnosticIndexRouteObject = AgnosticBaseRouteObject & Record<string, any>;
+export declare type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & Record<string, any>;
+export declare type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {
+    id: string;
+};
+export declare type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {
+    children?: AgnosticDataRouteObject[];
+    id: string;
+};
+export interface AgnosticRouteMatch<ParamKey extends string = string, RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject> {
+    params: Params<ParamKey>;
+    pathname: string;
+    pathnameBase: string;
+    route: RouteObjectType;
+}
+export type AgnosticDataRouteMatch = AgnosticRouteMatch<string, AgnosticDataRouteObject>;
+interface UseMatchesMatch {
+    id: string;
+    pathname: string;
+    params: AgnosticRouteMatch['params'];
+    data: unknown;
+    handle: unknown;
+}
+export interface GetScrollRestorationKeyFunction {
+    (location: Location, matches: UseMatchesMatch[]): string | null;
+}
+export interface Path {
+    pathname: string;
+    search: string;
+    hash: string;
+}
+export interface RouterSubscriber<TState extends RouterState = RouterState> {
+    (state: TState): void;
+}
+export interface GetScrollPositionFunction {
+    (): number;
+}
+declare type LinkNavigateOptions = {
+    replace?: boolean;
+    state?: any;
+    preventScrollReset?: boolean;
+};
+export declare type AgnosticDataRouteObject = AgnosticDataIndexRouteObject | AgnosticDataNonIndexRouteObject;
+export declare type To = string | Partial<Path>;
+export declare type HydrationState = any;
+export declare type FormMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
+export declare type FormEncType = 'application/x-www-form-urlencoded' | 'multipart/form-data';
+export declare type RouterNavigateOptions = LinkNavigateOptions | SubmissionNavigateOptions;
+export declare type AgnosticRouteObject = AgnosticIndexRouteObject | AgnosticNonIndexRouteObject;
+declare type SubmissionNavigateOptions = {
+    replace?: boolean;
+    state?: any;
+    formMethod?: FormMethod;
+    formEncType?: FormEncType;
+    formData: FormData;
+};
+export interface RouterInit {
+    basename: string;
+    routes: AgnosticRouteObject[];
+    history: History;
+    hydrationData?: HydrationState;
+}
+export type NavigationState = {
+    state: 'idle' | 'loading' | 'submitting';
+};
+export type NavigationStates = {
+    Idle: NavigationState;
+    Loading: NavigationState;
+    Submitting: NavigationState;
+};
+export type Navigation = NavigationStates[keyof NavigationStates];
+export type RouteData = any;
+export type Fetcher = any;
+type HistoryAction = 'POP' | 'PUSH' | 'REPLACE';
+export interface RouterState {
+    historyAction: Action | HistoryAction | any;
+    location: Location;
+    navigation: Navigation;
+}
+export interface Router<TState extends RouterState = RouterState> {
+    state: TState;
+    subscribe(fn: RouterSubscriber<TState>): () => void;
+}
+export type CreateRouterFunction<TState extends RouterState = RouterState, TRouter extends Router<TState> = Router<TState>> = (routes: RouteObject[], opts?: any) => TRouter;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/build/types-ts3.8/vendor/tanstackrouter-types.d.ts

@@ -0,0 +1,36 @@
+export interface VendoredTanstackRouter {
+    history: VendoredTanstackRouterHistory;
+    state: VendoredTanstackRouterState;
+    options: {
+        parseSearch: (search: string) => Record<string, any>;
+    };
+    matchRoutes: (pathname: string, locationSearch: {}, opts?: {
+        preload?: boolean;
+        throwOnError?: boolean;
+    }) => Array<VendoredTanstackRouterRouteMatch>;
+    subscribe(eventType: 'onResolved' | 'onBeforeNavigate', callback: (stateUpdate: {
+        toLocation: VendoredTanstackRouterLocation;
+        fromLocation?: VendoredTanstackRouterLocation;
+    }) => void): () => void;
+}
+interface VendoredTanstackRouterLocation {
+    pathname: string;
+    search: {};
+    state: string;
+}
+interface VendoredTanstackRouterHistory {
+    subscribe: (cb: () => void) => () => void;
+}
+interface VendoredTanstackRouterState {
+    matches: Array<VendoredTanstackRouterRouteMatch>;
+    pendingMatches?: Array<VendoredTanstackRouterRouteMatch>;
+}
+export interface VendoredTanstackRouterRouteMatch {
+    routeId: string;
+    pathname: string;
+    params: {
+        [key: string]: string;
+    };
+}
+export {};
+//# sourceMappingURL=tanstackrouter-types.d.ts.map

package/changes.json

@@ -0,0 +1,5 @@
+{
+  "bumped": {},
+  "timestamp": "2026-03-18T22:43:01.590Z",
+  "totalUpdated": 0
+}

package/package.json

@@ -0,0 +1,108 @@
+{
+  "name": "@depup/sentry__react",
+  "version": "10.44.0-depup.0",
+  "description": "Official Sentry SDK for React.js (with updated dependencies)",
+  "repository": "git://github.com/getsentry/sentry-javascript.git",
+  "homepage": "https://github.com/getsentry/sentry-javascript/tree/master/packages/react",
+  "author": "Sentry",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "/build",
+    "changes.json",
+    "README.md"
+  ],
+  "main": "build/cjs/index.js",
+  "module": "build/esm/index.js",
+  "types": "build/types/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./build/types/index.d.ts",
+        "default": "./build/esm/index.js"
+      },
+      "require": {
+        "types": "./build/types/index.d.ts",
+        "default": "./build/cjs/index.js"
+      }
+    }
+  },
+  "typesVersions": {
+    "<5.0": {
+      "build/types/index.d.ts": [
+        "build/types-ts3.8/index.d.ts"
+      ]
+    }
+  },
+  "dependencies": {
+    "@sentry/browser": "10.44.0",
+    "@sentry/core": "10.44.0"
+  },
+  "peerDependencies": {
+    "react": "^16.14.0 || 17.x || 18.x || 19.x"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^15.0.5",
+    "@testing-library/react-hooks": "^7.0.2",
+    "@types/history-4": "npm:@types/history@4.7.8",
+    "@types/history-5": "npm:@types/history@4.7.8",
+    "@types/node-fetch": "^2.6.11",
+    "@types/react": "17.0.3",
+    "@types/react-router-4": "npm:@types/react-router@4.0.25",
+    "@types/react-router-5": "npm:@types/react-router@5.1.20",
+    "eslint-plugin-react": "^7.20.5",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "history-4": "npm:history@4.6.0",
+    "history-5": "npm:history@4.9.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-router-3": "npm:react-router@3.2.0",
+    "react-router-4": "npm:react-router@4.1.0",
+    "react-router-5": "npm:react-router@5.3.4",
+    "react-router-6": "npm:react-router@6.30.3",
+    "redux": "^4.0.5"
+  },
+  "scripts": {
+    "build": "run-p build:transpile build:types",
+    "build:dev": "yarn build",
+    "build:transpile": "rollup -c rollup.npm.config.mjs",
+    "build:types": "run-s build:types:core build:types:downlevel",
+    "build:types:core": "tsc -p tsconfig.types.json",
+    "build:types:downlevel": "yarn downlevel-dts build/types build/types-ts3.8 --to ts3.8",
+    "build:watch": "run-p build:transpile:watch",
+    "build:dev:watch": "yarn build:watch",
+    "build:transpile:watch": "rollup -c rollup.npm.config.mjs --watch",
+    "build:tarball": "npm pack",
+    "circularDepCheck": "madge --circular src/index.ts",
+    "clean": "rimraf build coverage sentry-react-*.tgz",
+    "lint:fix": "OXLINT_TSGOLINT_DANGEROUSLY_SUPPRESS_PROGRAM_DIAGNOSTICS=true oxlint . --fix --type-aware",
+    "lint": "OXLINT_TSGOLINT_DANGEROUSLY_SUPPRESS_PROGRAM_DIAGNOSTICS=true oxlint . --type-aware",
+    "lint:es-compatibility": "es-check es2020 ./build/cjs/*.js && es-check es2020 ./build/esm/*.js --module",
+    "test": "vitest run",
+    "test:watch": "vitest --watch",
+    "yalc:publish": "yalc publish --push --sig"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  },
+  "sideEffects": false,
+  "keywords": [
+    "@sentry/react",
+    "depup",
+    "updated-dependencies",
+    "security",
+    "latest",
+    "patched"
+  ],
+  "depup": {
+    "changes": {},
+    "depsUpdated": 0,
+    "originalPackage": "@sentry/react",
+    "originalVersion": "10.44.0",
+    "processedAt": "2026-03-18T22:43:10.239Z",
+    "smokeTest": "failed"
+  }
+}