logrocket/setup.js

JavaScript SDK for [LogRocket](https://logrocket.com/)

(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define([], factory);
	else {
		var a = factory();
		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
	}
})(this, function() {
return /******/ (function() { // webpackBootstrap
/******/ 	var __webpack_modules__ = ({

/***/ "./packages/@logrocket/console/src/index.js":
/*!**************************************************!*\
  !*** ./packages/@logrocket/console/src/index.js ***!
  \**************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
var _registerConsole = _interopRequireDefault(__webpack_require__(/*! ./registerConsole */ "./packages/@logrocket/console/src/registerConsole.js"));
var _default = _registerConsole.default;
exports["default"] = _default;

/***/ }),

/***/ "./packages/@logrocket/console/src/registerConsole.js":
/*!************************************************************!*\
  !*** ./packages/@logrocket/console/src/registerConsole.js ***!
  \************************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = registerConsole;
var _typeof2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/typeof */ "./node_modules/@babel/runtime/helpers/typeof.js"));
var _enhanceFunc = _interopRequireDefault(__webpack_require__(/*! @logrocket/utils/src/enhanceFunc */ "./packages/@logrocket/utils/src/enhanceFunc.ts"));
var _exceptions = __webpack_require__(/*! @logrocket/exceptions */ "./packages/@logrocket/exceptions/src/index.js");
// eslint-disable-line no-restricted-imports

function registerConsole(logger) {
  var unsubFunctions = [];
  var methods = ['log', 'warn', 'info', 'error', 'debug'];
  methods.forEach(function (method) {
    unsubFunctions.push((0, _enhanceFunc.default)(console, method, function () {
      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }
      logger.addEvent('lr.core.LogEvent', function () {
        var consoleOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
        var isEnabled = consoleOptions.isEnabled;
        if ((0, _typeof2.default)(isEnabled) === 'object' && isEnabled[method] === false || isEnabled === false) {
          return null;
        }
        if (method === 'error' && consoleOptions.shouldAggregateConsoleErrors) {
          // some customers have loggers that add the log level as the first arg
          if (!!args && args.length >= 2 && args[0] === 'ERROR') {
            var secondArg = '';
            try {
              secondArg = " ".concat(args[1]);
            } catch (_unused) {} // eslint-disable-line no-empty
            _exceptions.Capture.captureMessage(logger, "".concat(args[0]).concat(secondArg), args, {}, true);
          } else {
            _exceptions.Capture.captureMessage(logger, args[0], args, {}, true);
          }
        }
        return {
          logLevel: method.toUpperCase(),
          args: args
        };
      });
    }));
  });
  return function () {
    unsubFunctions.forEach(function (unsubFunction) {
      return unsubFunction();
    });
  };
}

/***/ }),

/***/ "./packages/@logrocket/exceptions/src/Capture.js":
/*!*******************************************************!*\
  !*** ./packages/@logrocket/exceptions/src/Capture.js ***!
  \*******************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.captureMessage = captureMessage;
exports.captureException = captureException;
var _scrubException = __webpack_require__(/*! @logrocket/utils/src/scrubException */ "./packages/@logrocket/utils/src/scrubException.ts");
var _TraceKit = _interopRequireDefault(__webpack_require__(/*! @logrocket/utils/src/TraceKit */ "./packages/@logrocket/utils/src/TraceKit.js"));
var _stackTraceFromError = _interopRequireDefault(__webpack_require__(/*! ./stackTraceFromError */ "./packages/@logrocket/exceptions/src/stackTraceFromError.js"));
// eslint-disable-line no-restricted-imports
// eslint-disable-line no-restricted-imports

function captureMessage(logger, message, messageArgs) {
  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
  var isConsole = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
  var data = {
    exceptionType: isConsole ? 'CONSOLE' : 'MESSAGE',
    message: message,
    messageArgs: messageArgs,
    browserHref: window.location ? window.location.href : ''
  };
  (0, _scrubException.scrubException)(data, options);
  logger.addEvent('lr.core.Exception', function () {
    return data;
  });
}
function captureException(logger, exception) {
  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  var preppedTrace = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
  var exceptionType = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 'WINDOW';
  var trace = preppedTrace || _TraceKit.default.computeStackTrace(exception);
  var data = {
    exceptionType: exceptionType,
    errorType: trace.name,
    message: trace.message,
    browserHref: window.location ? window.location.href : ''
  };
  (0, _scrubException.scrubException)(data, options);
  var addEventOptions = {
    _stackTrace: (0, _stackTraceFromError.default)(trace)
  };
  logger.addEvent('lr.core.Exception', function () {
    return data;
  }, addEventOptions);
}

