@sentry/browser 10.22.0 → 10.25.0

package/build/npm/cjs/prod/eventbuilder.js

@@ -0,0 +1,397 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+
+/**
+ * This function creates an exception from a JavaScript Error
+ */
+function exceptionFromError(stackParser, ex) {
+  // Get the frames first since Opera can lose the stack if we touch anything else first
+  const frames = parseStackFrames(stackParser, ex);
+
+  const exception = {
+    type: extractType(ex),
+    value: extractMessage(ex),
+  };
+
+  if (frames.length) {
+    exception.stacktrace = { frames };
+  }
+
+  if (exception.type === undefined && exception.value === '') {
+    exception.value = 'Unrecoverable error caught';
+  }
+
+  return exception;
+}
+
+function eventFromPlainObject(
+  stackParser,
+  exception,
+  syntheticException,
+  isUnhandledRejection,
+) {
+  const client = core.getClient();
+  const normalizeDepth = client?.getOptions().normalizeDepth;
+
+  // If we can, we extract an exception from the object properties
+  const errorFromProp = getErrorPropertyFromObject(exception);
+
+  const extra = {
+    __serialized__: core.normalizeToSize(exception, normalizeDepth),
+  };
+
+  if (errorFromProp) {
+    return {
+      exception: {
+        values: [exceptionFromError(stackParser, errorFromProp)],
+      },
+      extra,
+    };
+  }
+
+  const event = {
+    exception: {
+      values: [
+        {
+          type: core.isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',
+          value: getNonErrorObjectExceptionValue(exception, { isUnhandledRejection }),
+        } ,
+      ],
+    },
+    extra,
+  } ;
+
+  if (syntheticException) {
+    const frames = parseStackFrames(stackParser, syntheticException);
+    if (frames.length) {
+      // event.exception.values[0] has been set above
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      event.exception.values[0].stacktrace = { frames };
+    }
+  }
+
+  return event;
+}
+
+function eventFromError(stackParser, ex) {
+  return {
+    exception: {
+      values: [exceptionFromError(stackParser, ex)],
+    },
+  };
+}
+
+/** Parses stack frames from an error */
+function parseStackFrames(
+  stackParser,
+  ex,
+) {
+  // Access and store the stacktrace property before doing ANYTHING
+  // else to it because Opera is not very good at providing it
+  // reliably in other circumstances.
+  const stacktrace = ex.stacktrace || ex.stack || '';
+
+  const skipLines = getSkipFirstStackStringLines(ex);
+  const framesToPop = getPopFirstTopFrames(ex);
+
+  try {
+    return stackParser(stacktrace, skipLines, framesToPop);
+  } catch {
+    // no-empty
+  }
+
+  return [];
+}
+
+// Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108
+const reactMinifiedRegexp = /Minified React error #\d+;/i;
+
+/**
+ * Certain known React errors contain links that would be falsely
+ * parsed as frames. This function check for these errors and
+ * returns number of the stack string lines to skip.
+ */
+function getSkipFirstStackStringLines(ex) {
+  if (ex && reactMinifiedRegexp.test(ex.message)) {
+    return 1;
+  }
+
+  return 0;
+}
+
+/**
+ * If error has `framesToPop` property, it means that the
+ * creator tells us the first x frames will be useless
+ * and should be discarded. Typically error from wrapper function
+ * which don't point to the actual location in the developer's code.
+ *
+ * Example: https://github.com/zertosh/invariant/blob/master/invariant.js#L46
+ */
+function getPopFirstTopFrames(ex) {
+  if (typeof ex.framesToPop === 'number') {
+    return ex.framesToPop;
+  }
+
+  return 0;
+}
+
+// https://developer.mozilla.org/en-US/docs/WebAssembly/JavaScript_interface/Exception
+// @ts-expect-error - WebAssembly.Exception is a valid class
+function isWebAssemblyException(exception) {
+  // Check for support
+  // @ts-expect-error - WebAssembly.Exception is a valid class
+  if (typeof WebAssembly !== 'undefined' && typeof WebAssembly.Exception !== 'undefined') {
+    // @ts-expect-error - WebAssembly.Exception is a valid class
+    return exception instanceof WebAssembly.Exception;
+  } else {
+    return false;
+  }
+}
+
+/**
+ * Extracts from errors what we use as the exception `type` in error events.
+ *
+ * Usually, this is the `name` property on Error objects but WASM errors need to be treated differently.
+ */
+function extractType(ex) {
+  const name = ex?.name;
+
+  // The name for WebAssembly.Exception Errors needs to be extracted differently.
+  // Context: https://github.com/getsentry/sentry-javascript/issues/13787
+  if (!name && isWebAssemblyException(ex)) {
+    // Emscripten sets array[type, message] to the "message" property on the WebAssembly.Exception object
+    const hasTypeInMessage = ex.message && Array.isArray(ex.message) && ex.message.length == 2;
+    return hasTypeInMessage ? ex.message[0] : 'WebAssembly.Exception';
+  }
+
+  return name;
+}
+
+/**
+ * There are cases where stacktrace.message is an Event object
+ * https://github.com/getsentry/sentry-javascript/issues/1949
+ * In this specific case we try to extract stacktrace.message.error.message
+ */
+function extractMessage(ex) {
+  const message = ex?.message;
+
+  if (isWebAssemblyException(ex)) {
+    // For Node 18, Emscripten sets array[type, message] to the "message" property on the WebAssembly.Exception object
+    if (Array.isArray(ex.message) && ex.message.length == 2) {
+      return ex.message[1];
+    }
+    return 'wasm exception';
+  }
+
+  if (!message) {
+    return 'No error message';
+  }
+
+  if (message.error && typeof message.error.message === 'string') {
+    return message.error.message;
+  }
+
+  return message;
+}
+
+/**
+ * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.
+ * @hidden
+ */
+function eventFromException(
+  stackParser,
+  exception,
+  hint,
+  attachStacktrace,
+) {
+  const syntheticException = hint?.syntheticException || undefined;
+  const event = eventFromUnknownInput(stackParser, exception, syntheticException, attachStacktrace);
+  core.addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }
+  event.level = 'error';
+  if (hint?.event_id) {
+    event.event_id = hint.event_id;
+  }
+  return core.resolvedSyncPromise(event);
+}
+
+/**
+ * Builds and Event from a Message
+ * @hidden
+ */
+function eventFromMessage(
+  stackParser,
+  message,
+  level = 'info',
+  hint,
+  attachStacktrace,
+) {
+  const syntheticException = hint?.syntheticException || undefined;
+  const event = eventFromString(stackParser, message, syntheticException, attachStacktrace);
+  event.level = level;
+  if (hint?.event_id) {
+    event.event_id = hint.event_id;
+  }
+  return core.resolvedSyncPromise(event);
+}
+
+/**
+ * @hidden
+ */
+function eventFromUnknownInput(
+  stackParser,
+  exception,
+  syntheticException,
+  attachStacktrace,
+  isUnhandledRejection,
+) {
+  let event;
+
+  if (core.isErrorEvent(exception ) && (exception ).error) {
+    // If it is an ErrorEvent with `error` property, extract it to get actual Error
+    const errorEvent = exception ;
+    return eventFromError(stackParser, errorEvent.error );
+  }
+
+  // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) then we just extract the name
+  // and message, as it doesn't provide anything else. According to the spec, all `DOMExceptions` should also be
+  // `Error`s, but that's not the case in IE11, so in that case we treat it the same as we do a `DOMError`.
+  //
+  // https://developer.mozilla.org/en-US/docs/Web/API/DOMError
+  // https://developer.mozilla.org/en-US/docs/Web/API/DOMException
+  // https://webidl.spec.whatwg.org/#es-DOMException-specialness
+  if (core.isDOMError(exception) || core.isDOMException(exception )) {
+    const domException = exception ;
+
+    if ('stack' in (exception )) {
+      event = eventFromError(stackParser, exception );
+    } else {
+      const name = domException.name || (core.isDOMError(domException) ? 'DOMError' : 'DOMException');
+      const message = domException.message ? `${name}: ${domException.message}` : name;
+      event = eventFromString(stackParser, message, syntheticException, attachStacktrace);
+      core.addExceptionTypeValue(event, message);
+    }
+    if ('code' in domException) {
+      // eslint-disable-next-line deprecation/deprecation
+      event.tags = { ...event.tags, 'DOMException.code': `${domException.code}` };
+    }
+
+    return event;
+  }
+  if (core.isError(exception)) {
+    // we have a real Error object, do nothing
+    return eventFromError(stackParser, exception);
+  }
+  if (core.isPlainObject(exception) || core.isEvent(exception)) {
+    // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize
+    // it manually. This will allow us to group events based on top-level keys which is much better than creating a new
+    // group on any key/value change.
+    const objectException = exception;
+    event = eventFromPlainObject(stackParser, objectException, syntheticException, isUnhandledRejection);
+    core.addExceptionMechanism(event, {
+      synthetic: true,
+    });
+    return event;
+  }
+
+  // If none of previous checks were valid, then it means that it's not:
+  // - an instance of DOMError
+  // - an instance of DOMException
+  // - an instance of Event
+  // - an instance of Error
+  // - a valid ErrorEvent (one with an error property)
+  // - a plain Object
+  //
+  // So bail out and capture it as a simple message:
+  event = eventFromString(stackParser, exception , syntheticException, attachStacktrace);
+  core.addExceptionTypeValue(event, `${exception}`, undefined);
+  core.addExceptionMechanism(event, {
+    synthetic: true,
+  });
+
+  return event;
+}
+
+function eventFromString(
+  stackParser,
+  message,
+  syntheticException,
+  attachStacktrace,
+) {
+  const event = {};
+
+  if (attachStacktrace && syntheticException) {
+    const frames = parseStackFrames(stackParser, syntheticException);
+    if (frames.length) {
+      event.exception = {
+        values: [{ value: message, stacktrace: { frames } }],
+      };
+    }
+    core.addExceptionMechanism(event, { synthetic: true });
+  }
+
+  if (core.isParameterizedString(message)) {
+    const { __sentry_template_string__, __sentry_template_values__ } = message;
+
+    event.logentry = {
+      message: __sentry_template_string__,
+      params: __sentry_template_values__,
+    };
+    return event;
+  }
+
+  event.message = message;
+  return event;
+}
+
+function getNonErrorObjectExceptionValue(
+  exception,
+  { isUnhandledRejection },
+) {
+  const keys = core.extractExceptionKeysForMessage(exception);
+  const captureType = isUnhandledRejection ? 'promise rejection' : 'exception';
+
+  // Some ErrorEvent instances do not have an `error` property, which is why they are not handled before
+  // We still want to try to get a decent message for these cases
+  if (core.isErrorEvent(exception)) {
+    return `Event \`ErrorEvent\` captured as ${captureType} with message \`${exception.message}\``;
+  }
+
+  if (core.isEvent(exception)) {
+    const className = getObjectClassName(exception);
+    return `Event \`${className}\` (type=${exception.type}) captured as ${captureType}`;
+  }
+
+  return `Object captured as ${captureType} with keys: ${keys}`;
+}
+
+function getObjectClassName(obj) {
+  try {
+    const prototype = Object.getPrototypeOf(obj);
+    return prototype ? prototype.constructor.name : undefined;
+  } catch {
+    // ignore errors here
+  }
+}
+
+/** If a plain object has a property that is an `Error`, return this error. */
+function getErrorPropertyFromObject(obj) {
+  for (const prop in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+      const value = obj[prop];
+      if (value instanceof Error) {
+        return value;
+      }
+    }
+  }
+
+  return undefined;
+}
+
+exports.eventFromException = eventFromException;
+exports.eventFromMessage = eventFromMessage;
+exports.eventFromUnknownInput = eventFromUnknownInput;
+exports.exceptionFromError = exceptionFromError;
+exports.extractMessage = extractMessage;
+exports.extractType = extractType;
+//# sourceMappingURL=eventbuilder.js.map

