@sentry/core 10.53.1 → 10.54.0

package/build/cjs/utils/flushIfServerless.js

@@ -7,70 +7,36 @@ const worldwide = require('./worldwide.js');
 
 async function flushWithTimeout(timeout) {
   try {
-    debugLogger.debug.log('Flushing events...');
+    debugLogger.debug.log("Flushing events...");
     await exports$1.flush(timeout);
-    debugLogger.debug.log('Done flushing events');
+    debugLogger.debug.log("Done flushing events");
   } catch (e) {
-    debugLogger.debug.log('Error while flushing events:\n', e);
+    debugLogger.debug.log("Error while flushing events:\n", e);
   }
 }
-
-/**
- *  Flushes the event queue with a timeout in serverless environments to ensure that events are sent to Sentry before the
- *  serverless function execution ends.
- *
- * The function is async, but in environments that support a `waitUntil` mechanism, it will run synchronously.
- *
- * This function is aware of the following serverless platforms:
- * - Cloudflare: If a Cloudflare context is provided, it will use `ctx.waitUntil()` to flush events (keeps the `this` context of `ctx`).
- *               If a `cloudflareWaitUntil` function is provided, it will use that to flush events (looses the `this` context of `ctx`).
- * - Vercel: It detects the Vercel environment and uses Vercel's `waitUntil` function.
- * - Other Serverless (AWS Lambda, Google Cloud, etc.): It detects the environment via environment variables
- *   and uses a regular `await flush()`.
- *
- *  @internal This function is supposed for internal Sentry SDK usage only.
- *  @hidden
- */
-async function flushIfServerless(
-  params
-
- = {},
-) {
-  const { timeout = 2000 } = params;
-
-  if ('cloudflareWaitUntil' in params && typeof params?.cloudflareWaitUntil === 'function') {
+async function flushIfServerless(params = {}) {
+  const { timeout = 2e3 } = params;
+  if ("cloudflareWaitUntil" in params && typeof params?.cloudflareWaitUntil === "function") {
     params.cloudflareWaitUntil(flushWithTimeout(timeout));
     return;
   }
-
-  if ('cloudflareCtx' in params && typeof params.cloudflareCtx?.waitUntil === 'function') {
+  if ("cloudflareCtx" in params && typeof params.cloudflareCtx?.waitUntil === "function") {
     params.cloudflareCtx.waitUntil(flushWithTimeout(timeout));
     return;
   }
-
-  // Note: vercelWaitUntil only does something in Vercel Edge runtime
-  // In Node runtime, we use process.on('SIGTERM') instead
-  // @ts-expect-error This is not typed
-  if (worldwide.GLOBAL_OBJ[Symbol.for('@vercel/request-context')]) {
-    // Vercel has a waitUntil equivalent that works without execution context
+  if (worldwide.GLOBAL_OBJ[/* @__PURE__ */ Symbol.for("@vercel/request-context")]) {
     vercelWaitUntil.vercelWaitUntil(flushWithTimeout(timeout));
     return;
   }
-
-  if (typeof process === 'undefined') {
+  if (typeof process === "undefined") {
     return;
   }
-
-  const isServerless =
-    !!process.env.FUNCTIONS_WORKER_RUNTIME || // Azure Functions
-    !!process.env.LAMBDA_TASK_ROOT || // AWS Lambda
-    !!process.env.K_SERVICE || // Google Cloud Run
-    !!process.env.CF_PAGES || // Cloudflare Pages
-    !!process.env.VERCEL ||
-    !!process.env.NETLIFY;
-
+  const isServerless = !!process.env.FUNCTIONS_WORKER_RUNTIME || // Azure Functions
+  !!process.env.LAMBDA_TASK_ROOT || // AWS Lambda
+  !!process.env.K_SERVICE || // Google Cloud Run
+  !!process.env.CF_PAGES || // Cloudflare Pages
+  !!process.env.VERCEL || !!process.env.NETLIFY;
   if (isServerless) {
-    // Use regular flush for environments without a generic waitUntil mechanism
     await flushWithTimeout(timeout);
   }
 }

package/build/cjs/utils/flushIfServerless.js.map

@@ -1 +1 @@
-{"version":3,"file":"flushIfServerless.js","sources":["../../../src/utils/flushIfServerless.ts"],"sourcesContent":["import { flush } from '../exports';\nimport { debug } from './debug-logger';\nimport { vercelWaitUntil } from './vercelWaitUntil';\nimport { GLOBAL_OBJ } from './worldwide';\n\ntype MinimalCloudflareContext = {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  waitUntil(promise: Promise<any>): void;\n};\n\nasync function flushWithTimeout(timeout: number): Promise<void> {\n  try {\n    debug.log('Flushing events...');\n    await flush(timeout);\n    debug.log('Done flushing events');\n  } catch (e) {\n    debug.log('Error while flushing events:\\n', e);\n  }\n}\n\n/**\n *  Flushes the event queue with a timeout in serverless environments to ensure that events are sent to Sentry before the\n *  serverless function execution ends.\n *\n * The function is async, but in environments that support a `waitUntil` mechanism, it will run synchronously.\n *\n * This function is aware of the following serverless platforms:\n * - Cloudflare: If a Cloudflare context is provided, it will use `ctx.waitUntil()` to flush events (keeps the `this` context of `ctx`).\n *               If a `cloudflareWaitUntil` function is provided, it will use that to flush events (looses the `this` context of `ctx`).\n * - Vercel: It detects the Vercel environment and uses Vercel's `waitUntil` function.\n * - Other Serverless (AWS Lambda, Google Cloud, etc.): It detects the environment via environment variables\n *   and uses a regular `await flush()`.\n *\n *  @internal This function is supposed for internal Sentry SDK usage only.\n *  @hidden\n */\nexport async function flushIfServerless(\n  params: // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    | { timeout?: number; cloudflareWaitUntil?: (task: Promise<any>) => void }\n    | { timeout?: number; cloudflareCtx?: MinimalCloudflareContext } = {},\n): Promise<void> {\n  const { timeout = 2000 } = params;\n\n  if ('cloudflareWaitUntil' in params && typeof params?.cloudflareWaitUntil === 'function') {\n    params.cloudflareWaitUntil(flushWithTimeout(timeout));\n    return;\n  }\n\n  if ('cloudflareCtx' in params && typeof params.cloudflareCtx?.waitUntil === 'function') {\n    params.cloudflareCtx.waitUntil(flushWithTimeout(timeout));\n    return;\n  }\n\n  // Note: vercelWaitUntil only does something in Vercel Edge runtime\n  // In Node runtime, we use process.on('SIGTERM') instead\n  // @ts-expect-error This is not typed\n  if (GLOBAL_OBJ[Symbol.for('@vercel/request-context')]) {\n    // Vercel has a waitUntil equivalent that works without execution context\n    vercelWaitUntil(flushWithTimeout(timeout));\n    return;\n  }\n\n  if (typeof process === 'undefined') {\n    return;\n  }\n\n  const isServerless =\n    !!process.env.FUNCTIONS_WORKER_RUNTIME || // Azure Functions\n    !!process.env.LAMBDA_TASK_ROOT || // AWS Lambda\n    !!process.env.K_SERVICE || // Google Cloud Run\n    !!process.env.CF_PAGES || // Cloudflare Pages\n    !!process.env.VERCEL ||\n    !!process.env.NETLIFY;\n\n  if (isServerless) {\n    // Use regular flush for environments without a generic waitUntil mechanism\n    await flushWithTimeout(timeout);\n  }\n}\n"],"names":["debug","flush","GLOBAL_OBJ","vercelWaitUntil"],"mappings":";;;;;;;AAUA,eAAe,gBAAgB,CAAC,OAAO,EAAyB;AAChE,EAAE,IAAI;AACN,IAAIA,iBAAK,CAAC,GAAG,CAAC,oBAAoB,CAAC;AACnC,IAAI,MAAMC,eAAK,CAAC,OAAO,CAAC;AACxB,IAAID,iBAAK,CAAC,GAAG,CAAC,sBAAsB,CAAC;AACrC,EAAE,CAAA,CAAE,OAAO,CAAC,EAAE;AACd,IAAIA,iBAAK,CAAC,GAAG,CAAC,gCAAgC,EAAE,CAAC,CAAC;AAClD,EAAE;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,eAAe,iBAAiB;AACvC,EAAE;;AAEE,GAAmE,EAAE;AACzE,EAAiB;AACjB,EAAE,MAAM,EAAE,OAAA,GAAU,IAAA,EAAK,GAAI,MAAM;;AAEnC,EAAE,IAAI,qBAAA,IAAyB,MAAA,IAAU,OAAO,MAAM,EAAE,mBAAA,KAAwB,UAAU,EAAE;AAC5F,IAAI,MAAM,CAAC,mBAAmB,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;AACzD,IAAI;AACJ,EAAE;;AAEF,EAAE,IAAI,eAAA,IAAmB,UAAU,OAAO,MAAM,CAAC,aAAa,EAAE,SAAA,KAAc,UAAU,EAAE;AAC1F,IAAI,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;AAC7D,IAAI;AACJ,EAAE;;AAEF;AACA;AACA;AACA,EAAE,IAAIE,oBAAU,CAAC,MAAM,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC,EAAE;AACzD;AACA,IAAIC,+BAAe,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;AAC9C,IAAI;AACJ,EAAE;;AAEF,EAAE,IAAI,OAAO,OAAA,KAAY,WAAW,EAAE;AACtC,IAAI;AACJ,EAAE;;AAEF,EAAE,MAAM,YAAA;AACR,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,wBAAA;AAClB,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,gBAAA;AAClB,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,SAAA;AAClB,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,QAAA;AAClB,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,MAAA;AAClB,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO;;AAEzB,EAAE,IAAI,YAAY,EAAE;AACpB;AACA,IAAI,MAAM,gBAAgB,CAAC,OAAO,CAAC;AACnC,EAAE;AACF;;;;"}
+{"version":3,"file":"flushIfServerless.js","sources":["../../../src/utils/flushIfServerless.ts"],"sourcesContent":["import { flush } from '../exports';\nimport { debug } from './debug-logger';\nimport { vercelWaitUntil } from './vercelWaitUntil';\nimport { GLOBAL_OBJ } from './worldwide';\n\ntype MinimalCloudflareContext = {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  waitUntil(promise: Promise<any>): void;\n};\n\nasync function flushWithTimeout(timeout: number): Promise<void> {\n  try {\n    debug.log('Flushing events...');\n    await flush(timeout);\n    debug.log('Done flushing events');\n  } catch (e) {\n    debug.log('Error while flushing events:\\n', e);\n  }\n}\n\n/**\n *  Flushes the event queue with a timeout in serverless environments to ensure that events are sent to Sentry before the\n *  serverless function execution ends.\n *\n * The function is async, but in environments that support a `waitUntil` mechanism, it will run synchronously.\n *\n * This function is aware of the following serverless platforms:\n * - Cloudflare: If a Cloudflare context is provided, it will use `ctx.waitUntil()` to flush events (keeps the `this` context of `ctx`).\n *               If a `cloudflareWaitUntil` function is provided, it will use that to flush events (looses the `this` context of `ctx`).\n * - Vercel: It detects the Vercel environment and uses Vercel's `waitUntil` function.\n * - Other Serverless (AWS Lambda, Google Cloud, etc.): It detects the environment via environment variables\n *   and uses a regular `await flush()`.\n *\n *  @internal This function is supposed for internal Sentry SDK usage only.\n *  @hidden\n */\nexport async function flushIfServerless(\n  params: // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    | { timeout?: number; cloudflareWaitUntil?: (task: Promise<any>) => void }\n    | { timeout?: number; cloudflareCtx?: MinimalCloudflareContext } = {},\n): Promise<void> {\n  const { timeout = 2000 } = params;\n\n  if ('cloudflareWaitUntil' in params && typeof params?.cloudflareWaitUntil === 'function') {\n    params.cloudflareWaitUntil(flushWithTimeout(timeout));\n    return;\n  }\n\n  if ('cloudflareCtx' in params && typeof params.cloudflareCtx?.waitUntil === 'function') {\n    params.cloudflareCtx.waitUntil(flushWithTimeout(timeout));\n    return;\n  }\n\n  // Note: vercelWaitUntil only does something in Vercel Edge runtime\n  // In Node runtime, we use process.on('SIGTERM') instead\n  // @ts-expect-error This is not typed\n  if (GLOBAL_OBJ[Symbol.for('@vercel/request-context')]) {\n    // Vercel has a waitUntil equivalent that works without execution context\n    vercelWaitUntil(flushWithTimeout(timeout));\n    return;\n  }\n\n  if (typeof process === 'undefined') {\n    return;\n  }\n\n  const isServerless =\n    !!process.env.FUNCTIONS_WORKER_RUNTIME || // Azure Functions\n    !!process.env.LAMBDA_TASK_ROOT || // AWS Lambda\n    !!process.env.K_SERVICE || // Google Cloud Run\n    !!process.env.CF_PAGES || // Cloudflare Pages\n    !!process.env.VERCEL ||\n    !!process.env.NETLIFY;\n\n  if (isServerless) {\n    // Use regular flush for environments without a generic waitUntil mechanism\n    await flushWithTimeout(timeout);\n  }\n}\n"],"names":["debug","flush","GLOBAL_OBJ","vercelWaitUntil"],"mappings":";;;;;;;AAUA,eAAe,iBAAiB,OAAA,EAAgC;AAC9D,EAAA,IAAI;AACF,IAAAA,iBAAA,CAAM,IAAI,oBAAoB,CAAA;AAC9B,IAAA,MAAMC,gBAAM,OAAO,CAAA;AACnB,IAAAD,iBAAA,CAAM,IAAI,sBAAsB,CAAA;AAAA,EAClC,SAAS,CAAA,EAAG;AACV,IAAAA,iBAAA,CAAM,GAAA,CAAI,kCAAkC,CAAC,CAAA;AAAA,EAC/C;AACF;AAkBA,eAAsB,iBAAA,CACpB,MAAA,GAEqE,EAAC,EACvD;AACf,EAAA,MAAM,EAAE,OAAA,GAAU,GAAA,EAAK,GAAI,MAAA;AAE3B,EAAA,IAAI,qBAAA,IAAyB,MAAA,IAAU,OAAO,MAAA,EAAQ,wBAAwB,UAAA,EAAY;AACxF,IAAA,MAAA,CAAO,mBAAA,CAAoB,gBAAA,CAAiB,OAAO,CAAC,CAAA;AACpD,IAAA;AAAA,EACF;AAEA,EAAA,IAAI,mBAAmB,MAAA,IAAU,OAAO,MAAA,CAAO,aAAA,EAAe,cAAc,UAAA,EAAY;AACtF,IAAA,MAAA,CAAO,aAAA,CAAc,SAAA,CAAU,gBAAA,CAAiB,OAAO,CAAC,CAAA;AACxD,IAAA;AAAA,EACF;AAKA,EAAA,IAAIE,oBAAA,iBAAW,MAAA,CAAO,GAAA,CAAI,yBAAyB,CAAC,CAAA,EAAG;AAErD,IAAAC,+BAAA,CAAgB,gBAAA,CAAiB,OAAO,CAAC,CAAA;AACzC,IAAA;AAAA,EACF;AAEA,EAAA,IAAI,OAAO,YAAY,WAAA,EAAa;AAClC,IAAA;AAAA,EACF;AAEA,EAAA,MAAM,YAAA,GACJ,CAAC,CAAC,OAAA,CAAQ,GAAA,CAAI,wBAAA;AAAA,EACd,CAAC,CAAC,OAAA,CAAQ,GAAA,CAAI,gBAAA;AAAA,EACd,CAAC,CAAC,OAAA,CAAQ,GAAA,CAAI,SAAA;AAAA,EACd,CAAC,CAAC,OAAA,CAAQ,GAAA,CAAI,QAAA;AAAA,EACd,CAAC,CAAC,OAAA,CAAQ,GAAA,CAAI,UACd,CAAC,CAAC,QAAQ,GAAA,CAAI,OAAA;AAEhB,EAAA,IAAI,YAAA,EAAc;AAEhB,IAAA,MAAM,iBAAiB,OAAO,CAAA;AAAA,EAChC;AACF;;;;"}

package/build/cjs/utils/get-default-export.js

@@ -1,31 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-/**
- * Often we patch a module's default export, but we want to be able to do
- * something like this:
- *
- * ```ts
- * patchTheThing(await import('the-thing'));
- * ```
- *
- * Or like this:
- *
- * ```ts
- * import theThing from 'the-thing';
- * patchTheThing(theThing);
- * ```
- *
- * Note: this does not support modules with a falsey default export. However,
- * presumably in those cases, there's no default export to patch anyway.
- */
 function getDefaultExport(moduleExport) {
-  return (
-    (!!moduleExport &&
-      typeof moduleExport === 'object' &&
-      'default' in moduleExport &&
-      (moduleExport ).default) ||
-    (moduleExport )
-  );
+  return !!moduleExport && typeof moduleExport === "object" && "default" in moduleExport && moduleExport.default || moduleExport;
 }
 
 exports.getDefaultExport = getDefaultExport;

package/build/cjs/utils/get-default-export.js.map

@@ -1 +1 @@
-{"version":3,"file":"get-default-export.js","sources":["../../../src/utils/get-default-export.ts"],"sourcesContent":["/**\n * Often we patch a module's default export, but we want to be able to do\n * something like this:\n *\n * ```ts\n * patchTheThing(await import('the-thing'));\n * ```\n *\n * Or like this:\n *\n * ```ts\n * import theThing from 'the-thing';\n * patchTheThing(theThing);\n * ```\n *\n * Note: this does not support modules with a falsey default export. However,\n * presumably in those cases, there's no default export to patch anyway.\n */\nexport function getDefaultExport<T>(moduleExport: T | { default: T }): T {\n  return (\n    (!!moduleExport &&\n      typeof moduleExport === 'object' &&\n      'default' in moduleExport &&\n      (moduleExport as { default: T }).default) ||\n    (moduleExport as T)\n  );\n}\n"],"names":[],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,gBAAgB,CAAI,YAAY,EAAyB;AACzE,EAAE;AACF,IAAI,CAAC,CAAC,CAAC,YAAA;AACP,MAAM,OAAO,YAAA,KAAiB,QAAA;AAC9B,MAAM,SAAA,IAAa,YAAA;AACnB,MAAM,CAAC,YAAA,GAAgC,OAAO;AAC9C,KAAK,YAAA;AACL;AACA;;;;"}
+{"version":3,"file":"get-default-export.js","sources":["../../../src/utils/get-default-export.ts"],"sourcesContent":["/**\n * Often we patch a module's default export, but we want to be able to do\n * something like this:\n *\n * ```ts\n * patchTheThing(await import('the-thing'));\n * ```\n *\n * Or like this:\n *\n * ```ts\n * import theThing from 'the-thing';\n * patchTheThing(theThing);\n * ```\n *\n * Note: this does not support modules with a falsey default export. However,\n * presumably in those cases, there's no default export to patch anyway.\n */\nexport function getDefaultExport<T>(moduleExport: T | { default: T }): T {\n  return (\n    (!!moduleExport &&\n      typeof moduleExport === 'object' &&\n      'default' in moduleExport &&\n      (moduleExport as { default: T }).default) ||\n    (moduleExport as T)\n  );\n}\n"],"names":[],"mappings":";;AAkBO,SAAS,iBAAoB,YAAA,EAAqC;AACvE,EAAA,OACG,CAAC,CAAC,YAAA,IACD,OAAO,iBAAiB,QAAA,IACxB,SAAA,IAAa,YAAA,IACZ,YAAA,CAAgC,OAAA,IAClC,YAAA;AAEL;;;;"}

package/build/cjs/utils/handleCallbackErrors.js

@@ -3,28 +3,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const chainAndCopyPromiselike = require('./chain-and-copy-promiselike.js');
 const is = require('./is.js');
 
-/* eslint-disable */
-// Vendor "Awaited" in to be TS 3.8 compatible
-
-/**
- * Wrap a callback function with error handling.
- * If an error is thrown, it will be passed to the `onError` callback and re-thrown.
- *
- * If the return value of the function is a promise, it will be handled with `maybeHandlePromiseRejection`.
- *
- * If an `onFinally` callback is provided, this will be called when the callback has finished
- * - so if it returns a promise, once the promise resolved/rejected,
- * else once the callback has finished executing.
- * The `onFinally` callback will _always_ be called, no matter if an error was thrown or not.
- */
-function handleCallbackErrors
-
-(
-  fn,
-  onError,
-  onFinally = () => {},
-  onSuccess = () => {},
-) {
+function handleCallbackErrors(fn, onError, onFinally = () => {
+}, onSuccess = () => {
+}) {
   let maybePromiseResult;
   try {
     maybePromiseResult = fn();
@@ -33,41 +14,22 @@ function handleCallbackErrors
     onFinally();
     throw e;
   }
-
   return maybeHandlePromiseRejection(maybePromiseResult, onError, onFinally, onSuccess);
 }
-
-/**
- * Maybe handle a promise rejection.
- * This expects to be given a value that _may_ be a promise, or any other value.
- * If it is a promise, and it rejects, it will call the `onError` callback.
- *
- * For thenable objects with extra methods (like jQuery's jqXHR),
- * this function preserves those methods by wrapping the original thenable in a Proxy
- * that intercepts .then() calls to apply error handling while forwarding all other
- * properties to the original object.
- * This allows code like `startSpan(() => $.ajax(...)).abort()` to work correctly.
- */
-function maybeHandlePromiseRejection(
-  value,
-  onError,
-  onFinally,
-  onSuccess,
-) {
+function maybeHandlePromiseRejection(value, onError, onFinally, onSuccess) {
   if (is.isThenable(value)) {
     return chainAndCopyPromiselike.chainAndCopyPromiseLike(
-      value ,
-      result => {
+      value,
+      (result) => {
         onFinally();
-        onSuccess(result );
+        onSuccess(result);
       },
-      err => {
+      (err) => {
         onError(err);
         onFinally();
-      },
-    ) ;
+      }
+    );
   }
-  // Non-thenable value - call callbacks immediately and return as-is
   onFinally();
   onSuccess(value);
   return value;

package/build/cjs/utils/handleCallbackErrors.js.map

@@ -1 +1 @@
-{"version":3,"file":"handleCallbackErrors.js","sources":["../../../src/utils/handleCallbackErrors.ts"],"sourcesContent":["import { chainAndCopyPromiseLike } from '../utils/chain-and-copy-promiselike';\nimport { isThenable } from '../utils/is';\n\n/* eslint-disable */\n// Vendor \"Awaited\" in to be TS 3.8 compatible\ntype AwaitedPromise<T> = T extends null | undefined\n  ? T // special case for `null | undefined` when not in `--strictNullChecks` mode\n  : T extends object & { then(onfulfilled: infer F, ...args: infer _): any } // `await` only unwraps object types with a callable `then`. Non-object types are not unwrapped\n    ? F extends (value: infer V, ...args: infer _) => any // if the argument to `then` is callable, extracts the first argument\n      ? V // normally this would recursively unwrap, but this is not possible in TS3.8\n      : never // the argument to `then` was not callable\n    : T; // non-object or non-thenable\n/* eslint-enable */\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function handleCallbackErrors<Fn extends () => Promise<any>, PromiseValue = AwaitedPromise<ReturnType<Fn>>>(\n  fn: Fn,\n  onError: (error: unknown) => void,\n  onFinally?: () => void,\n  onSuccess?: (result: PromiseValue) => void,\n): ReturnType<Fn>;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function handleCallbackErrors<Fn extends () => any>(\n  fn: Fn,\n  onError: (error: unknown) => void,\n  onFinally?: () => void,\n  onSuccess?: (result: ReturnType<Fn>) => void,\n): ReturnType<Fn>;\n/**\n * Wrap a callback function with error handling.\n * If an error is thrown, it will be passed to the `onError` callback and re-thrown.\n *\n * If the return value of the function is a promise, it will be handled with `maybeHandlePromiseRejection`.\n *\n * If an `onFinally` callback is provided, this will be called when the callback has finished\n * - so if it returns a promise, once the promise resolved/rejected,\n * else once the callback has finished executing.\n * The `onFinally` callback will _always_ be called, no matter if an error was thrown or not.\n */\nexport function handleCallbackErrors<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  Fn extends () => any,\n  ValueType = ReturnType<Fn>,\n>(\n  fn: Fn,\n  onError: (error: unknown) => void,\n  onFinally: () => void = () => {},\n  onSuccess: (result: ValueType | AwaitedPromise<ValueType>) => void = () => {},\n): ValueType {\n  let maybePromiseResult: ReturnType<Fn>;\n  try {\n    maybePromiseResult = fn();\n  } catch (e) {\n    onError(e);\n    onFinally();\n    throw e;\n  }\n\n  return maybeHandlePromiseRejection(maybePromiseResult, onError, onFinally, onSuccess);\n}\n\n/**\n * Maybe handle a promise rejection.\n * This expects to be given a value that _may_ be a promise, or any other value.\n * If it is a promise, and it rejects, it will call the `onError` callback.\n *\n * For thenable objects with extra methods (like jQuery's jqXHR),\n * this function preserves those methods by wrapping the original thenable in a Proxy\n * that intercepts .then() calls to apply error handling while forwarding all other\n * properties to the original object.\n * This allows code like `startSpan(() => $.ajax(...)).abort()` to work correctly.\n */\nfunction maybeHandlePromiseRejection<MaybePromise>(\n  value: MaybePromise,\n  onError: (error: unknown) => void,\n  onFinally: () => void,\n  onSuccess: (result: MaybePromise | AwaitedPromise<MaybePromise>) => void,\n): MaybePromise {\n  if (isThenable(value)) {\n    return chainAndCopyPromiseLike(\n      value as MaybePromise & PromiseLike<Awaited<typeof value>> & Record<string, unknown>,\n      result => {\n        onFinally();\n        onSuccess(result as Awaited<MaybePromise>);\n      },\n      err => {\n        onError(err);\n        onFinally();\n      },\n    ) as MaybePromise;\n  }\n  // Non-thenable value - call callbacks immediately and return as-is\n  onFinally();\n  onSuccess(value);\n  return value;\n}\n"],"names":["isThenable","chainAndCopyPromiseLike"],"mappings":";;;;;AAGA;AACA;;AAwBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS;;AAIhB;AACA,EAAE,EAAE;AACJ,EAAE,OAAO;AACT,EAAE,SAAS,GAAe,MAAM,CAAC,CAAC;AAClC,EAAE,SAAS,GAA4D,MAAM,CAAC,CAAC;AAC/E,EAAa;AACb,EAAE,IAAI,kBAAkB;AACxB,EAAE,IAAI;AACN,IAAI,kBAAA,GAAqB,EAAE,EAAE;AAC7B,EAAE,CAAA,CAAE,OAAO,CAAC,EAAE;AACd,IAAI,OAAO,CAAC,CAAC,CAAC;AACd,IAAI,SAAS,EAAE;AACf,IAAI,MAAM,CAAC;AACX,EAAE;;AAEF,EAAE,OAAO,2BAA2B,CAAC,kBAAkB,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,CAAC;AACvF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,2BAA2B;AACpC,EAAE,KAAK;AACP,EAAE,OAAO;AACT,EAAE,SAAS;AACX,EAAE,SAAS;AACX,EAAgB;AAChB,EAAE,IAAIA,aAAU,CAAC,KAAK,CAAC,EAAE;AACzB,IAAI,OAAOC,+CAAuB;AAClC,MAAM,KAAA;AACN,MAAM,UAAU;AAChB,QAAQ,SAAS,EAAE;AACnB,QAAQ,SAAS,CAAC,MAAA,EAAgC;AAClD,MAAM,CAAC;AACP,MAAM,OAAO;AACb,QAAQ,OAAO,CAAC,GAAG,CAAC;AACpB,QAAQ,SAAS,EAAE;AACnB,MAAM,CAAC;AACP,KAAI;AACJ,EAAE;AACF;AACA,EAAE,SAAS,EAAE;AACb,EAAE,SAAS,CAAC,KAAK,CAAC;AAClB,EAAE,OAAO,KAAK;AACd;;;;"}
+{"version":3,"file":"handleCallbackErrors.js","sources":["../../../src/utils/handleCallbackErrors.ts"],"sourcesContent":["import { chainAndCopyPromiseLike } from '../utils/chain-and-copy-promiselike';\nimport { isThenable } from '../utils/is';\n\n/* eslint-disable */\n// Vendor \"Awaited\" in to be TS 3.8 compatible\ntype AwaitedPromise<T> = T extends null | undefined\n  ? T // special case for `null | undefined` when not in `--strictNullChecks` mode\n  : T extends object & { then(onfulfilled: infer F, ...args: infer _): any } // `await` only unwraps object types with a callable `then`. Non-object types are not unwrapped\n    ? F extends (value: infer V, ...args: infer _) => any // if the argument to `then` is callable, extracts the first argument\n      ? V // normally this would recursively unwrap, but this is not possible in TS3.8\n      : never // the argument to `then` was not callable\n    : T; // non-object or non-thenable\n/* eslint-enable */\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function handleCallbackErrors<Fn extends () => Promise<any>, PromiseValue = AwaitedPromise<ReturnType<Fn>>>(\n  fn: Fn,\n  onError: (error: unknown) => void,\n  onFinally?: () => void,\n  onSuccess?: (result: PromiseValue) => void,\n): ReturnType<Fn>;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function handleCallbackErrors<Fn extends () => any>(\n  fn: Fn,\n  onError: (error: unknown) => void,\n  onFinally?: () => void,\n  onSuccess?: (result: ReturnType<Fn>) => void,\n): ReturnType<Fn>;\n/**\n * Wrap a callback function with error handling.\n * If an error is thrown, it will be passed to the `onError` callback and re-thrown.\n *\n * If the return value of the function is a promise, it will be handled with `maybeHandlePromiseRejection`.\n *\n * If an `onFinally` callback is provided, this will be called when the callback has finished\n * - so if it returns a promise, once the promise resolved/rejected,\n * else once the callback has finished executing.\n * The `onFinally` callback will _always_ be called, no matter if an error was thrown or not.\n */\nexport function handleCallbackErrors<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  Fn extends () => any,\n  ValueType = ReturnType<Fn>,\n>(\n  fn: Fn,\n  onError: (error: unknown) => void,\n  onFinally: () => void = () => {},\n  onSuccess: (result: ValueType | AwaitedPromise<ValueType>) => void = () => {},\n): ValueType {\n  let maybePromiseResult: ReturnType<Fn>;\n  try {\n    maybePromiseResult = fn();\n  } catch (e) {\n    onError(e);\n    onFinally();\n    throw e;\n  }\n\n  return maybeHandlePromiseRejection(maybePromiseResult, onError, onFinally, onSuccess);\n}\n\n/**\n * Maybe handle a promise rejection.\n * This expects to be given a value that _may_ be a promise, or any other value.\n * If it is a promise, and it rejects, it will call the `onError` callback.\n *\n * For thenable objects with extra methods (like jQuery's jqXHR),\n * this function preserves those methods by wrapping the original thenable in a Proxy\n * that intercepts .then() calls to apply error handling while forwarding all other\n * properties to the original object.\n * This allows code like `startSpan(() => $.ajax(...)).abort()` to work correctly.\n */\nfunction maybeHandlePromiseRejection<MaybePromise>(\n  value: MaybePromise,\n  onError: (error: unknown) => void,\n  onFinally: () => void,\n  onSuccess: (result: MaybePromise | AwaitedPromise<MaybePromise>) => void,\n): MaybePromise {\n  if (isThenable(value)) {\n    return chainAndCopyPromiseLike(\n      value as MaybePromise & PromiseLike<Awaited<typeof value>> & Record<string, unknown>,\n      result => {\n        onFinally();\n        onSuccess(result as Awaited<MaybePromise>);\n      },\n      err => {\n        onError(err);\n        onFinally();\n      },\n    ) as MaybePromise;\n  }\n  // Non-thenable value - call callbacks immediately and return as-is\n  onFinally();\n  onSuccess(value);\n  return value;\n}\n"],"names":["isThenable","chainAndCopyPromiseLike"],"mappings":";;;;;AAuCO,SAAS,oBAAA,CAKd,EAAA,EACA,OAAA,EACA,SAAA,GAAwB,MAAM;AAAC,CAAA,EAC/B,YAAqE,MAAM;AAAC,CAAA,EACjE;AACX,EAAA,IAAI,kBAAA;AACJ,EAAA,IAAI;AACF,IAAA,kBAAA,GAAqB,EAAA,EAAG;AAAA,EAC1B,SAAS,CAAA,EAAG;AACV,IAAA,OAAA,CAAQ,CAAC,CAAA;AACT,IAAA,SAAA,EAAU;AACV,IAAA,MAAM,CAAA;AAAA,EACR;AAEA,EAAA,OAAO,2BAAA,CAA4B,kBAAA,EAAoB,OAAA,EAAS,SAAA,EAAW,SAAS,CAAA;AACtF;AAaA,SAAS,2BAAA,CACP,KAAA,EACA,OAAA,EACA,SAAA,EACA,SAAA,EACc;AACd,EAAA,IAAIA,aAAA,CAAW,KAAK,CAAA,EAAG;AACrB,IAAA,OAAOC,+CAAA;AAAA,MACL,KAAA;AAAA,MACA,CAAA,MAAA,KAAU;AACR,QAAA,SAAA,EAAU;AACV,QAAA,SAAA,CAAU,MAA+B,CAAA;AAAA,MAC3C,CAAA;AAAA,MACA,CAAA,GAAA,KAAO;AACL,QAAA,OAAA,CAAQ,GAAG,CAAA;AACX,QAAA,SAAA,EAAU;AAAA,MACZ;AAAA,KACF;AAAA,EACF;AAEA,EAAA,SAAA,EAAU;AACV,EAAA,SAAA,CAAU,KAAK,CAAA;AACf,EAAA,OAAO,KAAA;AACT;;;;"}

package/build/cjs/utils/hasSpansEnabled.js

@@ -2,37 +2,13 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const currentScopes = require('../currentScopes.js');
 
-// Treeshakable guard to remove all code related to tracing
-
-/**
- * Determines if span recording is currently enabled.
- *
- * Spans are recorded when at least one of `tracesSampleRate` and `tracesSampler`
- * is defined in the SDK config. This function does not make any assumption about
- * sampling decisions, it only checks if the SDK is configured to record spans.
- *
- * Important: This function only determines if span recording is enabled. Trace
- * continuation and propagation is separately controlled and not covered by this function.
- * If this function returns `false`, traces can still be propagated (which is what
- * we refer to by "Tracing without Performance")
- * @see https://develop.sentry.dev/sdk/telemetry/traces/tracing-without-performance/
- *
- * @param maybeOptions An SDK options object to be passed to this function.
- * If this option is not provided, the function will use the current client's options.
- */
-function hasSpansEnabled(
-  maybeOptions,
-) {
-  if (typeof __SENTRY_TRACING__ === 'boolean' && !__SENTRY_TRACING__) {
+function hasSpansEnabled(maybeOptions) {
+  if (typeof __SENTRY_TRACING__ === "boolean" && !__SENTRY_TRACING__) {
     return false;
   }
-
   const options = maybeOptions || currentScopes.getClient()?.getOptions();
-  return (
-    !!options &&
-    // Note: This check is `!= null`, meaning "nullish". `0` is not "nullish", `undefined` and `null` are. (This comment was brought to you by 15 minutes of questioning life)
-    (options.tracesSampleRate != null || !!options.tracesSampler)
-  );
+  return !!options && // Note: This check is `!= null`, meaning "nullish". `0` is not "nullish", `undefined` and `null` are. (This comment was brought to you by 15 minutes of questioning life)
+  (options.tracesSampleRate != null || !!options.tracesSampler);
 }
 
 exports.hasSpansEnabled = hasSpansEnabled;

package/build/cjs/utils/hasSpansEnabled.js.map

@@ -1 +1 @@
-{"version":3,"file":"hasSpansEnabled.js","sources":["../../../src/utils/hasSpansEnabled.ts"],"sourcesContent":["import { getClient } from '../currentScopes';\nimport type { CoreOptions } from '../types-hoist/options';\n\n// Treeshakable guard to remove all code related to tracing\ndeclare const __SENTRY_TRACING__: boolean | undefined;\n\n/**\n * Determines if span recording is currently enabled.\n *\n * Spans are recorded when at least one of `tracesSampleRate` and `tracesSampler`\n * is defined in the SDK config. This function does not make any assumption about\n * sampling decisions, it only checks if the SDK is configured to record spans.\n *\n * Important: This function only determines if span recording is enabled. Trace\n * continuation and propagation is separately controlled and not covered by this function.\n * If this function returns `false`, traces can still be propagated (which is what\n * we refer to by \"Tracing without Performance\")\n * @see https://develop.sentry.dev/sdk/telemetry/traces/tracing-without-performance/\n *\n * @param maybeOptions An SDK options object to be passed to this function.\n * If this option is not provided, the function will use the current client's options.\n */\nexport function hasSpansEnabled(\n  maybeOptions?: Pick<CoreOptions, 'tracesSampleRate' | 'tracesSampler'> | undefined,\n): boolean {\n  if (typeof __SENTRY_TRACING__ === 'boolean' && !__SENTRY_TRACING__) {\n    return false;\n  }\n\n  const options = maybeOptions || getClient()?.getOptions();\n  return (\n    !!options &&\n    // Note: This check is `!= null`, meaning \"nullish\". `0` is not \"nullish\", `undefined` and `null` are. (This comment was brought to you by 15 minutes of questioning life)\n    (options.tracesSampleRate != null || !!options.tracesSampler)\n  );\n}\n"],"names":["getClient"],"mappings":";;;;AAGA;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,eAAe;AAC/B,EAAE,YAAY;AACd,EAAW;AACX,EAAE,IAAI,OAAO,kBAAA,KAAuB,SAAA,IAAa,CAAC,kBAAkB,EAAE;AACtE,IAAI,OAAO,KAAK;AAChB,EAAE;;AAEF,EAAE,MAAM,OAAA,GAAU,YAAA,IAAgBA,uBAAS,EAAE,EAAE,UAAU,EAAE;AAC3D,EAAE;AACF,IAAI,CAAC,CAAC,OAAA;AACN;AACA,KAAK,OAAO,CAAC,gBAAA,IAAoB,IAAA,IAAQ,CAAC,CAAC,OAAO,CAAC,aAAa;AAChE;AACA;;;;"}
+{"version":3,"file":"hasSpansEnabled.js","sources":["../../../src/utils/hasSpansEnabled.ts"],"sourcesContent":["import { getClient } from '../currentScopes';\nimport type { CoreOptions } from '../types/options';\n\n// Treeshakable guard to remove all code related to tracing\ndeclare const __SENTRY_TRACING__: boolean | undefined;\n\n/**\n * Determines if span recording is currently enabled.\n *\n * Spans are recorded when at least one of `tracesSampleRate` and `tracesSampler`\n * is defined in the SDK config. This function does not make any assumption about\n * sampling decisions, it only checks if the SDK is configured to record spans.\n *\n * Important: This function only determines if span recording is enabled. Trace\n * continuation and propagation is separately controlled and not covered by this function.\n * If this function returns `false`, traces can still be propagated (which is what\n * we refer to by \"Tracing without Performance\")\n * @see https://develop.sentry.dev/sdk/telemetry/traces/tracing-without-performance/\n *\n * @param maybeOptions An SDK options object to be passed to this function.\n * If this option is not provided, the function will use the current client's options.\n */\nexport function hasSpansEnabled(\n  maybeOptions?: Pick<CoreOptions, 'tracesSampleRate' | 'tracesSampler'> | undefined,\n): boolean {\n  if (typeof __SENTRY_TRACING__ === 'boolean' && !__SENTRY_TRACING__) {\n    return false;\n  }\n\n  const options = maybeOptions || getClient()?.getOptions();\n  return (\n    !!options &&\n    // Note: This check is `!= null`, meaning \"nullish\". `0` is not \"nullish\", `undefined` and `null` are. (This comment was brought to you by 15 minutes of questioning life)\n    (options.tracesSampleRate != null || !!options.tracesSampler)\n  );\n}\n"],"names":["getClient"],"mappings":";;;;AAsBO,SAAS,gBACd,YAAA,EACS;AACT,EAAA,IAAI,OAAO,kBAAA,KAAuB,SAAA,IAAa,CAAC,kBAAA,EAAoB;AAClE,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,MAAM,OAAA,GAAU,YAAA,IAAgBA,uBAAA,EAAU,EAAG,UAAA,EAAW;AACxD,EAAA,OACE,CAAC,CAAC,OAAA;AAAA,GAED,OAAA,CAAQ,gBAAA,IAAoB,IAAA,IAAQ,CAAC,CAAC,OAAA,CAAQ,aAAA,CAAA;AAEnD;;;;"}

package/build/cjs/utils/ipAddress.js

@@ -1,36 +1,24 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-// By default, we want to infer the IP address, unless this is explicitly set to `null`
-// We do this after all other processing is done
-// If `ip_address` is explicitly set to `null` or a value, we leave it as is
-
-/**
- * @internal
- * @deprecated -- set ip inferral via via SDK metadata options on client instead.
- */
 function addAutoIpAddressToUser(objWithMaybeUser) {
-  if (objWithMaybeUser.user?.ip_address === undefined) {
+  if (objWithMaybeUser.user?.ip_address === void 0) {
     objWithMaybeUser.user = {
       ...objWithMaybeUser.user,
-      ip_address: '{{auto}}',
+      ip_address: "{{auto}}"
     };
   }
 }
-
-/**
- * @internal
- */
 function addAutoIpAddressToSession(session) {
-  if ('aggregates' in session) {
-    if (session.attrs?.['ip_address'] === undefined) {
+  if ("aggregates" in session) {
+    if (session.attrs?.["ip_address"] === void 0) {
       session.attrs = {
         ...session.attrs,
-        ip_address: '{{auto}}',
+        ip_address: "{{auto}}"
       };
     }
   } else {
-    if (session.ipAddress === undefined) {
-      session.ipAddress = '{{auto}}';
+    if (session.ipAddress === void 0) {
+      session.ipAddress = "{{auto}}";
     }
   }
 }

package/build/cjs/utils/ipAddress.js.map

@@ -1 +1 @@
-{"version":3,"file":"ipAddress.js","sources":["../../../src/utils/ipAddress.ts"],"sourcesContent":["import type { Session, SessionAggregates } from '../types-hoist/session';\nimport type { User } from '../types-hoist/user';\n\n// By default, we want to infer the IP address, unless this is explicitly set to `null`\n// We do this after all other processing is done\n// If `ip_address` is explicitly set to `null` or a value, we leave it as is\n\n/**\n * @internal\n * @deprecated -- set ip inferral via via SDK metadata options on client instead.\n */\nexport function addAutoIpAddressToUser(objWithMaybeUser: { user?: User | null }): void {\n  if (objWithMaybeUser.user?.ip_address === undefined) {\n    objWithMaybeUser.user = {\n      ...objWithMaybeUser.user,\n      ip_address: '{{auto}}',\n    };\n  }\n}\n\n/**\n * @internal\n */\nexport function addAutoIpAddressToSession(session: Session | SessionAggregates): void {\n  if ('aggregates' in session) {\n    if (session.attrs?.['ip_address'] === undefined) {\n      session.attrs = {\n        ...session.attrs,\n        ip_address: '{{auto}}',\n      };\n    }\n  } else {\n    if (session.ipAddress === undefined) {\n      session.ipAddress = '{{auto}}';\n    }\n  }\n}\n"],"names":[],"mappings":";;AAGA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACO,SAAS,sBAAsB,CAAC,gBAAgB,EAAgC;AACvF,EAAE,IAAI,gBAAgB,CAAC,IAAI,EAAE,UAAA,KAAe,SAAS,EAAE;AACvD,IAAI,gBAAgB,CAAC,IAAA,GAAO;AAC5B,MAAM,GAAG,gBAAgB,CAAC,IAAI;AAC9B,MAAM,UAAU,EAAE,UAAU;AAC5B,KAAK;AACL,EAAE;AACF;;AAEA;AACA;AACA;AACO,SAAS,yBAAyB,CAAC,OAAO,EAAqC;AACtF,EAAE,IAAI,YAAA,IAAgB,OAAO,EAAE;AAC/B,IAAI,IAAI,OAAO,CAAC,KAAK,GAAG,YAAY,CAAA,KAAM,SAAS,EAAE;AACrD,MAAM,OAAO,CAAC,KAAA,GAAQ;AACtB,QAAQ,GAAG,OAAO,CAAC,KAAK;AACxB,QAAQ,UAAU,EAAE,UAAU;AAC9B,OAAO;AACP,IAAI;AACJ,EAAE,OAAO;AACT,IAAI,IAAI,OAAO,CAAC,SAAA,KAAc,SAAS,EAAE;AACzC,MAAM,OAAO,CAAC,SAAA,GAAY,UAAU;AACpC,IAAI;AACJ,EAAE;AACF;;;;;"}
+{"version":3,"file":"ipAddress.js","sources":["../../../src/utils/ipAddress.ts"],"sourcesContent":["import type { Session, SessionAggregates } from '../types/session';\nimport type { User } from '../types/user';\n\n// By default, we want to infer the IP address, unless this is explicitly set to `null`\n// We do this after all other processing is done\n// If `ip_address` is explicitly set to `null` or a value, we leave it as is\n\n/**\n * @internal\n * @deprecated -- set ip inferral via via SDK metadata options on client instead.\n */\nexport function addAutoIpAddressToUser(objWithMaybeUser: { user?: User | null }): void {\n  if (objWithMaybeUser.user?.ip_address === undefined) {\n    objWithMaybeUser.user = {\n      ...objWithMaybeUser.user,\n      ip_address: '{{auto}}',\n    };\n  }\n}\n\n/**\n * @internal\n */\nexport function addAutoIpAddressToSession(session: Session | SessionAggregates): void {\n  if ('aggregates' in session) {\n    if (session.attrs?.['ip_address'] === undefined) {\n      session.attrs = {\n        ...session.attrs,\n        ip_address: '{{auto}}',\n      };\n    }\n  } else {\n    if (session.ipAddress === undefined) {\n      session.ipAddress = '{{auto}}';\n    }\n  }\n}\n"],"names":[],"mappings":";;AAWO,SAAS,uBAAuB,gBAAA,EAAgD;AACrF,EAAA,IAAI,gBAAA,CAAiB,IAAA,EAAM,UAAA,KAAe,MAAA,EAAW;AACnD,IAAA,gBAAA,CAAiB,IAAA,GAAO;AAAA,MACtB,GAAG,gBAAA,CAAiB,IAAA;AAAA,MACpB,UAAA,EAAY;AAAA,KACd;AAAA,EACF;AACF;AAKO,SAAS,0BAA0B,OAAA,EAA4C;AACpF,EAAA,IAAI,gBAAgB,OAAA,EAAS;AAC3B,IAAA,IAAI,OAAA,CAAQ,KAAA,GAAQ,YAAY,CAAA,KAAM,MAAA,EAAW;AAC/C,MAAA,OAAA,CAAQ,KAAA,GAAQ;AAAA,QACd,GAAG,OAAA,CAAQ,KAAA;AAAA,QACX,UAAA,EAAY;AAAA,OACd;AAAA,IACF;AAAA,EACF,CAAA,MAAO;AACL,IAAA,IAAI,OAAA,CAAQ,cAAc,MAAA,EAAW;AACnC,MAAA,OAAA,CAAQ,SAAA,GAAY,UAAA;AAAA,IACtB;AAAA,EACF;AACF;;;;;"}

package/build/cjs/utils/is.js

@@ -1,182 +1,56 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-// eslint-disable-next-line @typescript-eslint/unbound-method
 const objectToString = Object.prototype.toString;
-
-/**
- * Checks whether given value's type is one of a few Error or Error-like
- * {@link isError}.
- *
- * @param wat A value to be checked.
- * @returns A boolean representing the result.
- */
 function isError(wat) {
   switch (objectToString.call(wat)) {
-    case '[object Error]':
-    case '[object Exception]':
-    case '[object DOMException]':
-    case '[object WebAssembly.Exception]':
+    case "[object Error]":
+    case "[object Exception]":
+    case "[object DOMException]":
+    case "[object WebAssembly.Exception]":
       return true;
     default:
       return isInstanceOf(wat, Error);
   }
 }
-/**
- * Checks whether given value is an instance of the given built-in class.
- *
- * @param wat The value to be checked
- * @param className
- * @returns A boolean representing the result.
- */
 function isBuiltin(wat, className) {
   return objectToString.call(wat) === `[object ${className}]`;
 }
-
-/**
- * Checks whether given value's type is ErrorEvent
- * {@link isErrorEvent}.
- *
- * @param wat A value to be checked.
- * @returns A boolean representing the result.
- */
 function isErrorEvent(wat) {
-  return isBuiltin(wat, 'ErrorEvent');
+  return isBuiltin(wat, "ErrorEvent");
 }
-
-/**
- * Checks whether given value's type is DOMError
- * {@link isDOMError}.
- *
- * @param wat A value to be checked.
- * @returns A boolean representing the result.
- */
 function isDOMError(wat) {
-  return isBuiltin(wat, 'DOMError');
+  return isBuiltin(wat, "DOMError");
 }
-
-/**
- * Checks whether given value's type is DOMException
- * {@link isDOMException}.
- *
- * @param wat A value to be checked.
- * @returns A boolean representing the result.
- */
 function isDOMException(wat) {
-  return isBuiltin(wat, 'DOMException');
+  return isBuiltin(wat, "DOMException");
 }
-
-/**
- * Checks whether given value's type is a string
- * {@link isString}.
- *
- * @param wat A value to be checked.
- * @returns A boolean representing the result.
- */
 function isString(wat) {
-  return isBuiltin(wat, 'String');
+  return isBuiltin(wat, "String");
 }
-
-/**
- * Checks whether given string is parameterized
- * {@link isParameterizedString}.
- *
- * @param wat A value to be checked.
- * @returns A boolean representing the result.
- */
 function isParameterizedString(wat) {
-  return (
-    typeof wat === 'object' &&
-    wat !== null &&
-    '__sentry_template_string__' in wat &&
-    '__sentry_template_values__' in wat
-  );
+  return typeof wat === "object" && wat !== null && "__sentry_template_string__" in wat && "__sentry_template_values__" in wat;
 }
-
-/**
- * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)
- * {@link isPrimitive}.
- *
- * @param wat A value to be checked.
- * @returns A boolean representing the result.
- */
 function isPrimitive(wat) {
-  return wat === null || isParameterizedString(wat) || (typeof wat !== 'object' && typeof wat !== 'function');
+  return wat === null || isParameterizedString(wat) || typeof wat !== "object" && typeof wat !== "function";
 }
-
-/**
- * Checks whether given value's type is an object literal, or a class instance.
- * {@link isPlainObject}.
- *
- * @param wat A value to be checked.
- * @returns A boolean representing the result.
- */
 function isPlainObject(wat) {
-  return isBuiltin(wat, 'Object');
+  return isBuiltin(wat, "Object");
 }
-
-/**
- * Checks whether given value's type is an Event instance
- * {@link isEvent}.
- *
- * @param wat A value to be checked.
- * @returns A boolean representing the result.
- */
 function isEvent(wat) {
-  return typeof Event !== 'undefined' && isInstanceOf(wat, Event);
+  return typeof Event !== "undefined" && isInstanceOf(wat, Event);
 }
-
-/**
- * Checks whether given value's type is an Element instance
- * {@link isElement}.
- *
- * @param wat A value to be checked.
- * @returns A boolean representing the result.
- */
 function isElement(wat) {
-  return typeof Element !== 'undefined' && isInstanceOf(wat, Element);
+  return typeof Element !== "undefined" && isInstanceOf(wat, Element);
 }
-
-/**
- * Checks whether given value's type is an regexp
- * {@link isRegExp}.
- *
- * @param wat A value to be checked.
- * @returns A boolean representing the result.
- */
 function isRegExp(wat) {
-  return isBuiltin(wat, 'RegExp');
+  return isBuiltin(wat, "RegExp");
 }
-
-/**
- * Checks whether given value has a then function.
- * @param wat A value to be checked.
- */
 function isThenable(wat) {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  return Boolean(wat?.then && typeof wat.then === 'function');
+  return Boolean(wat?.then && typeof wat.then === "function");
 }
-
-/**
- * Checks whether given value's type is a SyntheticEvent
- * {@link isSyntheticEvent}.
- *
- * @param wat A value to be checked.
- * @returns A boolean representing the result.
- */
 function isSyntheticEvent(wat) {
-  return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;
+  return isPlainObject(wat) && "nativeEvent" in wat && "preventDefault" in wat && "stopPropagation" in wat;
 }
-
-/**
- * Checks whether given value's type is an instance of provided constructor.
- * {@link isInstanceOf}.
- *
- * @param wat A value to be checked.
- * @param base A constructor to be used in a check.
- * @returns A boolean representing the result.
- */
-// TODO: fix in v11, convert any to unknown
-// export function isInstanceOf<T>(wat: unknown, base: { new (...args: any[]): T }): wat is T {
 function isInstanceOf(wat, base) {
   try {
     return wat instanceof base;
@@ -184,30 +58,11 @@ function isInstanceOf(wat, base) {
     return false;
   }
 }
-
-/**
- * Checks whether given value's type is a Vue ViewModel or a VNode.
- *
- * @param wat A value to be checked.
- * @returns A boolean representing the result.
- */
 function isVueViewModel(wat) {
-  // Not using Object.prototype.toString because in Vue 3 it would read the instance's Symbol(Symbol.toStringTag) property.
-  // We also need to check for __v_isVNode because Vue 3 component render instances have an internal __v_isVNode property.
-  return !!(
-    typeof wat === 'object' &&
-    wat !== null &&
-    ((wat ).__isVue || (wat )._isVue || (wat ).__v_isVNode)
-  );
+  return !!(typeof wat === "object" && wat !== null && (wat.__isVue || wat._isVue || wat.__v_isVNode));
 }
-
-/**
- * Checks whether the given parameter is a Standard Web API Request instance.
- *
- * Returns false if Request is not available in the current runtime.
- */
 function isRequest(request) {
-  return typeof Request !== 'undefined' && isInstanceOf(request, Request);
+  return typeof Request !== "undefined" && isInstanceOf(request, Request);
 }
 
 exports.isDOMError = isDOMError;