/***/ }),

/***/ "./packages/@logrocket/exceptions/src/index.js":
/*!*****************************************************!*\
  !*** ./packages/@logrocket/exceptions/src/index.js ***!
  \*****************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");
var _typeof = __webpack_require__(/*! @babel/runtime/helpers/typeof */ "./node_modules/@babel/runtime/helpers/typeof.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
Object.defineProperty(exports, "registerExceptions", ({
  enumerable: true,
  get: function get() {
    return _registerExceptions.default;
  }
}));
exports.Capture = void 0;
var _registerExceptions = _interopRequireDefault(__webpack_require__(/*! ./registerExceptions */ "./packages/@logrocket/exceptions/src/registerExceptions.js"));
var Capture = _interopRequireWildcard(__webpack_require__(/*! ./Capture */ "./packages/@logrocket/exceptions/src/Capture.js"));
exports.Capture = Capture;
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

/***/ }),

/***/ "./packages/@logrocket/exceptions/src/raven/raven.js":
/*!***********************************************************!*\
  !*** ./packages/@logrocket/exceptions/src/raven/raven.js ***!
  \***********************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
var _classCallCheck2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "./node_modules/@babel/runtime/helpers/classCallCheck.js"));
var _createClass2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/createClass */ "./node_modules/@babel/runtime/helpers/createClass.js"));
var _TraceKit = _interopRequireDefault(__webpack_require__(/*! @logrocket/utils/src/TraceKit */ "./packages/@logrocket/utils/src/TraceKit.js"));
/* eslint-disable */

/*
Some contents of this file were originaly from raven-js, BSD-2 Clause

Copyright (c) 2018 Sentry (https://sentry.io) and individual contributors.
All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

var objectPrototype = Object.prototype;
function isUndefined(what) {
  return what === void 0;
}
function isFunction(what) {
  return typeof what === 'function';
}
function each(obj, callback) {
  var i, j;
  if (isUndefined(obj.length)) {
    for (i in obj) {
      if (hasKey(obj, i)) {
        callback.call(null, i, obj[i]);
      }
    }
  } else {
    j = obj.length;
    if (j) {
      for (i = 0; i < j; i++) {
        callback.call(null, i, obj[i]);
      }
    }
  }
}

/**
 * hasKey, a better form of hasOwnProperty
 * Example: hasKey(MainHostObject, property) === true/false
 *
 * @param {Object} host object to check property
 * @param {string} key to check
 */
function hasKey(object, key) {
  return objectPrototype.hasOwnProperty.call(object, key);
}

/**
 * Polyfill a method
 * @param obj object e.g. `document`
 * @param name method name present on object e.g. `addEventListener`
 * @param replacement replacement function
 * @param track {optional} record instrumentation to an array
 */