package/build/npm/cjs/prod/eventbuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventbuilder.js","sources":["../../../../src/eventbuilder.ts"],"sourcesContent":["import type {\n  Event,\n  EventHint,\n  Exception,\n  ParameterizedString,\n  SeverityLevel,\n  StackFrame,\n  StackParser,\n} from '@sentry/core';\nimport {\n  addExceptionMechanism,\n  addExceptionTypeValue,\n  extractExceptionKeysForMessage,\n  getClient,\n  isDOMError,\n  isDOMException,\n  isError,\n  isErrorEvent,\n  isEvent,\n  isParameterizedString,\n  isPlainObject,\n  normalizeToSize,\n  resolvedSyncPromise,\n} from '@sentry/core';\n\ntype Prototype = { constructor: (...args: unknown[]) => unknown };\n\n/**\n * This function creates an exception from a JavaScript Error\n */\nexport function exceptionFromError(stackParser: StackParser, ex: Error): Exception {\n  // Get the frames first since Opera can lose the stack if we touch anything else first\n  const frames = parseStackFrames(stackParser, ex);\n\n  const exception: Exception = {\n    type: extractType(ex),\n    value: extractMessage(ex),\n  };\n\n  if (frames.length) {\n    exception.stacktrace = { frames };\n  }\n\n  if (exception.type === undefined && exception.value === '') {\n    exception.value = 'Unrecoverable error caught';\n  }\n\n  return exception;\n}\n\nfunction eventFromPlainObject(\n  stackParser: StackParser,\n  exception: Record<string, unknown>,\n  syntheticException?: Error,\n  isUnhandledRejection?: boolean,\n): Event {\n  const client = getClient();\n  const normalizeDepth = client?.getOptions().normalizeDepth;\n\n  // If we can, we extract an exception from the object properties\n  const errorFromProp = getErrorPropertyFromObject(exception);\n\n  const extra = {\n    __serialized__: normalizeToSize(exception, normalizeDepth),\n  };\n\n  if (errorFromProp) {\n    return {\n      exception: {\n        values: [exceptionFromError(stackParser, errorFromProp)],\n      },\n      extra,\n    };\n  }\n\n  const event = {\n    exception: {\n      values: [\n        {\n          type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',\n          value: getNonErrorObjectExceptionValue(exception, { isUnhandledRejection }),\n        } as Exception,\n      ],\n    },\n    extra,\n  } satisfies Event;\n\n  if (syntheticException) {\n    const frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      // event.exception.values[0] has been set above\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      event.exception.values[0]!.stacktrace = { frames };\n    }\n  }\n\n  return event;\n}\n\nfunction eventFromError(stackParser: StackParser, ex: Error): Event {\n  return {\n    exception: {\n      values: [exceptionFromError(stackParser, ex)],\n    },\n  };\n}\n\n/** Parses stack frames from an error */\nfunction parseStackFrames(\n  stackParser: StackParser,\n  ex: Error & { framesToPop?: number; stacktrace?: string },\n): StackFrame[] {\n  // Access and store the stacktrace property before doing ANYTHING\n  // else to it because Opera is not very good at providing it\n  // reliably in other circumstances.\n  const stacktrace = ex.stacktrace || ex.stack || '';\n\n  const skipLines = getSkipFirstStackStringLines(ex);\n  const framesToPop = getPopFirstTopFrames(ex);\n\n  try {\n    return stackParser(stacktrace, skipLines, framesToPop);\n  } catch {\n    // no-empty\n  }\n\n  return [];\n}\n\n// Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108\nconst reactMinifiedRegexp = /Minified React error #\\d+;/i;\n\n/**\n * Certain known React errors contain links that would be falsely\n * parsed as frames. This function check for these errors and\n * returns number of the stack string lines to skip.\n */\nfunction getSkipFirstStackStringLines(ex: Error): number {\n  if (ex && reactMinifiedRegexp.test(ex.message)) {\n    return 1;\n  }\n\n  return 0;\n}\n\n/**\n * If error has `framesToPop` property, it means that the\n * creator tells us the first x frames will be useless\n * and should be discarded. Typically error from wrapper function\n * which don't point to the actual location in the developer's code.\n *\n * Example: https://github.com/zertosh/invariant/blob/master/invariant.js#L46\n */\nfunction getPopFirstTopFrames(ex: Error & { framesToPop?: unknown }): number {\n  if (typeof ex.framesToPop === 'number') {\n    return ex.framesToPop;\n  }\n\n  return 0;\n}\n\n// https://developer.mozilla.org/en-US/docs/WebAssembly/JavaScript_interface/Exception\n// @ts-expect-error - WebAssembly.Exception is a valid class\nfunction isWebAssemblyException(exception: unknown): exception is WebAssembly.Exception {\n  // Check for support\n  // @ts-expect-error - WebAssembly.Exception is a valid class\n  if (typeof WebAssembly !== 'undefined' && typeof WebAssembly.Exception !== 'undefined') {\n    // @ts-expect-error - WebAssembly.Exception is a valid class\n    return exception instanceof WebAssembly.Exception;\n  } else {\n    return false;\n  }\n}\n\n/**\n * Extracts from errors what we use as the exception `type` in error events.\n *\n * Usually, this is the `name` property on Error objects but WASM errors need to be treated differently.\n */\nexport function extractType(ex: Error & { message: { error?: Error } }): string | undefined {\n  const name = ex?.name;\n\n  // The name for WebAssembly.Exception Errors needs to be extracted differently.\n  // Context: https://github.com/getsentry/sentry-javascript/issues/13787\n  if (!name && isWebAssemblyException(ex)) {\n    // Emscripten sets array[type, message] to the \"message\" property on the WebAssembly.Exception object\n    const hasTypeInMessage = ex.message && Array.isArray(ex.message) && ex.message.length == 2;\n    return hasTypeInMessage ? ex.message[0] : 'WebAssembly.Exception';\n  }\n\n  return name;\n}\n\n/**\n * There are cases where stacktrace.message is an Event object\n * https://github.com/getsentry/sentry-javascript/issues/1949\n * In this specific case we try to extract stacktrace.message.error.message\n */\nexport function extractMessage(ex: Error & { message: { error?: Error } }): string {\n  const message = ex?.message;\n\n  if (isWebAssemblyException(ex)) {\n    // For Node 18, Emscripten sets array[type, message] to the \"message\" property on the WebAssembly.Exception object\n    if (Array.isArray(ex.message) && ex.message.length == 2) {\n      return ex.message[1];\n    }\n    return 'wasm exception';\n  }\n\n  if (!message) {\n    return 'No error message';\n  }\n\n  if (message.error && typeof message.error.message === 'string') {\n    return message.error.message;\n  }\n\n  return message;\n}\n\n/**\n * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.\n * @hidden\n */\nexport function eventFromException(\n  stackParser: StackParser,\n  exception: unknown,\n  hint?: EventHint,\n  attachStacktrace?: boolean,\n): PromiseLike<Event> {\n  const syntheticException = hint?.syntheticException || undefined;\n  const event = eventFromUnknownInput(stackParser, exception, syntheticException, attachStacktrace);\n  addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }\n  event.level = 'error';\n  if (hint?.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * Builds and Event from a Message\n * @hidden\n */\nexport function eventFromMessage(\n  stackParser: StackParser,\n  message: ParameterizedString,\n  level: SeverityLevel = 'info',\n  hint?: EventHint,\n  attachStacktrace?: boolean,\n): PromiseLike<Event> {\n  const syntheticException = hint?.syntheticException || undefined;\n  const event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n  event.level = level;\n  if (hint?.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * @hidden\n */\nexport function eventFromUnknownInput(\n  stackParser: StackParser,\n  exception: unknown,\n  syntheticException?: Error,\n  attachStacktrace?: boolean,\n  isUnhandledRejection?: boolean,\n): Event {\n  let event: Event;\n\n  if (isErrorEvent(exception as ErrorEvent) && (exception as ErrorEvent).error) {\n    // If it is an ErrorEvent with `error` property, extract it to get actual Error\n    const errorEvent = exception as ErrorEvent;\n    return eventFromError(stackParser, errorEvent.error as Error);\n  }\n\n  // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) then we just extract the name\n  // and message, as it doesn't provide anything else. According to the spec, all `DOMExceptions` should also be\n  // `Error`s, but that's not the case in IE11, so in that case we treat it the same as we do a `DOMError`.\n  //\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n  // https://webidl.spec.whatwg.org/#es-DOMException-specialness\n  if (isDOMError(exception) || isDOMException(exception as DOMException)) {\n    const domException = exception as DOMException;\n\n    if ('stack' in (exception as Error)) {\n      event = eventFromError(stackParser, exception as Error);\n    } else {\n      const name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n      const message = domException.message ? `${name}: ${domException.message}` : name;\n      event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n      addExceptionTypeValue(event, message);\n    }\n    if ('code' in domException) {\n      // eslint-disable-next-line deprecation/deprecation\n      event.tags = { ...event.tags, 'DOMException.code': `${domException.code}` };\n    }\n\n    return event;\n  }\n  if (isError(exception)) {\n    // we have a real Error object, do nothing\n    return eventFromError(stackParser, exception);\n  }\n  if (isPlainObject(exception) || isEvent(exception)) {\n    // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize\n    // it manually. This will allow us to group events based on top-level keys which is much better than creating a new\n    // group on any key/value change.\n    const objectException = exception;\n    event = eventFromPlainObject(stackParser, objectException, syntheticException, isUnhandledRejection);\n    addExceptionMechanism(event, {\n      synthetic: true,\n    });\n    return event;\n  }\n\n  // If none of previous checks were valid, then it means that it's not:\n  // - an instance of DOMError\n  // - an instance of DOMException\n  // - an instance of Event\n  // - an instance of Error\n  // - a valid ErrorEvent (one with an error property)\n  // - a plain Object\n  //\n  // So bail out and capture it as a simple message:\n  event = eventFromString(stackParser, exception as string, syntheticException, attachStacktrace);\n  addExceptionTypeValue(event, `${exception}`, undefined);\n  addExceptionMechanism(event, {\n    synthetic: true,\n  });\n\n  return event;\n}\n\nfunction eventFromString(\n  stackParser: StackParser,\n  message: ParameterizedString,\n  syntheticException?: Error,\n  attachStacktrace?: boolean,\n): Event {\n  const event: Event = {};\n\n  if (attachStacktrace && syntheticException) {\n    const frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      event.exception = {\n        values: [{ value: message, stacktrace: { frames } }],\n      };\n    }\n    addExceptionMechanism(event, { synthetic: true });\n  }\n\n  if (isParameterizedString(message)) {\n    const { __sentry_template_string__, __sentry_template_values__ } = message;\n\n    event.logentry = {\n      message: __sentry_template_string__,\n      params: __sentry_template_values__,\n    };\n    return event;\n  }\n\n  event.message = message;\n  return event;\n}\n\nfunction getNonErrorObjectExceptionValue(\n  exception: Record<string, unknown>,\n  { isUnhandledRejection }: { isUnhandledRejection?: boolean },\n): string {\n  const keys = extractExceptionKeysForMessage(exception);\n  const captureType = isUnhandledRejection ? 'promise rejection' : 'exception';\n\n  // Some ErrorEvent instances do not have an `error` property, which is why they are not handled before\n  // We still want to try to get a decent message for these cases\n  if (isErrorEvent(exception)) {\n    return `Event \\`ErrorEvent\\` captured as ${captureType} with message \\`${exception.message}\\``;\n  }\n\n  if (isEvent(exception)) {\n    const className = getObjectClassName(exception);\n    return `Event \\`${className}\\` (type=${exception.type}) captured as ${captureType}`;\n  }\n\n  return `Object captured as ${captureType} with keys: ${keys}`;\n}\n\nfunction getObjectClassName(obj: unknown): string | undefined | void {\n  try {\n    const prototype: Prototype | null = Object.getPrototypeOf(obj);\n    return prototype ? prototype.constructor.name : undefined;\n  } catch {\n    // ignore errors here\n  }\n}\n\n/** If a plain object has a property that is an `Error`, return this error. */\nfunction getErrorPropertyFromObject(obj: Record<string, unknown>): Error | undefined {\n  for (const prop in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, prop)) {\n      const value = obj[prop];\n      if (value instanceof Error) {\n        return value;\n      }\n    }\n  }\n\n  return undefined;\n}\n"],"names":["getClient","normalizeToSize","isEvent","addExceptionMechanism","resolvedSyncPromise","isErrorEvent","isDOMError","isDOMException","addExceptionTypeValue","isError","isPlainObject","isParameterizedString","extractExceptionKeysForMessage"],"mappings":"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"}

package/build/npm/cjs/prod/feedbackAsync.js

@@ -0,0 +1,15 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const feedback = require('@sentry-internal/feedback');
+const lazyLoadIntegration = require('./utils/lazyLoadIntegration.js');
+
+/**
+ * An integration to add user feedback to your application,
+ * while loading most of the code lazily only when it's needed.
+ */
+const feedbackAsyncIntegration = feedback.buildFeedbackIntegration({
+  lazyLoadIntegration: lazyLoadIntegration.lazyLoadIntegration,
+});
+
+exports.feedbackAsyncIntegration = feedbackAsyncIntegration;
+//# sourceMappingURL=feedbackAsync.js.map

package/build/npm/cjs/prod/feedbackAsync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feedbackAsync.js","sources":["../../../../src/feedbackAsync.ts"],"sourcesContent":["import { buildFeedbackIntegration } from '@sentry-internal/feedback';\nimport { lazyLoadIntegration } from './utils/lazyLoadIntegration';\n\n/**\n * An integration to add user feedback to your application,\n * while loading most of the code lazily only when it's needed.\n */\nexport const feedbackAsyncIntegration = buildFeedbackIntegration({\n  lazyLoadIntegration,\n});\n"],"names":["buildFeedbackIntegration","lazyLoadIntegration"],"mappings":";;;;;AAGA;AACA;AACA;AACA;AACO,MAAM,wBAAA,GAA2BA,iCAAwB,CAAC;AACjE,uBAAEC,uCAAmB;AACrB,CAAC;;;;"}

package/build/npm/cjs/prod/feedbackSync.js

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const feedback = require('@sentry-internal/feedback');
+
+/** Add a widget to capture user feedback to your application. */
+const feedbackSyncIntegration = feedback.buildFeedbackIntegration({
+  getModalIntegration: () => feedback.feedbackModalIntegration,
+  getScreenshotIntegration: () => feedback.feedbackScreenshotIntegration,
+});
+
+exports.feedbackSyncIntegration = feedbackSyncIntegration;
+//# sourceMappingURL=feedbackSync.js.map

package/build/npm/cjs/prod/feedbackSync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feedbackSync.js","sources":["../../../../src/feedbackSync.ts"],"sourcesContent":["import {\n  buildFeedbackIntegration,\n  feedbackModalIntegration,\n  feedbackScreenshotIntegration,\n} from '@sentry-internal/feedback';\n\n/** Add a widget to capture user feedback to your application. */\nexport const feedbackSyncIntegration = buildFeedbackIntegration({\n  getModalIntegration: () => feedbackModalIntegration,\n  getScreenshotIntegration: () => feedbackScreenshotIntegration,\n});\n"],"names":["buildFeedbackIntegration","feedbackModalIntegration","feedbackScreenshotIntegration"],"mappings":";;;;AAMA;AACO,MAAM,uBAAA,GAA0BA,iCAAwB,CAAC;AAChE,EAAE,mBAAmB,EAAE,MAAMC,iCAAwB;AACrD,EAAE,wBAAwB,EAAE,MAAMC,sCAA6B;AAC/D,CAAC;;;;"}

package/build/npm/cjs/prod/helpers.js

@@ -0,0 +1,185 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+
+const WINDOW = core.GLOBAL_OBJ ;
+
+let ignoreOnError = 0;
+
+/**
+ * @hidden
+ */
+function shouldIgnoreOnError() {
+  return ignoreOnError > 0;
+}
+
+/**
+ * @hidden
+ */
+function ignoreNextOnError() {
+  // onerror should trigger before setTimeout
+  ignoreOnError++;
+  setTimeout(() => {
+    ignoreOnError--;
+  });
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+
+/**
+ * Instruments the given function and sends an event to Sentry every time the
+ * function throws an exception.
+ *
+ * @param fn A function to wrap. It is generally safe to pass an unbound function, because the returned wrapper always
+ * has a correct `this` context.
+ * @returns The wrapped function.
+ * @hidden
+ */
+function wrap(
+  fn,
+  options
+
+ = {},
+) {
+  // for future readers what this does is wrap a function and then create
+  // a bi-directional wrapping between them.
+  //
+  // example: wrapped = wrap(original);
+  //  original.__sentry_wrapped__ -> wrapped
+  //  wrapped.__sentry_original__ -> original
+
+  function isFunction(fn) {
+    return typeof fn === 'function';
+  }
+
+  if (!isFunction(fn)) {
+    return fn;
+  }
+
+  try {
+    // if we're dealing with a function that was previously wrapped, return
+    // the original wrapper.
+    const wrapper = (fn ).__sentry_wrapped__;
+    if (wrapper) {
+      if (typeof wrapper === 'function') {
+        return wrapper;
+      } else {
+        // If we find that the `__sentry_wrapped__` function is not a function at the time of accessing it, it means
+        // that something messed with it. In that case we want to return the originally passed function.
+        return fn;
+      }
+    }
+
+    // We don't wanna wrap it twice
+    if (core.getOriginalFunction(fn)) {
+      return fn;
+    }
+  } catch {
+    // Just accessing custom props in some Selenium environments
+    // can cause a "Permission denied" exception (see raven-js#495).
+    // Bail on wrapping and return the function as-is (defers to window.onerror).
+    return fn;
+  }
+
+  // Wrap the function itself
+  // It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`
+  const sentryWrapped = function ( ...args) {
+    try {
+      // Also wrap arguments that are themselves functions
+      const wrappedArguments = args.map(arg => wrap(arg, options));
+
+      // Attempt to invoke user-land function
+      // NOTE: If you are a Sentry user, and you are seeing this stack frame, it
+      //       means the sentry.javascript SDK caught an error invoking your application code. This
+      //       is expected behavior and NOT indicative of a bug with sentry.javascript.
+      return fn.apply(this, wrappedArguments);
+    } catch (ex) {
+      ignoreNextOnError();
+
+      core.withScope(scope => {
+        scope.addEventProcessor(event => {
+          if (options.mechanism) {
+            core.addExceptionTypeValue(event, undefined, undefined);
+            core.addExceptionMechanism(event, options.mechanism);
+          }
+
+          event.extra = {
+            ...event.extra,
+            arguments: args,
+          };
+
+          return event;
+        });
+
+        // no need to add a mechanism here, we already add it via an event processor above
+        core.captureException(ex);
+      });
+
+      throw ex;
+    }
+  } ;
+
+  // Wrap the wrapped function in a proxy, to ensure any other properties of the original function remain available
+  try {
+    for (const property in fn) {
+      if (Object.prototype.hasOwnProperty.call(fn, property)) {
+        sentryWrapped[property ] = fn[property ];
+      }
+    }
+  } catch {
+    // Accessing some objects may throw
+    // ref: https://github.com/getsentry/sentry-javascript/issues/1168
+  }
+
+  // Signal that this function has been wrapped/filled already
+  // for both debugging and to prevent it to being wrapped/filled twice
+  core.markFunctionWrapped(sentryWrapped, fn);
+
+  core.addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped);
+
+  // Restore original function name (not all browsers allow that)
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name');
+    if (descriptor.configurable) {
+      Object.defineProperty(sentryWrapped, 'name', {
+        get() {
+          return fn.name;
+        },
+      });
+    }
+  } catch {
+    // This may throw if e.g. the descriptor does not exist, or a browser does not allow redefining `name`.
+    // to save some bytes we simply try-catch this
+  }
+
+  return sentryWrapped;
+}
+
+/**
+ * Get HTTP request data from the current page.
+ */
+function getHttpRequestData() {
+  // grab as much info as exists and add it to the event
+  const url = core.getLocationHref();
+  const { referrer } = WINDOW.document || {};
+  const { userAgent } = WINDOW.navigator || {};
+
+  const headers = {
+    ...(referrer && { Referer: referrer }),
+    ...(userAgent && { 'User-Agent': userAgent }),
+  };
+  const request = {
+    url,
+    headers,
+  };
+
+  return request;
+}
+
+exports.WINDOW = WINDOW;
+exports.getHttpRequestData = getHttpRequestData;
+exports.ignoreNextOnError = ignoreNextOnError;
+exports.shouldIgnoreOnError = shouldIgnoreOnError;
+exports.wrap = wrap;
+//# sourceMappingURL=helpers.js.map