function fill(obj, name, replacement, track) {
  var orig = obj[name];
  obj[name] = replacement(orig);
  if (track) {
    track.push([obj, name, orig]);
  }
}
var _window = typeof window !== 'undefined' ? window : typeof __webpack_require__.g !== 'undefined' ? __webpack_require__.g : typeof self !== 'undefined' ? self : {};
var _document = _window.document;
var Handler = /*#__PURE__*/function () {
  function Handler(_ref) {
    var captureException = _ref.captureException;
    (0, _classCallCheck2.default)(this, Handler);
    this._errorHandler = this._errorHandler.bind(this);
    this._ignoreOnError = 0;
    this._wrappedBuiltIns = [];
    this.captureException = captureException;
    _TraceKit.default.report.subscribe(this._errorHandler);
    this._instrumentTryCatch();
  }
  (0, _createClass2.default)(Handler, [{
    key: "uninstall",
    value: function uninstall() {
      _TraceKit.default.report.unsubscribe(this._errorHandler);

      // restore any wrapped builtins
      var builtin;
      while (this._wrappedBuiltIns.length) {
        builtin = this._wrappedBuiltIns.shift();
        var obj = builtin[0],
          name = builtin[1],
          orig = builtin[2];
        obj[name] = orig;
      }
    }
  }, {
    key: "_errorHandler",
    value: function _errorHandler(report) {
      if (!this._ignoreOnError) {
        this.captureException(report);
      }
    }
  }, {
    key: "_ignoreNextOnError",
    value: function _ignoreNextOnError() {
      var _this = this;
      this._ignoreOnError += 1;
      setTimeout(function () {
        // onerror should trigger before setTimeout
        _this._ignoreOnError -= 1;
      });
    }

    /*
     * Wrap code within a context so Handler can capture errors
     * reliably across domains that is executed immediately.
     *
     * @param {object} options A specific set of options for this context [optional]
     * @param {function} func The callback to be immediately executed within the context
     * @param {array} args An array of arguments to be called with the callback [optional]
     */
  }, {
    key: "context",
    value: function context(options, func, args) {
      if (isFunction(options)) {
        args = func || [];
        func = options;
        options = undefined;
      }
      return this.wrap(options, func).apply(this, args);
    }
  }, {
    key: "wrap",
    value:
    /*
     * Wrap code within a context and returns back a new function to be executed
     *
     * @param {object} options A specific set of options for this context [optional]
     * @param {function} func The function to be wrapped in a new context
     * @param {function} func A function to call before the try/catch wrapper [optional, private]
     * @return {function} The newly wrapped functions with a context
     */
    function wrap(options, func, _before) {
      var self = this;
      // 1 argument has been passed, and it's not a function
      // so just return it
      if (isUndefined(func) && !isFunction(options)) {
        return options;
      }

      // options is optional
      if (isFunction(options)) {
        func = options;
        options = undefined;
      }

      // At this point, we've passed along 2 arguments, and the second one
      // is not a function either, so we'll just return the second argument.
      if (!isFunction(func)) {
        return func;
      }

      // We don't wanna wrap it twice!
      try {
        if (func.__lr__) {
          return func;
        }

        // If this has already been wrapped in the past, return that
        if (func.__lr_wrapper__) {
          return func.__lr_wrapper__;
        }

        // If func is not extensible, return the function as-is to prevent TypeErrors
        // when trying to add new props & to assure immutable funcs aren't changed
        if (!Object.isExtensible(func)) {
          return func;
        }
      } catch (e) {
        // Just accessing custom props in some Selenium environments
        // can cause a "Permission denied" exception (see lr-js#495).
        // Bail on wrapping and return the function as-is (defers to window.onerror).
        return func;
      }
      function wrapped() {
        var args = [],
          i = arguments.length,
          deep = !options || options && options.deep !== false;
        if (_before && isFunction(_before)) {
          _before.apply(this, arguments);
        }

        // Recursively wrap all of a function's arguments that are
        // functions themselves.
        while (i--) {
          args[i] = deep ? self.wrap(options, arguments[i]) : arguments[i];
        }
        try {
          // Attempt to invoke user-land function. This is part of the LogRocket SDK.
          // If you're seeing this frame in a stack trace, it means that LogRocket caught
          // an unhandled error thrown by your application code, reported it, then bubbled
          // it up. This is expected behavior and is not a bug with LogRocket.
          return func.apply(this, args);
        } catch (e) {
          self._ignoreNextOnError();
          self.captureException(_TraceKit.default.computeStackTrace(e), options);
          throw e;
        }
      }

      // copy over properties of the old function
      for (var property in func) {
        if (hasKey(func, property)) {
          wrapped[property] = func[property];
        }
      }
      wrapped.prototype = func.prototype;
      func.__lr_wrapper__ = wrapped;
      // Signal that this function has been wrapped already
      // for both debugging and to prevent it to being wrapped twice
      wrapped.__lr__ = true;
      wrapped.__inner__ = func;
      return wrapped;
    }
  }, {
    key: "_instrumentTryCatch",
    value:
    /**
     * Install any queued plugins
     */
    function _instrumentTryCatch() {
      var self = this;
      var wrappedBuiltIns = self._wrappedBuiltIns;
      function wrapTimeFn(orig) {
        return function (fn, t) {
          // preserve arity
          // Make a copy of the arguments to prevent deoptimization
          // https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments
          var args = new Array(arguments.length);
          for (var i = 0; i < args.length; ++i) {
            args[i] = arguments[i];
          }
          var originalCallback = args[0];
          if (isFunction(originalCallback)) {
            args[0] = self.wrap(originalCallback);
          }

          // IE < 9 doesn't support .call/.apply on setInterval/setTimeout, but it
          // also supports only two arguments and doesn't care what this is, so we
          // can just call the original function directly.
          if (orig.apply) {
            return orig.apply(this, args);
          } else {
            return orig(args[0], args[1]);
          }
        };
      }
      function wrapEventTarget(global) {
        var proto = _window[global] && _window[global].prototype;
        if (proto && proto.hasOwnProperty && proto.hasOwnProperty('addEventListener')) {
          fill(proto, 'addEventListener', function (orig) {
            return function (evtName, fn, capture, secure) {
              // preserve arity
              try {
                if (fn && fn.handleEvent) {
                  fn.handleEvent = self.wrap(fn.handleEvent);
                }
              } catch (err) {
                // can sometimes get 'Permission denied to access property "handle Event'
              }

              // More breadcrumb DOM capture ... done here and not in `_instrumentBreadcrumbs`
              // so that we don't have more than one wrapper function
              var before;
              return orig.call(this, evtName, self.wrap(fn, undefined, before), capture, secure);
            };
          }, wrappedBuiltIns);
          fill(proto, 'removeEventListener', function (orig) {
            return function (evt, fn, capture, secure) {
              /**
               * There are 3 scenararios to consider when removing an event listener
               *
               * 1. 'addEventListener' was called when the LR SDK was uninitialized.
               * In this case, the event handler has not been wrapped, so this behaves 
               * as a passthrough and just removes the original handler.
               *
               * 2. 'addEventListener' was called while the LR SDK was initialized, which means
               * our wrapped 'addEventListener' was called. In this case, the tracked event handler
               * is also wrapped, so we need to remove that wrapped version of the handler.
               *
               * 3. 'addEventListener' was called both before and after the LR SDK was initialized
               * for the same event handler. In this case, we have to remove both of them.
               * If we'd remove only the wrapped one, the initial handler would stick around forever.
               */
              try {
                var wrappedFn = fn === null || fn === void 0 ? void 0 : fn.__lr_wrapper__;
                if (wrappedFn) {
                  orig.call(this, evt, wrappedFn, capture, secure);
                }
              } catch (e) {
                // ignore, accessing __lr_wrapper__ will throw in some Selenium environments
              }
              return orig.call(this, evt, fn, capture, secure);
            };
          },
          // undefined is provided here to skip tracking for uninstall.
          // Once our removeEventListener is installed, it can't be uninstalled.
          // We always need to support removing logrocket wrapped event handlers (event
          // handlers added when logrocket was installed) even after SDK shutdown.
          undefined);
        }
      }
      fill(_window, 'setTimeout', wrapTimeFn, wrappedBuiltIns);
      fill(_window, 'setInterval', wrapTimeFn, wrappedBuiltIns);
      if (_window.requestAnimationFrame) {
        fill(_window, 'requestAnimationFrame', function (orig) {
          return function (cb) {
            return orig(self.wrap(cb));
          };
        }, wrappedBuiltIns);
      }

      // event targets borrowed from bugsnag-js:
      // https://github.com/bugsnag/bugsnag-js/blob/master/src/bugsnag.js#L666
      var eventTargets = ['EventTarget', 'Window', 'Node', 'ApplicationCache', 'AudioTrackList', 'ChannelMergerNode', 'CryptoOperation', 'EventSource', 'FileReader', 'HTMLUnknownElement', 'IDBDatabase', 'IDBRequest', 'IDBTransaction', 'KeyOperation', 'MediaController', 'MessagePort', 'ModalWindow', 'Notification', 'SVGElementInstance', 'Screen', 'TextTrack', 'TextTrackCue', 'TextTrackList', 'WebSocket', 'WebSocketWorker', 'Worker', 'XMLHttpRequest', 'XMLHttpRequestEventTarget', 'XMLHttpRequestUpload'];
      for (var i = 0; i < eventTargets.length; i++) {
        wrapEventTarget(eventTargets[i]);
      }
      var $ = _window.jQuery || _window.$;
      if ($ && $.fn && $.fn.ready) {
        fill($.fn, 'ready', function (orig) {
          return function (fn) {
            return orig.call(this, self.wrap(fn));
          };
        }, wrappedBuiltIns);
      }
    }
  }]);
  return Handler;
}();
exports["default"] = Handler;
;

/***/ }),

/***/ "./packages/@logrocket/exceptions/src/registerExceptions.js":
/*!******************************************************************!*\
  !*** ./packages/@logrocket/exceptions/src/registerExceptions.js ***!
  \******************************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");
var _typeof = __webpack_require__(/*! @babel/runtime/helpers/typeof */ "./node_modules/@babel/runtime/helpers/typeof.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = registerCore;
var _raven = _interopRequireDefault(__webpack_require__(/*! ./raven/raven */ "./packages/@logrocket/exceptions/src/raven/raven.js"));
var Capture = _interopRequireWildcard(__webpack_require__(/*! ./Capture */ "./packages/@logrocket/exceptions/src/Capture.js"));
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
function registerCore(logger) {
  var raven = new _raven.default({
    captureException: function captureException(errorReport) {
      Capture.captureException(logger, null, null, errorReport);
    }
  });
  var rejectionHandler = function rejectionHandler(evt) {
    // http://2ality.com/2016/04/unhandled-rejections.html
    if (evt.reason instanceof Error) {
      Capture.captureException(logger, evt.reason, null, null, 'UNHANDLED_REJECTION');
    } else {
      logger.addEvent('lr.core.Exception', function () {
        return {
          exceptionType: 'UNHANDLED_REJECTION',
          message: evt.reason || 'Unhandled Promise rejection'
        };
      });
    }
  };
  window.addEventListener('unhandledrejection', rejectionHandler);
  return function () {
    window.removeEventListener('unhandledrejection', rejectionHandler);
    raven.uninstall();
  };
}

/***/ }),

/***/ "./packages/@logrocket/exceptions/src/stackTraceFromError.js":
/*!*******************************************************************!*\
  !*** ./packages/@logrocket/exceptions/src/stackTraceFromError.js ***!
  \*******************************************************************/
/***/ (function(__unused_webpack_module, exports) {

"use strict";


Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = stackTraceFromError;
function stackTraceFromError(errorReport) {
  function makeNotNull(val) {
    return val === null ? undefined : val;
  }
  return errorReport.stack ? errorReport.stack.map(function (frame) {
    return {
      lineNumber: makeNotNull(frame.line),
      columnNumber: makeNotNull(frame.column),
      fileName: makeNotNull(frame.url),
      functionName: makeNotNull(frame.func)
    };
  }) : undefined;
}

/***/ }),

/***/ "./packages/@logrocket/network/src/fetchIntercept.js":
/*!***********************************************************!*\
  !*** ./packages/@logrocket/network/src/fetchIntercept.js ***!
  \***********************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
var _toConsumableArray2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/toConsumableArray */ "./node_modules/@babel/runtime/helpers/toConsumableArray.js"));
var _registerXHR = __webpack_require__(/*! ./registerXHR */ "./packages/@logrocket/network/src/registerXHR.js");
var interceptors = [];
function makeInterceptor(fetch, fetchId) {
  var reversedInterceptors = interceptors.reduce(function (array, interceptor) {
    return [interceptor].concat(array);
  }, []);
  // if a browser supports fetch, it supports promise
  // eslint-disable-next-line compat/compat
  for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
    args[_key - 2] = arguments[_key];
  }
  var promise = Promise.resolve(args);

  // Register request interceptors
  reversedInterceptors.forEach(function (_ref) {
    var request = _ref.request,
      requestError = _ref.requestError;
    if (request || requestError) {
      promise = promise.then(function (args) {
        return request.apply(void 0, [fetchId].concat((0, _toConsumableArray2.default)(args)));
      }, function (args) {
        return requestError.apply(void 0, [fetchId].concat((0, _toConsumableArray2.default)(args)));
      });
    }
  });
  promise = promise.then(function (args) {
    (0, _registerXHR.setActive)(false);
    var res;
    var err;
    try {
      res = fetch.apply(void 0, (0, _toConsumableArray2.default)(args));
    } catch (_err) {
      err = _err;
    }
    (0, _registerXHR.setActive)(true);
    if (err) {
      throw err;
    }
    return res;
  });
  reversedInterceptors.forEach(function (_ref2) {
    var response = _ref2.response,
      responseError = _ref2.responseError;
    if (response || responseError) {
      promise = promise.then(function (res) {
        return response(fetchId, res);
      }, function (err) {
        return responseError && responseError(fetchId, err);
      });
    }
  });
  return promise;
}
function attach(env) {
  if (!env.fetch || !env.Promise) {
    // Make sure fetch is available in the given environment. If it's not, then
    // default to using XHR intercept.
    return;
  }
  var isPolyfill = env.fetch.polyfill;

  // eslint-disable-next-line no-param-reassign
  env.fetch = function (fetch) {
    var fetchId = 0;
    return function () {
      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        args[_key2] = arguments[_key2];
      }
      return makeInterceptor.apply(void 0, [fetch, fetchId++].concat(args));
    };
  }(env.fetch);

  // Forward the polyfill properly from fetch (set by github/whatwg-fetch).
  if (isPolyfill) {
    // eslint-disable-next-line no-param-reassign
    env.fetch.polyfill = isPolyfill;
  }
}

// TODO: React Native
//   attach(global);

var didAttach = false;
var _default = {
  register: function register(interceptor) {
    if (!didAttach) {
      didAttach = true;
      attach(window);
    }
    interceptors.push(interceptor);
    return function () {
      var index = interceptors.indexOf(interceptor);
      if (index >= 0) {
        interceptors.splice(index, 1);
      }
    };
  },
  clear: function clear() {
    interceptors = [];
  }
};
exports["default"] = _default;

/***/ }),

/***/ "./packages/@logrocket/network/src/index.js":
/*!**************************************************!*\
  !*** ./packages/@logrocket/network/src/index.js ***!
  \**************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = registerNetwork;
var _defineProperty2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "./node_modules/@babel/runtime/helpers/defineProperty.js"));
var _typeof2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/typeof */ "./node_modules/@babel/runtime/helpers/typeof.js"));
var _registerFetch = _interopRequireDefault(__webpack_require__(/*! ./registerFetch */ "./packages/@logrocket/network/src/registerFetch.js"));
var _registerIonic = __webpack_require__(/*! ./registerIonic */ "./packages/@logrocket/network/src/registerIonic.ts");
var _registerNetworkInformation = _interopRequireDefault(__webpack_require__(/*! ./registerNetworkInformation */ "./packages/@logrocket/network/src/registerNetworkInformation.js"));
var _registerXHR = _interopRequireDefault(__webpack_require__(/*! ./registerXHR */ "./packages/@logrocket/network/src/registerXHR.js"));
var _mapValues = _interopRequireDefault(__webpack_require__(/*! @logrocket/utils/src/mapValues */ "./packages/@logrocket/utils/src/mapValues.js"));
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
// eslint-disable-line no-restricted-imports

function registerNetwork(logger) {
  var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
    isReactNative: false,
    isDisabled: false
  };
  if ((config === null || config === void 0 ? void 0 : config.isDisabled) === true) {
    return function () {};
  }
  var isReactNative = config.isReactNative,
    shouldAugmentNPS = config.shouldAugmentNPS,
    shouldParseXHRBlob = config.shouldParseXHRBlob;
  var ignoredNetwork = {};

  // truncate if > 4MB in size
  var truncate = function truncate(data) {
    var limit = 1024 * 1000 * 4;
    var str = data;
    if ((0, _typeof2.default)(data) === 'object' && data != null) {
      var proto = Object.getPrototypeOf(data);
      if (proto === Object.prototype || proto === null) {
        // plain object - jsonify for the size check
        str = JSON.stringify(data);
      }
    }
    if (str && str.length && str.length > limit && typeof str === 'string') {
      var beginning = str.substring(0, 1000);
      return "".concat(beginning, " ... LogRocket truncating to first 1000 characters.\n      Keep data under 4MB to prevent truncation. https://docs.logrocket.com/reference/network");
    }
    return data;
  };
  var addRequest = function addRequest(reqId, request) {
    var method = request.method;
    logger.addEvent('lr.network.RequestEvent', function () {
      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
        _ref$isEnabled = _ref.isEnabled,
        isEnabled = _ref$isEnabled === void 0 ? true : _ref$isEnabled,
        _ref$requestSanitizer = _ref.requestSanitizer,
        requestSanitizer = _ref$requestSanitizer === void 0 ? function (f) {
          return f;
        } : _ref$requestSanitizer;
      if (!isEnabled) {
        return null;
      }
      var sanitized = null;
      try {
        // only try catch user defined functions
        sanitized = requestSanitizer(_objectSpread(_objectSpread({}, request), {}, {
          reqId: reqId
        }));
      } catch (err) {
        console.error(err);
      }
      if (sanitized) {
        var url = sanitized.url;
        if (typeof document !== 'undefined' && typeof document.createElement === 'function') {
          // Writing and then reading from an a tag turns a relative
          // url into an absolute one.
          var a = document.createElement('a');
          a.href = sanitized.url;
          url = a.href;
        }
        return {
          reqId: reqId,
          // default
          url: url,
          // sanitized
          headers: (0, _mapValues.default)(sanitized.headers, function (headerValue) {
            // sanitized
            return "".concat(headerValue);
          }),
          body: truncate(sanitized.body),
          // sanitized
          method: method,
          // default
          referrer: sanitized.referrer || undefined,
          // sanitized
          mode: sanitized.mode || undefined,
          // sanitized
          credentials: sanitized.credentials || undefined // sanitized
        };
      }

      ignoredNetwork[reqId] = true;
      return null;
    });
  };
  var addResponse = function addResponse(reqId, response) {
    var method = response.method,
      status = response.status,
      responseType = response.responseType;
    logger.addEvent('lr.network.ResponseEvent', function () {
      var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
        _ref2$isEnabled = _ref2.isEnabled,
        isEnabled = _ref2$isEnabled === void 0 ? true : _ref2$isEnabled,
        _ref2$responseSanitiz = _ref2.responseSanitizer,
        responseSanitizer = _ref2$responseSanitiz === void 0 ? function (f) {
          return f;
        } : _ref2$responseSanitiz;
      if (!isEnabled) {
        return null;
      } else if (ignoredNetwork[reqId]) {
        delete ignoredNetwork[reqId];
        return null;
      }
      var sanitized = null;
      try {
        // only try catch user defined functions
        sanitized = responseSanitizer(_objectSpread(_objectSpread({}, response), {}, {
          reqId: reqId
        }));
      } catch (err) {
        console.error(err);
        // fall through to redacted log
      }

      if (sanitized) {
        return {
          reqId: reqId,
          // default
          responseType: responseType,
          status: sanitized.status,
          // sanitized
          headers: (0, _mapValues.default)(sanitized.headers, function (headerValue) {
            // sanitized
            return "".concat(headerValue);
          }),
          body: truncate(sanitized.body),
          // sanitized
          method: method // default
        };
      }

      return {
        reqId: reqId,
        // default
        responseType: responseType,
        status: status,
        // default
        headers: {},
        // redacted
        body: null,
        // redacted
        method: method // default
      };
    });
  };

  var isIgnored = function isIgnored(reqId) {
    return logger.isDisabled || ignoredNetwork[reqId] === true;
  };
  var unsubFetch = (0, _registerFetch.default)({
    addRequest: addRequest,
    addResponse: addResponse,
    isIgnored: isIgnored
  });
  var unsubXHR = (0, _registerXHR.default)({
    addRequest: addRequest,
    addResponse: addResponse,
    isIgnored: isIgnored,
    logger: logger,
    shouldAugmentNPS: shouldAugmentNPS,
    shouldParseXHRBlob: shouldParseXHRBlob
  });
  var unsubIonic = (0, _registerIonic.registerIonic)({
    addRequest: addRequest,
    addResponse: addResponse,
    isIgnored: isIgnored
  });
  var unsubNetworkInformation = isReactNative ? function () {} : (0, _registerNetworkInformation.default)(logger);
  return function () {
    unsubNetworkInformation();
    unsubFetch();
    unsubXHR();
    unsubIonic();
  };
}

/***/ }),

/***/ "./packages/@logrocket/network/src/registerFetch.js":
/*!**********************************************************!*\
  !*** ./packages/@logrocket/network/src/registerFetch.js ***!
  \**********************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = registerFetch;
var _defineProperty2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "./node_modules/@babel/runtime/helpers/defineProperty.js"));
var _mapValues = _interopRequireDefault(__webpack_require__(/*! @logrocket/utils/src/mapValues */ "./packages/@logrocket/utils/src/mapValues.js"));
var _fetchIntercept = _interopRequireDefault(__webpack_require__(/*! ./fetchIntercept */ "./packages/@logrocket/network/src/fetchIntercept.js"));
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
function makeObjectFromHeaders(headers) {
  // If using real fetch, we must stringify the Headers object.
  if (headers == null || typeof headers.forEach !== 'function') {
    return headers;
  }
  var result = {};
  headers.forEach(function (value, key) {
    if (result[key]) {
      result[key] = "".concat(result[key], ",").concat(value);
    } else {
      result[key] = "".concat(value);
    }
  });
  return result;
}

// XHR specification is unclear of what types to allow in value so using toString method for now
var stringifyHeaders = function stringifyHeaders(headers) {
  return (0, _mapValues.default)(makeObjectFromHeaders(headers), function (value) {
    return "".concat(value);
  });
};
function pluckFetchFields() {
  var arg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  return {
    url: arg.url,
    headers: stringifyHeaders(arg.headers),
    method: arg.method && arg.method.toUpperCase(),
    referrer: arg.referrer || undefined,
    mode: arg.mode || undefined,
    credentials: arg.credentials || undefined
  };
}
function registerFetch(_ref) {
  var addRequest = _ref.addRequest,
    addResponse = _ref.addResponse,
    isIgnored = _ref.isIgnored;
  var LOGROCKET_FETCH_LABEL = 'fetch-';
  var fetchMethodMap = {};
  var unregister = _fetchIntercept.default.register({
    request: function request(fetchId) {
      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
      }
      var p;
      if (typeof Request !== 'undefined' && args[0] instanceof Request) {
        var clonedText;

        // Request.clone() and Request.text() may throw in Safari (e.g., when
        // request body contains FormData)
        try {
          clonedText = args[0].clone().text();
        } catch (err) {
          // if a browser supports fetch, it supports promise
          // eslint-disable-next-line compat/compat
          clonedText = Promise.resolve("LogRocket fetch error: ".concat(err.message));
        }
        p = clonedText.then(function (body) {
          return _objectSpread(_objectSpread({}, pluckFetchFields(args[0])), {}, {
            body: body
          });
        }, function (err) {
          return _objectSpread(_objectSpread({}, pluckFetchFields(args[0])), {}, {
            body: "LogRocket fetch error: ".concat(err.message)
          });
        });
      } else {
        // if a browser supports fetch, it supports promise
        // eslint-disable-next-line compat/compat
        p = Promise.resolve(_objectSpread(_objectSpread({}, pluckFetchFields(args[1])), {}, {
          url: "".concat(args[0]),
          body: (args[1] || {}).body
        }));
      }
      return p.then(function (req) {
        fetchMethodMap[fetchId] = req.method;
        addRequest("".concat(LOGROCKET_FETCH_LABEL).concat(fetchId), req);
        return args;
      });
    },
    requestError: function requestError(fetchId, error) {
      // if a browser supports fetch, it supports promise
      // eslint-disable-next-line compat/compat
      return Promise.reject(error);
    },
    response: function response(fetchId, _response) {
      var responseClone;
      var responseTextPromise;
      if (isIgnored("".concat(LOGROCKET_FETCH_LABEL).concat(fetchId))) {
        // Don't even try to read ignored requests
        return _response;
      }

      // event-streams are meant to remain open and be consumed over time by the sender. Attempting to capture the body
      // of these requests will cause us to "stall" here, and prevents the users of our SDK from using event-streams
      // unless they have explicitly ignored the request.
      if (_response.headers.get('content-type') === 'text/event-stream') {
        // eslint-disable-next-line compat/compat
        responseTextPromise = Promise.resolve('LogRocket skipped consuming an event-stream body.');
      } else {
        try {
          // TODO: enhance function on original response and future clones for:
          // text(), json(), blob(), formdata(), arraybuffer()
          responseClone = _response.clone();
        } catch (err) {
          // safari has a bug where cloning can fail
          var responseHash = {
            url: _response.url,
            responseType: _response.type.toUpperCase(),
            status: _response.status,
            headers: stringifyHeaders(_response.headers),
            body: "LogRocket fetch error: ".concat(err.message),
            method: fetchMethodMap[fetchId]
          };
          delete fetchMethodMap[fetchId];
          addResponse("".concat(LOGROCKET_FETCH_LABEL).concat(fetchId), responseHash);
          return _response;
        }
        try {
          if (window.TextDecoder && responseClone.body) {
            // use a reader to manually read the response body rather than calling response.text()
            // response.text() was timing out for some responses, in some cases because Apollo sends
            //   an abort signal or because the stream wasn't getting terminated cleanly
            // using a reader allows us to capture what we can from response bodies before the
            //   response receives an abort signal
            var reader = responseClone.body.getReader();
            // response bodies always decode with UTF-8
            // https://developer.mozilla.org/en-US/docs/Web/API/Response/text
            var utf8Decoder = new window.TextDecoder('utf-8');
            var bodyContents = '';
            responseTextPromise = reader.read().then(function readResponseBody(_ref2) {
              var done = _ref2.done,
                value = _ref2.value;
              if (done) {
                return bodyContents;
              }
              var chunk = value ? utf8Decoder.decode(value, {
                stream: true
              }) : '';
              bodyContents += chunk;
              return reader.read().then(readResponseBody);
            });
          } else {
            // TextDecoder doesn't have support across all browsers that LR supports, so if there's
            //  no TextDecoder, fall back to the old approach
            responseTextPromise = responseClone.text();
          }
        } catch (error) {
          // eslint-disable-next-line compat/compat
          responseTextPromise = Promise.resolve("LogRocket error reading body: ".concat(error.message));
        }
      }
      responseTextPromise.catch(function (error) {
        // don't drop request & log to console when the request is aborted,
        // as it may have already completed
        // https://github.com/LogRocket/logrocket/issues/34
        if (error.name === 'AbortError' && error instanceof DOMException) {
          return;
        }
        return "LogRocket error reading body: ".concat(error.message);
      }).then(function (data) {
        var responseHash = {
          url: _response.url,
          responseType: _response.type.toUpperCase(),
          status: _response.status,
          headers: stringifyHeaders(_response.headers),
          body: data,
          method: fetchMethodMap[fetchId]
        };
        delete fetchMethodMap[fetchId];
        addResponse("".concat(LOGROCKET_FETCH_LABEL).concat(fetchId), responseHash);
      });
      return _response;
    },
    responseError: function responseError(fetchId, error) {
      var response = {
        url: undefined,
        status: 0,
        headers: {},
        body: "".concat(error)
      };
      addResponse("".concat(LOGROCKET_FETCH_LABEL).concat(fetchId), response);
      // if a browser supports fetch, it supports promise
      // eslint-disable-next-line compat/compat
      return Promise.reject(error);
    }
  });
  return unregister;
}

/***/ }),

/***/ "./packages/@logrocket/network/src/registerIonic.ts":
/*!**********************************************************!*\
  !*** ./packages/@logrocket/network/src/registerIonic.ts ***!
  \**********************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequ