text: (function(e, a) { for(var i in a) e[i] = a[i]; }(exports, /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId]) {
  /******/ 			return installedModules[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  /******/
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  /******/
  /******/ 	// define getter function for harmony exports
  /******/ 	__webpack_require__.d = function(exports, name, getter) {
  /******/ 		if(!__webpack_require__.o(exports, name)) {
  /******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// define __esModule on exports
  /******/ 	__webpack_require__.r = function(exports) {
  /******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  /******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  /******/ 		}
  /******/ 		Object.defineProperty(exports, '__esModule', { value: true });
  /******/ 	};
  /******/
  /******/ 	// create a fake namespace object
  /******/ 	// mode & 1: value is a module id, require it
  /******/ 	// mode & 2: merge all properties of value into the ns
  /******/ 	// mode & 4: return value when already ns object
  /******/ 	// mode & 8|1: behave like require
  /******/ 	__webpack_require__.t = function(value, mode) {
  /******/ 		if(mode & 1) value = __webpack_require__(value);
  /******/ 		if(mode & 8) return value;
  /******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  /******/ 		var ns = Object.create(null);
  /******/ 		__webpack_require__.r(ns);
  /******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  /******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  /******/ 		return ns;
  /******/ 	};
  /******/
  /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  /******/ 	__webpack_require__.n = function(module) {
  /******/ 		var getter = module && module.__esModule ?
  /******/ 			function getDefault() { return module['default']; } :
  /******/ 			function getModuleExports() { return module; };
  /******/ 		__webpack_require__.d(getter, 'a', getter);
  /******/ 		return getter;
  /******/ 	};
  /******/
  /******/ 	// Object.prototype.hasOwnProperty.call
  /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  /******/
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(__webpack_require__.s = 549);
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ 0:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  const ansiStyles = __webpack_require__(97);
  const {stdout: stdoutColor, stderr: stderrColor} = __webpack_require__(72);
  const {
  	stringReplaceAll,
  	stringEncaseCRLFWithFirstIndex
  } = __webpack_require__(102);
  
  const {isArray} = Array;
  
  // `supportsColor.level` → `ansiStyles.color[name]` mapping
  const levelMapping = [
  	'ansi',
  	'ansi',
  	'ansi256',
  	'ansi16m'
  ];
  
  const styles = Object.create(null);
  
  const applyOptions = (object, options = {}) => {
  	if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
  		throw new Error('The `level` option should be an integer from 0 to 3');
  	}
  
  	// Detect level if not set manually
  	const colorLevel = stdoutColor ? stdoutColor.level : 0;
  	object.level = options.level === undefined ? colorLevel : options.level;
  };
  
  class ChalkClass {
  	constructor(options) {
  		// eslint-disable-next-line no-constructor-return
  		return chalkFactory(options);
  	}
  }
  
  const chalkFactory = options => {
  	const chalk = {};
  	applyOptions(chalk, options);
  
  	chalk.template = (...arguments_) => chalkTag(chalk.template, ...arguments_);
  
  	Object.setPrototypeOf(chalk, Chalk.prototype);
  	Object.setPrototypeOf(chalk.template, chalk);
  
  	chalk.template.constructor = () => {
  		throw new Error('`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.');
  	};
  
  	chalk.template.Instance = ChalkClass;
  
  	return chalk.template;
  };
  
  function Chalk(options) {
  	return chalkFactory(options);
  }
  
  for (const [styleName, style] of Object.entries(ansiStyles)) {
  	styles[styleName] = {
  		get() {
  			const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
  			Object.defineProperty(this, styleName, {value: builder});
  			return builder;
  		}
  	};
  }
  
  styles.visible = {
  	get() {
  		const builder = createBuilder(this, this._styler, true);
  		Object.defineProperty(this, 'visible', {value: builder});
  		return builder;
  	}
  };
  
  const usedModels = ['rgb', 'hex', 'keyword', 'hsl', 'hsv', 'hwb', 'ansi', 'ansi256'];
  
  for (const model of usedModels) {
  	styles[model] = {
  		get() {
  			const {level} = this;
  			return function (...arguments_) {
  				const styler = createStyler(ansiStyles.color[levelMapping[level]][model](...arguments_), ansiStyles.color.close, this._styler);
  				return createBuilder(this, styler, this._isEmpty);
  			};
  		}
  	};
  }
  
  for (const model of usedModels) {
  	const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
  	styles[bgModel] = {
  		get() {
  			const {level} = this;
  			return function (...arguments_) {
  				const styler = createStyler(ansiStyles.bgColor[levelMapping[level]][model](...arguments_), ansiStyles.bgColor.close, this._styler);
  				return createBuilder(this, styler, this._isEmpty);
  			};
  		}
  	};
  }
  
  const proto = Object.defineProperties(() => {}, {
  	...styles,
  	level: {
  		enumerable: true,
  		get() {
  			return this._generator.level;
  		},
  		set(level) {
  			this._generator.level = level;
  		}
  	}
  });
  
  const createStyler = (open, close, parent) => {
  	let openAll;
  	let closeAll;
  	if (parent === undefined) {
  		openAll = open;
  		closeAll = close;
  	} else {
  		openAll = parent.openAll + open;
  		closeAll = close + parent.closeAll;
  	}
  
  	return {
  		open,
  		close,
  		openAll,
  		closeAll,
  		parent
  	};
  };
  
  const createBuilder = (self, _styler, _isEmpty) => {
  	const builder = (...arguments_) => {
  		if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) {
  			// Called as a template literal, for example: chalk.red`2 + 3 = {bold ${2+3}}`
  			return applyStyle(builder, chalkTag(builder, ...arguments_));
  		}
  
  		// Single argument is hot path, implicit coercion is faster than anything
  		// eslint-disable-next-line no-implicit-coercion
  		return applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' '));
  	};
  
  	// We alter the prototype because we must return a function, but there is
  	// no way to create a function with a different prototype
  	Object.setPrototypeOf(builder, proto);
  
  	builder._generator = self;
  	builder._styler = _styler;
  	builder._isEmpty = _isEmpty;
  
  	return builder;
  };
  
  const applyStyle = (self, string) => {
  	if (self.level <= 0 || !string) {
  		return self._isEmpty ? '' : string;
  	}
  
  	let styler = self._styler;
  
  	if (styler === undefined) {
  		return string;
  	}
  
  	const {openAll, closeAll} = styler;
  	if (string.indexOf('\u001B') !== -1) {
  		while (styler !== undefined) {
  			// Replace any instances already present with a re-opening code
  			// otherwise only the part of the string until said closing code
  			// will be colored, and the rest will simply be 'plain'.
  			string = stringReplaceAll(string, styler.close, styler.open);
  
  			styler = styler.parent;
  		}
  	}
  
  	// We can move both next actions out of loop, because remaining actions in loop won't have
  	// any/visible effect on parts we add here. Close the styling before a linebreak and reopen
  	// after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92
  	const lfIndex = string.indexOf('\n');
  	if (lfIndex !== -1) {
  		string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
  	}
  
  	return openAll + string + closeAll;
  };
  
  let template;
  const chalkTag = (chalk, ...strings) => {
  	const [firstString] = strings;
  
  	if (!isArray(firstString) || !isArray(firstString.raw)) {
  		// If chalk() was called by itself or with a string,
  		// return the string itself as a string.
  		return strings.join(' ');
  	}
  
  	const arguments_ = strings.slice(1);
  	const parts = [firstString.raw[0]];
  
  	for (let i = 1; i < firstString.length; i++) {
  		parts.push(
  			String(arguments_[i - 1]).replace(/[{}\\]/g, '\\$&'),
  			String(firstString.raw[i])
  		);
  	}
  
  	if (template === undefined) {
  		template = __webpack_require__(103);
  	}
  
  	return template(chalk, parts.join(''));
  };
  
  Object.defineProperties(Chalk.prototype, styles);
  
  const chalk = Chalk(); // eslint-disable-line new-cap
  chalk.supportsColor = stdoutColor;
  chalk.stderr = Chalk({level: stderrColor ? stderrColor.level : 0}); // eslint-disable-line new-cap
  chalk.stderr.supportsColor = stderrColor;
  
  module.exports = chalk;
  
  
  /***/ }),
  
  /***/ 1:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return __extends; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return __assign; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return __rest; });
  /* unused harmony export __decorate */
  /* unused harmony export __param */
  /* unused harmony export __metadata */
  /* unused harmony export __awaiter */
  /* unused harmony export __generator */
  /* unused harmony export __createBinding */
  /* unused harmony export __exportStar */
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return __values; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return __read; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return __spread; });
  /* unused harmony export __spreadArrays */
  /* unused harmony export __await */
  /* unused harmony export __asyncGenerator */
  /* unused harmony export __asyncDelegator */
  /* unused harmony export __asyncValues */
  /* unused harmony export __makeTemplateObject */
  /* unused harmony export __importStar */
  /* unused harmony export __importDefault */
  /* unused harmony export __classPrivateFieldGet */
  /* unused harmony export __classPrivateFieldSet */
  /*! *****************************************************************************
  Copyright (c) Microsoft Corporation.
  
  Permission to use, copy, modify, and/or distribute this software for any
  purpose with or without fee is hereby granted.
  
  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  PERFORMANCE OF THIS SOFTWARE.
  ***************************************************************************** */
  /* global Reflect, Promise */
  
  var extendStatics = function(d, b) {
      extendStatics = Object.setPrototypeOf ||
          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
          function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
      return extendStatics(d, b);
  };
  
  function __extends(d, b) {
      extendStatics(d, b);
      function __() { this.constructor = d; }
      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  }
  
  var __assign = function() {
      __assign = Object.assign || function __assign(t) {
          for (var s, i = 1, n = arguments.length; i < n; i++) {
              s = arguments[i];
              for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
          }
          return t;
      }
      return __assign.apply(this, arguments);
  }
  
  function __rest(s, e) {
      var t = {};
      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
          t[p] = s[p];
      if (s != null && typeof Object.getOwnPropertySymbols === "function")
          for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
              if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                  t[p[i]] = s[p[i]];
          }
      return t;
  }
  
  function __decorate(decorators, target, key, desc) {
      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
      return c > 3 && r && Object.defineProperty(target, key, r), r;
  }
  
  function __param(paramIndex, decorator) {
      return function (target, key) { decorator(target, key, paramIndex); }
  }
  
  function __metadata(metadataKey, metadataValue) {
      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
  }
  
  function __awaiter(thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  }
  
  function __generator(thisArg, body) {
      var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
      function verb(n) { return function (v) { return step([n, v]); }; }
      function step(op) {
          if (f) throw new TypeError("Generator is already executing.");
          while (_) try {
              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
              if (y = 0, t) op = [op[0] & 2, t.value];
              switch (op[0]) {
                  case 0: case 1: t = op; break;
                  case 4: _.label++; return { value: op[1], done: false };
                  case 5: _.label++; y = op[1]; op = [0]; continue;
                  case 7: op = _.ops.pop(); _.trys.pop(); continue;
                  default:
                      if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                      if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                      if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                      if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                      if (t[2]) _.ops.pop();
                      _.trys.pop(); continue;
              }
              op = body.call(thisArg, _);
          } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
          if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
      }
  }
  
  function __createBinding(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }
  
  function __exportStar(m, exports) {
      for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];
  }
  
  function __values(o) {
      var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
      if (m) return m.call(o);
      if (o && typeof o.length === "number") return {
          next: function () {
              if (o && i >= o.length) o = void 0;
              return { value: o && o[i++], done: !o };
          }
      };
      throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
  }
  
  function __read(o, n) {
      var m = typeof Symbol === "function" && o[Symbol.iterator];
      if (!m) return o;
      var i = m.call(o), r, ar = [], e;
      try {
          while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
      }
      catch (error) { e = { error: error }; }
      finally {
          try {
              if (r && !r.done && (m = i["return"])) m.call(i);
          }
          finally { if (e) throw e.error; }
      }
      return ar;
  }
  
  function __spread() {
      for (var ar = [], i = 0; i < arguments.length; i++)
          ar = ar.concat(__read(arguments[i]));
      return ar;
  }
  
  function __spreadArrays() {
      for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
      for (var r = Array(s), k = 0, i = 0; i < il; i++)
          for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
              r[k] = a[j];
      return r;
  };
  
  function __await(v) {
      return this instanceof __await ? (this.v = v, this) : new __await(v);
  }
  
  function __asyncGenerator(thisArg, _arguments, generator) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var g = generator.apply(thisArg, _arguments || []), i, q = [];
      return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
      function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
      function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
      function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
      function fulfill(value) { resume("next", value); }
      function reject(value) { resume("throw", value); }
      function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
  }
  
  function __asyncDelegator(o) {
      var i, p;
      return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
      function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
  }
  
  function __asyncValues(o) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var m = o[Symbol.asyncIterator], i;
      return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
      function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
      function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
  }
  
  function __makeTemplateObject(cooked, raw) {
      if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
      return cooked;
  };
  
  function __importStar(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result.default = mod;
      return result;
  }
  
  function __importDefault(mod) {
      return (mod && mod.__esModule) ? mod : { default: mod };
  }
  
  function __classPrivateFieldGet(receiver, privateMap) {
      if (!privateMap.has(receiver)) {
          throw new TypeError("attempted to get private field on non-instance");
      }
      return privateMap.get(receiver);
  }
  
  function __classPrivateFieldSet(receiver, privateMap, value) {
      if (!privateMap.has(receiver)) {
          throw new TypeError("attempted to set private field on non-instance");
      }
      privateMap.set(receiver, value);
      return value;
  }
  
  
  /***/ }),
  
  /***/ 10:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return SpanStatus; });
  /** The status of an Span. */
  // eslint-disable-next-line import/export
  var SpanStatus;
  (function (SpanStatus) {
      /** The operation completed successfully. */
      SpanStatus["Ok"] = "ok";
      /** Deadline expired before operation could complete. */
      SpanStatus["DeadlineExceeded"] = "deadline_exceeded";
      /** 401 Unauthorized (actually does mean unauthenticated according to RFC 7235) */
      SpanStatus["Unauthenticated"] = "unauthenticated";
      /** 403 Forbidden */
      SpanStatus["PermissionDenied"] = "permission_denied";
      /** 404 Not Found. Some requested entity (file or directory) was not found. */
      SpanStatus["NotFound"] = "not_found";
      /** 429 Too Many Requests */
      SpanStatus["ResourceExhausted"] = "resource_exhausted";
      /** Client specified an invalid argument. 4xx. */
      SpanStatus["InvalidArgument"] = "invalid_argument";
      /** 501 Not Implemented */
      SpanStatus["Unimplemented"] = "unimplemented";
      /** 503 Service Unavailable */
      SpanStatus["Unavailable"] = "unavailable";
      /** Other/generic 5xx. */
      SpanStatus["InternalError"] = "internal_error";
      /** Unknown. Any non-standard HTTP status code. */
      SpanStatus["UnknownError"] = "unknown_error";
      /** The operation was cancelled (typically by the user). */
      SpanStatus["Cancelled"] = "cancelled";
      /** Already exists (409) */
      SpanStatus["AlreadyExists"] = "already_exists";
      /** Operation was rejected because the system is not in a state required for the operation's */
      SpanStatus["FailedPrecondition"] = "failed_precondition";
      /** The operation was aborted, typically due to a concurrency issue. */
      SpanStatus["Aborted"] = "aborted";
      /** Operation was attempted past the valid range. */
      SpanStatus["OutOfRange"] = "out_of_range";
      /** Unrecoverable data loss or corruption */
      SpanStatus["DataLoss"] = "data_loss";
  })(SpanStatus || (SpanStatus = {}));
  // eslint-disable-next-line @typescript-eslint/no-namespace, import/export
  (function (SpanStatus) {
      /**
       * Converts a HTTP status code into a {@link SpanStatus}.
       *
       * @param httpStatus The HTTP response status code.
       * @returns The span status or {@link SpanStatus.UnknownError}.
       */
      function fromHttpCode(httpStatus) {
          if (httpStatus < 400) {
              return SpanStatus.Ok;
          }
          if (httpStatus >= 400 && httpStatus < 500) {
              switch (httpStatus) {
                  case 401:
                      return SpanStatus.Unauthenticated;
                  case 403:
                      return SpanStatus.PermissionDenied;
                  case 404:
                      return SpanStatus.NotFound;
                  case 409:
                      return SpanStatus.AlreadyExists;
                  case 413:
                      return SpanStatus.FailedPrecondition;
                  case 429:
                      return SpanStatus.ResourceExhausted;
                  default:
                      return SpanStatus.InvalidArgument;
              }
          }
          if (httpStatus >= 500 && httpStatus < 600) {
              switch (httpStatus) {
                  case 501:
                      return SpanStatus.Unimplemented;
                  case 503:
                      return SpanStatus.Unavailable;
                  case 504:
                      return SpanStatus.DeadlineExceeded;
                  default:
                      return SpanStatus.InternalError;
              }
          }
          return SpanStatus.UnknownError;
      }
      SpanStatus.fromHttpCode = fromHttpCode;
  })(SpanStatus || (SpanStatus = {}));
  //# sourceMappingURL=spanstatus.js.map
  
  /***/ }),
  
  /***/ 100:
  /***/ (function(module, exports, __webpack_require__) {
  
  const conversions = __webpack_require__(61);
  
  /*
  	This function routes a model to all other models.
  
  	all functions that are routed have a property `.conversion` attached
  	to the returned synthetic function. This property is an array
  	of strings, each with the steps in between the 'from' and 'to'
  	color models (inclusive).
  
  	conversions that are not possible simply are not included.
  */
  
  function buildGraph() {
  	const graph = {};
  	// https://jsperf.com/object-keys-vs-for-in-with-closure/3
  	const models = Object.keys(conversions);
  
  	for (let len = models.length, i = 0; i < len; i++) {
  		graph[models[i]] = {
  			// http://jsperf.com/1-vs-infinity
  			// micro-opt, but this is simple.
  			distance: -1,
  			parent: null
  		};
  	}
  
  	return graph;
  }
  
  // https://en.wikipedia.org/wiki/Breadth-first_search
  function deriveBFS(fromModel) {
  	const graph = buildGraph();
  	const queue = [fromModel]; // Unshift -> queue -> pop
  
  	graph[fromModel].distance = 0;
  
  	while (queue.length) {
  		const current = queue.pop();
  		const adjacents = Object.keys(conversions[current]);
  
  		for (let len = adjacents.length, i = 0; i < len; i++) {
  			const adjacent = adjacents[i];
  			const node = graph[adjacent];
  
  			if (node.distance === -1) {
  				node.distance = graph[current].distance + 1;
  				node.parent = current;
  				queue.unshift(adjacent);
  			}
  		}
  	}
  
  	return graph;
  }
  
  function link(from, to) {
  	return function (args) {
  		return to(from(args));
  	};
  }
  
  function wrapConversion(toModel, graph) {
  	const path = [graph[toModel].parent, toModel];
  	let fn = conversions[graph[toModel].parent][toModel];
  
  	let cur = graph[toModel].parent;
  	while (graph[cur].parent) {
  		path.unshift(graph[cur].parent);
  		fn = link(conversions[graph[cur].parent][cur], fn);
  		cur = graph[cur].parent;
  	}
  
  	fn.conversion = path;
  	return fn;
  }
  
  module.exports = function (fromModel) {
  	const graph = deriveBFS(fromModel);
  	const conversion = {};
  
  	const models = Object.keys(graph);
  	for (let len = models.length, i = 0; i < len; i++) {
  		const toModel = models[i];
  		const node = graph[toModel];
  
  		if (node.parent === null) {
  			// No possible conversion, or this node is the source model.
  			continue;
  		}
  
  		conversion[toModel] = wrapConversion(toModel, graph);
  	}
  
  	return conversion;
  };
  
  
  
  /***/ }),
  
  /***/ 101:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  module.exports = (flag, argv = process.argv) => {
  	const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
  	const position = argv.indexOf(prefix + flag);
  	const terminatorPosition = argv.indexOf('--');
  	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
  };
  
  
  /***/ }),
  
  /***/ 102:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  const stringReplaceAll = (string, substring, replacer) => {
  	let index = string.indexOf(substring);
  	if (index === -1) {
  		return string;
  	}
  
  	const substringLength = substring.length;
  	let endIndex = 0;
  	let returnValue = '';
  	do {
  		returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
  		endIndex = index + substringLength;
  		index = string.indexOf(substring, endIndex);
  	} while (index !== -1);
  
  	returnValue += string.substr(endIndex);
  	return returnValue;
  };
  
  const stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => {
  	let endIndex = 0;
  	let returnValue = '';
  	do {
  		const gotCR = string[index - 1] === '\r';
  		returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? '\r\n' : '\n') + postfix;
  		endIndex = index + 1;
  		index = string.indexOf('\n', endIndex);
  	} while (index !== -1);
  
  	returnValue += string.substr(endIndex);
  	return returnValue;
  };
  
  module.exports = {
  	stringReplaceAll,
  	stringEncaseCRLFWithFirstIndex
  };
  
  
  /***/ }),
  
  /***/ 103:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  const TEMPLATE_REGEX = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
  const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
  const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
  const ESCAPE_REGEX = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi;
  
  const ESCAPES = new Map([
  	['n', '\n'],
  	['r', '\r'],
  	['t', '\t'],
  	['b', '\b'],
  	['f', '\f'],
  	['v', '\v'],
  	['0', '\0'],
  	['\\', '\\'],
  	['e', '\u001B'],
  	['a', '\u0007']
  ]);
  
  function unescape(c) {
  	const u = c[0] === 'u';
  	const bracket = c[1] === '{';
  
  	if ((u && !bracket && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
  		return String.fromCharCode(parseInt(c.slice(1), 16));
  	}
  
  	if (u && bracket) {
  		return String.fromCodePoint(parseInt(c.slice(2, -1), 16));
  	}
  
  	return ESCAPES.get(c) || c;
  }
  
  function parseArguments(name, arguments_) {
  	const results = [];
  	const chunks = arguments_.trim().split(/\s*,\s*/g);
  	let matches;
  
  	for (const chunk of chunks) {
  		const number = Number(chunk);
  		if (!Number.isNaN(number)) {
  			results.push(number);
  		} else if ((matches = chunk.match(STRING_REGEX))) {
  			results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, character) => escape ? unescape(escape) : character));
  		} else {
  			throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
  		}
  	}
  
  	return results;
  }
  
  function parseStyle(style) {
  	STYLE_REGEX.lastIndex = 0;
  
  	const results = [];
  	let matches;
  
  	while ((matches = STYLE_REGEX.exec(style)) !== null) {
  		const name = matches[1];
  
  		if (matches[2]) {
  			const args = parseArguments(name, matches[2]);
  			results.push([name].concat(args));
  		} else {
  			results.push([name]);
  		}
  	}
  
  	return results;
  }
  
  function buildStyle(chalk, styles) {
  	const enabled = {};
  
  	for (const layer of styles) {
  		for (const style of layer.styles) {
  			enabled[style[0]] = layer.inverse ? null : style.slice(1);
  		}
  	}
  
  	let current = chalk;
  	for (const [styleName, styles] of Object.entries(enabled)) {
  		if (!Array.isArray(styles)) {
  			continue;
  		}
  
  		if (!(styleName in current)) {
  			throw new Error(`Unknown Chalk style: ${styleName}`);
  		}
  
  		current = styles.length > 0 ? current[styleName](...styles) : current[styleName];
  	}
  
  	return current;
  }
  
  module.exports = (chalk, temporary) => {
  	const styles = [];
  	const chunks = [];
  	let chunk = [];
  
  	// eslint-disable-next-line max-params
  	temporary.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => {
  		if (escapeCharacter) {
  			chunk.push(unescape(escapeCharacter));
  		} else if (style) {
  			const string = chunk.join('');
  			chunk = [];
  			chunks.push(styles.length === 0 ? string : buildStyle(chalk, styles)(string));
  			styles.push({inverse, styles: parseStyle(style)});
  		} else if (close) {
  			if (styles.length === 0) {
  				throw new Error('Found extraneous } in Chalk template literal');
  			}
  
  			chunks.push(buildStyle(chalk, styles)(chunk.join('')));
  			chunk = [];
  			styles.pop();
  		} else {
  			chunk.push(character);
  		}
  	});
  
  	chunks.push(chunk.join(''));
  
  	if (styles.length > 0) {
  		const errMessage = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
  		throw new Error(errMessage);
  	}
  
  	return chunks.join('');
  };
  
  
  /***/ }),
  
  /***/ 104:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  const agent_1 = __importDefault(__webpack_require__(158));
  function createHttpsProxyAgent(opts) {
      return new agent_1.default(opts);
  }
  (function (createHttpsProxyAgent) {
      createHttpsProxyAgent.HttpsProxyAgent = agent_1.default;
      createHttpsProxyAgent.prototype = agent_1.default.prototype;
  })(createHttpsProxyAgent || (createHttpsProxyAgent = {}));
  module.exports = createHttpsProxyAgent;
  //# sourceMappingURL=index.js.map
  
  /***/ }),
  
  /***/ 105:
  /***/ (function(module, exports, __webpack_require__) {
  
  
  /**
   * This is the common logic for both the Node.js and web browser
   * implementations of `debug()`.
   */
  
  function setup(env) {
  	createDebug.debug = createDebug;
  	createDebug.default = createDebug;
  	createDebug.coerce = coerce;
  	createDebug.disable = disable;
  	createDebug.enable = enable;
  	createDebug.enabled = enabled;
  	createDebug.humanize = __webpack_require__(160);
  	createDebug.destroy = destroy;
  
  	Object.keys(env).forEach(key => {
  		createDebug[key] = env[key];
  	});
  
  	/**
  	* The currently active debug mode names, and names to skip.
  	*/
  
  	createDebug.names = [];
  	createDebug.skips = [];
  
  	/**
  	* Map of special "%n" handling functions, for the debug "format" argument.
  	*
  	* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
  	*/
  	createDebug.formatters = {};
  
  	/**
  	* Selects a color for a debug namespace
  	* @param {String} namespace The namespace string for the for the debug instance to be colored
  	* @return {Number|String} An ANSI color code for the given namespace
  	* @api private
  	*/
  	function selectColor(namespace) {
  		let hash = 0;
  
  		for (let i = 0; i < namespace.length; i++) {
  			hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
  			hash |= 0; // Convert to 32bit integer
  		}
  
  		return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
  	}
  	createDebug.selectColor = selectColor;
  
  	/**
  	* Create a debugger with the given `namespace`.
  	*
  	* @param {String} namespace
  	* @return {Function}
  	* @api public
  	*/
  	function createDebug(namespace) {
  		let prevTime;
  		let enableOverride = null;
  		let namespacesCache;
  		let enabledCache;
  
  		function debug(...args) {
  			// Disabled?
  			if (!debug.enabled) {
  				return;
  			}
  
  			const self = debug;
  
  			// Set `diff` timestamp
  			const curr = Number(new Date());
  			const ms = curr - (prevTime || curr);
  			self.diff = ms;
  			self.prev = prevTime;
  			self.curr = curr;
  			prevTime = curr;
  
  			args[0] = createDebug.coerce(args[0]);
  
  			if (typeof args[0] !== 'string') {
  				// Anything else let's inspect with %O
  				args.unshift('%O');
  			}
  
  			// Apply any `formatters` transformations
  			let index = 0;
  			args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
  				// If we encounter an escaped % then don't increase the array index
  				if (match === '%%') {
  					return '%';
  				}
  				index++;
  				const formatter = createDebug.formatters[format];
  				if (typeof formatter === 'function') {
  					const val = args[index];
  					match = formatter.call(self, val);
  
  					// Now we need to remove `args[index]` since it's inlined in the `format`
  					args.splice(index, 1);
  					index--;
  				}
  				return match;
  			});
  
  			// Apply env-specific formatting (colors, etc.)
  			createDebug.formatArgs.call(self, args);
  
  			const logFn = self.log || createDebug.log;
  			logFn.apply(self, args);
  		}
  
  		debug.namespace = namespace;
  		debug.useColors = createDebug.useColors();
  		debug.color = createDebug.selectColor(namespace);
  		debug.extend = extend;
  		debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
  
  		Object.defineProperty(debug, 'enabled', {
  			enumerable: true,
  			configurable: false,
  			get: () => {
  				if (enableOverride !== null) {
  					return enableOverride;
  				}
  				if (namespacesCache !== createDebug.namespaces) {
  					namespacesCache = createDebug.namespaces;
  					enabledCache = createDebug.enabled(namespace);
  				}
  
  				return enabledCache;
  			},
  			set: v => {
  				enableOverride = v;
  			}
  		});
  
  		// Env-specific initialization logic for debug instances
  		if (typeof createDebug.init === 'function') {
  			createDebug.init(debug);
  		}
  
  		return debug;
  	}
  
  	function extend(namespace, delimiter) {
  		const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
  		newDebug.log = this.log;
  		return newDebug;
  	}
  
  	/**
  	* Enables a debug mode by namespaces. This can include modes
  	* separated by a colon and wildcards.
  	*
  	* @param {String} namespaces
  	* @api public
  	*/
  	function enable(namespaces) {
  		createDebug.save(namespaces);
  		createDebug.namespaces = namespaces;
  
  		createDebug.names = [];
  		createDebug.skips = [];
  
  		let i;
  		const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
  		const len = split.length;
  
  		for (i = 0; i < len; i++) {
  			if (!split[i]) {
  				// ignore empty strings
  				continue;
  			}
  
  			namespaces = split[i].replace(/\*/g, '.*?');
  
  			if (namespaces[0] === '-') {
  				createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
  			} else {
  				createDebug.names.push(new RegExp('^' + namespaces + '$'));
  			}
  		}
  	}
  
  	/**
  	* Disable debug output.
  	*
  	* @return {String} namespaces
  	* @api public
  	*/
  	function disable() {
  		const namespaces = [
  			...createDebug.names.map(toNamespace),
  			...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
  		].join(',');
  		createDebug.enable('');
  		return namespaces;
  	}
  
  	/**
  	* Returns true if the given mode name is enabled, false otherwise.
  	*
  	* @param {String} name
  	* @return {Boolean}
  	* @api public
  	*/
  	function enabled(name) {
  		if (name[name.length - 1] === '*') {
  			return true;
  		}
  
  		let i;
  		let len;
  
  		for (i = 0, len = createDebug.skips.length; i < len; i++) {
  			if (createDebug.skips[i].test(name)) {
  				return false;
  			}
  		}
  
  		for (i = 0, len = createDebug.names.length; i < len; i++) {
  			if (createDebug.names[i].test(name)) {
  				return true;
  			}
  		}
  
  		return false;
  	}
  
  	/**
  	* Convert regexp to namespace
  	*
  	* @param {RegExp} regxep
  	* @return {String} namespace
  	* @api private
  	*/
  	function toNamespace(regexp) {
  		return regexp.toString()
  			.substring(2, regexp.toString().length - 2)
  			.replace(/\.\*\?$/, '*');
  	}
  
  	/**
  	* Coerce `val`.
  	*
  	* @param {Mixed} val
  	* @return {Mixed}
  	* @api private
  	*/
  	function coerce(val) {
  		if (val instanceof Error) {
  			return val.stack || val.message;
  		}
  		return val;
  	}
  
  	/**
  	* XXX DO NOT USE. This is a temporary stub function.
  	* XXX It WILL be removed in the next major release.
  	*/
  	function destroy() {
  		console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
  	}
  
  	createDebug.enable(createDebug.load());
  
  	return createDebug;
  }
  
  module.exports = setup;
  
  
  /***/ }),
  
  /***/ 11:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return getGlobalObject; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "j", function() { return uuid4; });
  /* unused harmony export parseUrl */
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return getEventDescription; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return consoleSandbox; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return addExceptionTypeValue; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return addExceptionMechanism; });
  /* unused harmony export getLocationHref */
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "h", function() { return parseSemver; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return parseRetryAfterHeader; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return addContextToFrame; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "i", function() { return stripUrlQueryAndFragment; });
  /* harmony import */ var _node__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(20);
  /* harmony import */ var _string__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(30);
  
  
  var fallbackGlobalObject = {};
  /**
   * Safely get global scope object
   *
   * @returns Global scope object
   */
  function getGlobalObject() {
      return (Object(_node__WEBPACK_IMPORTED_MODULE_0__[/* isNodeEnv */ "b"])()
          ? global
          : typeof window !== 'undefined' // eslint-disable-line no-restricted-globals
              ? window // eslint-disable-line no-restricted-globals
              : typeof self !== 'undefined'
                  ? self
                  : fallbackGlobalObject);
  }
  /**
   * UUID4 generator
   *
   * @returns string Generated UUID4.
   */
  function uuid4() {
      var global = getGlobalObject();
      var crypto = global.crypto || global.msCrypto;
      if (!(crypto === void 0) && crypto.getRandomValues) {
          // Use window.crypto API if available
          var arr = new Uint16Array(8);
          crypto.getRandomValues(arr);
          // set 4 in byte 7
          // eslint-disable-next-line no-bitwise
          arr[3] = (arr[3] & 0xfff) | 0x4000;
          // set 2 most significant bits of byte 9 to '10'
          // eslint-disable-next-line no-bitwise
          arr[4] = (arr[4] & 0x3fff) | 0x8000;
          var pad = function (num) {
              var v = num.toString(16);
              while (v.length < 4) {
                  v = "0" + v;
              }
              return v;
          };
          return (pad(arr[0]) + pad(arr[1]) + pad(arr[2]) + pad(arr[3]) + pad(arr[4]) + pad(arr[5]) + pad(arr[6]) + pad(arr[7]));
      }
      // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523
      return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
          // eslint-disable-next-line no-bitwise
          var r = (Math.random() * 16) | 0;
          // eslint-disable-next-line no-bitwise
          var v = c === 'x' ? r : (r & 0x3) | 0x8;
          return v.toString(16);
      });
  }
  /**
   * Parses string form of URL into an object
   * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B
   * // intentionally using regex and not <a/> href parsing trick because React Native and other
   * // environments where DOM might not be available
   * @returns parsed URL object
   */
  function parseUrl(url) {
      if (!url) {
          return {};
      }
      var match = url.match(/^(([^:/?#]+):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/);
      if (!match) {
          return {};
      }
      // coerce to undefined values to empty string so we don't get 'undefined'
      var query = match[6] || '';
      var fragment = match[8] || '';
      return {
          host: match[4],
          path: match[5],
          protocol: match[2],
          relative: match[5] + query + fragment,
      };
  }
  /**
   * Extracts either message or type+value from an event that can be used for user-facing logs
   * @returns event's description
   */
  function getEventDescription(event) {
      if (event.message) {
          return event.message;
      }
      if (event.exception && event.exception.values && event.exception.values[0]) {
          var exception = event.exception.values[0];
          if (exception.type && exception.value) {
              return exception.type + ": " + exception.value;
          }
          return exception.type || exception.value || event.event_id || '<unknown>';
      }
      return event.event_id || '<unknown>';
  }
  /** JSDoc */
  function consoleSandbox(callback) {
      var global = getGlobalObject();
      var levels = ['debug', 'info', 'warn', 'error', 'log', 'assert'];
      if (!('console' in global)) {
          return callback();
      }
      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
      var originalConsole = global.console;
      var wrappedLevels = {};
      // Restore all wrapped console methods
      levels.forEach(function (level) {
          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
          if (level in global.console && originalConsole[level].__sentry_original__) {
              wrappedLevels[level] = originalConsole[level];
              originalConsole[level] = originalConsole[level].__sentry_original__;
          }
      });
      // Perform callback manipulations
      var result = callback();
      // Revert restoration to wrapped state
      Object.keys(wrappedLevels).forEach(function (level) {
          originalConsole[level] = wrappedLevels[level];
      });
      return result;
  }
  /**
   * Adds exception values, type and value to an synthetic Exception.
   * @param event The event to modify.
   * @param value Value of the exception.
   * @param type Type of the exception.
   * @hidden
   */
  function addExceptionTypeValue(event, value, type) {
      event.exception = event.exception || {};
      event.exception.values = event.exception.values || [];
      event.exception.values[0] = event.exception.values[0] || {};
      event.exception.values[0].value = event.exception.values[0].value || value || '';
      event.exception.values[0].type = event.exception.values[0].type || type || 'Error';
  }
  /**
   * Adds exception mechanism to a given event.
   * @param event The event to modify.
   * @param mechanism Mechanism of the mechanism.
   * @hidden
   */
  function addExceptionMechanism(event, mechanism) {
      if (mechanism === void 0) { mechanism = {}; }
      // TODO: Use real type with `keyof Mechanism` thingy and maybe make it better?
      try {
          // @ts-ignore Type 'Mechanism | {}' is not assignable to type 'Mechanism | undefined'
          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
          event.exception.values[0].mechanism = event.exception.values[0].mechanism || {};
          Object.keys(mechanism).forEach(function (key) {
              // @ts-ignore Mechanism has no index signature
              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
              event.exception.values[0].mechanism[key] = mechanism[key];
          });
      }
      catch (_oO) {
          // no-empty
      }
  }
  /**
   * A safe form of location.href
   */
  function getLocationHref() {
      var global = getGlobalObject();
      try {
          return global.document.location.href;
      }
      catch (oO) {
          return '';
      }
  }
  // https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
  var SEMVER_REGEXP = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
  /**
   * Parses input into a SemVer interface
   * @param input string representation of a semver version
   */
  function parseSemver(input) {
      var match = input.match(SEMVER_REGEXP) || [];
      var major = parseInt(match[1], 10);
      var minor = parseInt(match[2], 10);
      var patch = parseInt(match[3], 10);
      return {
          buildmetadata: match[5],
          major: isNaN(major) ? undefined : major,
          minor: isNaN(minor) ? undefined : minor,
          patch: isNaN(patch) ? undefined : patch,
          prerelease: match[4],
      };
  }
  var defaultRetryAfter = 60 * 1000; // 60 seconds
  /**
   * Extracts Retry-After value from the request header or returns default value
   * @param now current unix timestamp
   * @param header string representation of 'Retry-After' header
   */
  function parseRetryAfterHeader(now, header) {
      if (!header) {
          return defaultRetryAfter;
      }
      var headerDelay = parseInt("" + header, 10);
      if (!isNaN(headerDelay)) {
          return headerDelay * 1000;
      }
      var headerDate = Date.parse("" + header);
      if (!isNaN(headerDate)) {
          return headerDate - now;
      }
      return defaultRetryAfter;
  }
  /**
   * This function adds context (pre/post/line) lines to the provided frame
   *
   * @param lines string[] containing all lines
   * @param frame StackFrame that will be mutated
   * @param linesOfContext number of context lines we want to add pre/post
   */
  function addContextToFrame(lines, frame, linesOfContext) {
      if (linesOfContext === void 0) { linesOfContext = 5; }
      var lineno = frame.lineno || 0;
      var maxLines = lines.length;
      var sourceLine = Math.max(Math.min(maxLines, lineno - 1), 0);
      frame.pre_context = lines
          .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)
          .map(function (line) { return Object(_string__WEBPACK_IMPORTED_MODULE_1__[/* snipLine */ "b"])(line, 0); });
      frame.context_line = Object(_string__WEBPACK_IMPORTED_MODULE_1__[/* snipLine */ "b"])(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);
      frame.post_context = lines
          .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)
          .map(function (line) { return Object(_string__WEBPACK_IMPORTED_MODULE_1__[/* snipLine */ "b"])(line, 0); });
  }
  /**
   * Strip the query string and fragment off of a given URL or path (if present)
   *
   * @param urlPath Full URL or path, including possible query string and/or fragment
   * @returns URL or path without query string or fragment
   */
  function stripUrlQueryAndFragment(urlPath) {
      // eslint-disable-next-line no-useless-escape
      return urlPath.split(/[\?#]/, 1)[0];
  }
  //# sourceMappingURL=misc.js.map
  
  /***/ }),
  
  /***/ 12:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  function Enum() {
      var values = [];
      for (var _i = 0; _i < arguments.length; _i++) {
          values[_i] = arguments[_i];
      }
      if (typeof values[0] === "string") {
          var result = {};
          for (var _a = 0, values_1 = values; _a < values_1.length; _a++) {
              var value = values_1[_a];
              result[value] = value;
          }
          return result;
      }
      else {
          return values[0];
      }
  }
  exports.Enum = Enum;
  (function (Enum) {
      function ofKeys(e) {
          var result = {};
          for (var _i = 0, _a = Object.keys(e); _i < _a.length; _i++) {
              var key = _a[_i];
              result[key] = key;
          }
          return result;
      }
      Enum.ofKeys = ofKeys;
      function keys(e) {
          return Object.keys(e);
      }
      Enum.keys = keys;
      function values(e) {
          var result = [];
          for (var _i = 0, _a = Object.keys(e); _i < _a.length; _i++) {
              var key = _a[_i];
              result.push(e[key]);
          }
          return result;
      }
      Enum.values = values;
      function isType(e, value) {
          return values(e).indexOf(value) !== -1;
      }
      Enum.isType = isType;
  })(Enum = exports.Enum || (exports.Enum = {}));
  //# sourceMappingURL=index.js.map
  
  /***/ }),
  
  /***/ 120:
  /***/ (function(module, exports, __webpack_require__) {
  
  var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/**
   * A doubly linked list-based Least Recently Used (LRU) cache. Will keep most
   * recently used items while discarding least recently used items when its limit
   * is reached.
   *
   * Licensed under MIT. Copyright (c) 2010 Rasmus Andersson <http://hunch.se/>
   * See README.md for details.
   *
   * Illustration of the design:
   *
   *       entry             entry             entry             entry
   *       ______            ______            ______            ______
   *      | head |.newer => |      |.newer => |      |.newer => | tail |
   *      |  A   |          |  B   |          |  C   |          |  D   |
   *      |______| <= older.|______| <= older.|______| <= older.|______|
   *
   *  removed  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  added
   */
  (function(g,f){
    const e =  true ? exports : undefined;
    f(e);
    if (true) { !(__WEBPACK_AMD_DEFINE_FACTORY__ = (e),
  				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
  				(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
  				__WEBPACK_AMD_DEFINE_FACTORY__),
  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); }
  })(this, function(exports) {
  
  const NEWER = Symbol('newer');
  const OLDER = Symbol('older');
  
  function LRUMap(limit, entries) {
    if (typeof limit !== 'number') {
      // called as (entries)
      entries = limit;
      limit = 0;
    }
  
    this.size = 0;
    this.limit = limit;
    this.oldest = this.newest = undefined;
    this._keymap = new Map();
  
    if (entries) {
      this.assign(entries);
      if (limit < 1) {
        this.limit = this.size;
      }
    }
  }
  
  exports.LRUMap = LRUMap;
  
  function Entry(key, value) {
    this.key = key;
    this.value = value;
    this[NEWER] = undefined;
    this[OLDER] = undefined;
  }
  
  
  LRUMap.prototype._markEntryAsUsed = function(entry) {
    if (entry === this.newest) {
      // Already the most recenlty used entry, so no need to update the list
      return;
    }
    // HEAD--------------TAIL
    //   <.older   .newer>
    //  <--- add direction --
    //   A  B  C  <D>  E
    if (entry[NEWER]) {
      if (entry === this.oldest) {
        this.oldest = entry[NEWER];
      }
      entry[NEWER][OLDER] = entry[OLDER]; // C <-- E.
    }
    if (entry[OLDER]) {
      entry[OLDER][NEWER] = entry[NEWER]; // C. --> E
    }
    entry[NEWER] = undefined; // D --x
    entry[OLDER] = this.newest; // D. --> E
    if (this.newest) {
      this.newest[NEWER] = entry; // E. <-- D
    }
    this.newest = entry;
  };
  
  LRUMap.prototype.assign = function(entries) {
    let entry, limit = this.limit || Number.MAX_VALUE;
    this._keymap.clear();
    let it = entries[Symbol.iterator]();
    for (let itv = it.next(); !itv.done; itv = it.next()) {
      let e = new Entry(itv.value[0], itv.value[1]);
      this._keymap.set(e.key, e);
      if (!entry) {
        this.oldest = e;
      } else {
        entry[NEWER] = e;
        e[OLDER] = entry;
      }
      entry = e;
      if (limit-- == 0) {
        throw new Error('overflow');
      }
    }
    this.newest = entry;
    this.size = this._keymap.size;
  };
  
  LRUMap.prototype.get = function(key) {
    // First, find our cache entry
    var entry = this._keymap.get(key);
    if (!entry) return; // Not cached. Sorry.
    // As <key> was found in the cache, register it as being requested recently
    this._markEntryAsUsed(entry);
    return entry.value;
  };
  
  LRUMap.prototype.set = function(key, value) {
    var entry = this._keymap.get(key);
  
    if (entry) {
      // update existing
      entry.value = value;
      this._markEntryAsUsed(entry);
      return this;
    }
  
    // new entry
    this._keymap.set(key, (entry = new Entry(key, value)));
  
    if (this.newest) {
      // link previous tail to the new tail (entry)
      this.newest[NEWER] = entry;
      entry[OLDER] = this.newest;
    } else {
      // we're first in -- yay
      this.oldest = entry;
    }
  
    // add new entry to the end of the linked list -- it's now the freshest entry.
    this.newest = entry;
    ++this.size;
    if (this.size > this.limit) {
      // we hit the limit -- remove the head
      this.shift();
    }
  
    return this;
  };
  
  LRUMap.prototype.shift = function() {
    // todo: handle special case when limit == 1
    var entry = this.oldest;
    if (entry) {
      if (this.oldest[NEWER]) {
        // advance the list
        this.oldest = this.oldest[NEWER];
        this.oldest[OLDER] = undefined;
      } else {
        // the cache is exhausted
        this.oldest = undefined;
        this.newest = undefined;
      }
      // Remove last strong reference to <entry> and remove links from the purged
      // entry being returned:
      entry[NEWER] = entry[OLDER] = undefined;
      this._keymap.delete(entry.key);
      --this.size;
      return [entry.key, entry.value];
    }
  };
  
  // ----------------------------------------------------------------------------
  // Following code is optional and can be removed without breaking the core
  // functionality.
  
  LRUMap.prototype.find = function(key) {
    let e = this._keymap.get(key);
    return e ? e.value : undefined;
  };
  
  LRUMap.prototype.has = function(key) {
    return this._keymap.has(key);
  };
  
  LRUMap.prototype['delete'] = function(key) {
    var entry = this._keymap.get(key);
    if (!entry) return;
    this._keymap.delete(entry.key);
    if (entry[NEWER] && entry[OLDER]) {
      // relink the older entry with the newer entry
      entry[OLDER][NEWER] = entry[NEWER];
      entry[NEWER][OLDER] = entry[OLDER];
    } else if (entry[NEWER]) {
      // remove the link to us
      entry[NEWER][OLDER] = undefined;
      // link the newer entry to head
      this.oldest = entry[NEWER];
    } else if (entry[OLDER]) {
      // remove the link to us
      entry[OLDER][NEWER] = undefined;
      // link the newer entry to head
      this.newest = entry[OLDER];
    } else {// if(entry[OLDER] === undefined && entry.newer === undefined) {
      this.oldest = this.newest = undefined;
    }
  
    this.size--;
    return entry.value;
  };
  
  LRUMap.prototype.clear = function() {
    // Not clearing links should be safe, as we don't expose live links to user
    this.oldest = this.newest = undefined;
    this.size = 0;
    this._keymap.clear();
  };
  
  
  function EntryIterator(oldestEntry) { this.entry = oldestEntry; }
  EntryIterator.prototype[Symbol.iterator] = function() { return this; }
  EntryIterator.prototype.next = function() {
    let ent = this.entry;
    if (ent) {
      this.entry = ent[NEWER];
      return { done: false, value: [ent.key, ent.value] };
    } else {
      return { done: true, value: undefined };
    }
  };
  
  
  function KeyIterator(oldestEntry) { this.entry = oldestEntry; }
  KeyIterator.prototype[Symbol.iterator] = function() { return this; }
  KeyIterator.prototype.next = function() {
    let ent = this.entry;
    if (ent) {
      this.entry = ent[NEWER];
      return { done: false, value: ent.key };
    } else {
      return { done: true, value: undefined };
    }
  };
  
  function ValueIterator(oldestEntry) { this.entry = oldestEntry; }
  ValueIterator.prototype[Symbol.iterator] = function() { return this; }
  ValueIterator.prototype.next = function() {
    let ent = this.entry;
    if (ent) {
      this.entry = ent[NEWER];
      return { done: false, value: ent.value };
    } else {
      return { done: true, value: undefined };
    }
  };
  
  
  LRUMap.prototype.keys = function() {
    return new KeyIterator(this.oldest);
  };
  
  LRUMap.prototype.values = function() {
    return new ValueIterator(this.oldest);
  };
  
  LRUMap.prototype.entries = function() {
    return this;
  };
  
  LRUMap.prototype[Symbol.iterator] = function() {
    return new EntryIterator(this.oldest);
  };
  
  LRUMap.prototype.forEach = function(fun, thisObj) {
    if (typeof thisObj !== 'object') {
      thisObj = this;
    }
    let entry = this.oldest;
    while (entry) {
      fun.call(thisObj, entry.value, entry.key, this);
      entry = entry[NEWER];
    }
  };
  
  /** Returns a JSON (array) representation */
  LRUMap.prototype.toJSON = function() {
    var s = new Array(this.size), i = 0, entry = this.oldest;
    while (entry) {
      s[i++] = { key: entry.key, value: entry.value };
      entry = entry[NEWER];
    }
    return s;
  };
  
  /** Returns a String representation */
  LRUMap.prototype.toString = function() {
    var s = '', entry = this.oldest;
    while (entry) {
      s += String(entry.key)+':'+entry.value;
      entry = entry[NEWER];
      if (entry) {
        s += ' < ';
      }
    }
    return s;
  };
  
  });
  
  
  /***/ }),
  
  /***/ 121:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return registerErrorInstrumentation; });
  /* harmony import */ var _sentry_utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(123);
  /* harmony import */ var _sentry_utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(8);
  /* harmony import */ var _spanstatus__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(10);
  /* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(5);
  
  
  
  /**
   * Configures global error listeners
   */
  function registerErrorInstrumentation() {
      Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_0__[/* addInstrumentationHandler */ "a"])({
          callback: errorCallback,
          type: 'error',
      });
      Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_0__[/* addInstrumentationHandler */ "a"])({
          callback: errorCallback,
          type: 'unhandledrejection',
      });
  }
  /**
   * If an error or unhandled promise occurs, we mark the active transaction as failed
   */
  function errorCallback() {
      var activeTransaction = Object(_utils__WEBPACK_IMPORTED_MODULE_3__[/* getActiveTransaction */ "b"])();
      if (activeTransaction) {
          _sentry_utils__WEBPACK_IMPORTED_MODULE_1__[/* logger */ "a"].log("[Tracing] Transaction: " + _spanstatus__WEBPACK_IMPORTED_MODULE_2__[/* SpanStatus */ "a"].InternalError + " -> Global error occured");
          activeTransaction.setStatus(_spanstatus__WEBPACK_IMPORTED_MODULE_2__[/* SpanStatus */ "a"].InternalError);
      }
  }
  //# sourceMappingURL=errors.js.map
  
  /***/ }),
  
  /***/ 122:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /*!
   * cookie
   * Copyright(c) 2012-2014 Roman Shtylman
   * Copyright(c) 2015 Douglas Christopher Wilson
   * MIT Licensed
   */
  
  
  
  /**
   * Module exports.
   * @public
   */
  
  exports.parse = parse;
  exports.serialize = serialize;
  
  /**
   * Module variables.
   * @private
   */
  
  var decode = decodeURIComponent;
  var encode = encodeURIComponent;
  var pairSplitRegExp = /; */;
  
  /**
   * RegExp to match field-content in RFC 7230 sec 3.2
   *
   * field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]
   * field-vchar   = VCHAR / obs-text
   * obs-text      = %x80-FF
   */
  
  var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
  
  /**
   * Parse a cookie header.
   *
   * Parse the given cookie header string into an object
   * The object has the various cookies as keys(names) => values
   *
   * @param {string} str
   * @param {object} [options]
   * @return {object}
   * @public
   */
  
  function parse(str, options) {
    if (typeof str !== 'string') {
      throw new TypeError('argument str must be a string');
    }
  
    var obj = {}
    var opt = options || {};
    var pairs = str.split(pairSplitRegExp);
    var dec = opt.decode || decode;
  
    for (var i = 0; i < pairs.length; i++) {
      var pair = pairs[i];
      var eq_idx = pair.indexOf('=');
  
      // skip things that don't look like key=value
      if (eq_idx < 0) {
        continue;
      }
  
      var key = pair.substr(0, eq_idx).trim()
      var val = pair.substr(++eq_idx, pair.length).trim();
  
      // quoted values
      if ('"' == val[0]) {
        val = val.slice(1, -1);
      }
  
      // only assign once
      if (undefined == obj[key]) {
        obj[key] = tryDecode(val, dec);
      }
    }
  
    return obj;
  }
  
  /**
   * Serialize data into a cookie header.
   *
   * Serialize the a name value pair into a cookie string suitable for
   * http headers. An optional options object specified cookie parameters.
   *
   * serialize('foo', 'bar', { httpOnly: true })
   *   => "foo=bar; httpOnly"
   *
   * @param {string} name
   * @param {string} val
   * @param {object} [options]
   * @return {string}
   * @public
   */
  
  function serialize(name, val, options) {
    var opt = options || {};
    var enc = opt.encode || encode;
  
    if (typeof enc !== 'function') {
      throw new TypeError('option encode is invalid');
    }
  
    if (!fieldContentRegExp.test(name)) {
      throw new TypeError('argument name is invalid');
    }
  
    var value = enc(val);
  
    if (value && !fieldContentRegExp.test(value)) {
      throw new TypeError('argument val is invalid');
    }
  
    var str = name + '=' + value;
  
    if (null != opt.maxAge) {
      var maxAge = opt.maxAge - 0;
  
      if (isNaN(maxAge) || !isFinite(maxAge)) {
        throw new TypeError('option maxAge is invalid')
      }
  
      str += '; Max-Age=' + Math.floor(maxAge);
    }
  
    if (opt.domain) {
      if (!fieldContentRegExp.test(opt.domain)) {
        throw new TypeError('option domain is invalid');
      }
  
      str += '; Domain=' + opt.domain;
    }
  
    if (opt.path) {
      if (!fieldContentRegExp.test(opt.path)) {
        throw new TypeError('option path is invalid');
      }
  
      str += '; Path=' + opt.path;
    }
  
    if (opt.expires) {
      if (typeof opt.expires.toUTCString !== 'function') {
        throw new TypeError('option expires is invalid');
      }
  
      str += '; Expires=' + opt.expires.toUTCString();
    }
  
    if (opt.httpOnly) {
      str += '; HttpOnly';
    }
  
    if (opt.secure) {
      str += '; Secure';
    }
  
    if (opt.sameSite) {
      var sameSite = typeof opt.sameSite === 'string'
        ? opt.sameSite.toLowerCase() : opt.sameSite;
  
      switch (sameSite) {
        case true:
          str += '; SameSite=Strict';
          break;
        case 'lax':
          str += '; SameSite=Lax';
          break;
        case 'strict':
          str += '; SameSite=Strict';
          break;
        case 'none':
          str += '; SameSite=None';
          break;
        default:
          throw new TypeError('option sameSite is invalid');
      }
    }
  
    return str;
  }
  
  /**
   * Try decoding a string using a decoding function.
   *
   * @param {string} str
   * @param {function} decode
   * @private
   */
  
  function tryDecode(str, decode) {
    try {
      return decode(str);
    } catch (e) {
      return str;
    }
  }
  
  
  /***/ }),
  
  /***/ 123:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  
  // EXPORTS
  __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ addInstrumentationHandler; });
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/node_modules/tslib/tslib.es6.js
  var tslib_es6 = __webpack_require__(16);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/is.js
  var is = __webpack_require__(9);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/logger.js
  var logger = __webpack_require__(8);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/misc.js
  var misc = __webpack_require__(11);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/object.js + 1 modules
  var object = __webpack_require__(14);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/stacktrace.js
  var stacktrace = __webpack_require__(56);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/supports.js
  
  
  /**
   * Tells whether current environment supports ErrorEvent objects
   * {@link supportsErrorEvent}.
   *
   * @returns Answer to the given question.
   */
  function supportsErrorEvent() {
      try {
          new ErrorEvent('');
          return true;
      }
      catch (e) {
          return false;
      }
  }
  /**
   * Tells whether current environment supports DOMError objects
   * {@link supportsDOMError}.
   *
   * @returns Answer to the given question.
   */
  function supportsDOMError() {
      try {
          // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':
          // 1 argument required, but only 0 present.
          // @ts-ignore It really needs 1 argument, not 0.
          new DOMError('');
          return true;
      }
      catch (e) {
          return false;
      }
  }
  /**
   * Tells whether current environment supports DOMException objects
   * {@link supportsDOMException}.
   *
   * @returns Answer to the given question.
   */
  function supportsDOMException() {
      try {
          new DOMException('');
          return true;
      }
      catch (e) {
          return false;
      }
  }
  /**
   * Tells whether current environment supports Fetch API
   * {@link supportsFetch}.
   *
   * @returns Answer to the given question.
   */
  function supportsFetch() {
      if (!('fetch' in Object(misc["f" /* getGlobalObject */])())) {
          return false;
      }
      try {
          new Headers();
          new Request('');
          new Response();
          return true;
      }
      catch (e) {
          return false;
      }
  }
  /**
   * isNativeFetch checks if the given function is a native implementation of fetch()
   */
  // eslint-disable-next-line @typescript-eslint/ban-types
  function isNativeFetch(func) {
      return func && /^function fetch\(\)\s+\{\s+\[native code\]\s+\}$/.test(func.toString());
  }
  /**
   * Tells whether current environment supports Fetch API natively
   * {@link supportsNativeFetch}.
   *
   * @returns true if `window.fetch` is natively implemented, false otherwise
   */
  function supportsNativeFetch() {
      if (!supportsFetch()) {
          return false;
      }
      var global = Object(misc["f" /* getGlobalObject */])();
      // Fast path to avoid DOM I/O
      // eslint-disable-next-line @typescript-eslint/unbound-method
      if (isNativeFetch(global.fetch)) {
          return true;
      }
      // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)
      // so create a "pure" iframe to see if that has native fetch
      var result = false;
      var doc = global.document;
      // eslint-disable-next-line deprecation/deprecation
      if (doc && typeof doc.createElement === "function") {
          try {
              var sandbox = doc.createElement('iframe');
              sandbox.hidden = true;
              doc.head.appendChild(sandbox);
              if (sandbox.contentWindow && sandbox.contentWindow.fetch) {
                  // eslint-disable-next-line @typescript-eslint/unbound-method
                  result = isNativeFetch(sandbox.contentWindow.fetch);
              }
              doc.head.removeChild(sandbox);
          }
          catch (err) {
              logger["a" /* logger */].warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);
          }
      }
      return result;
  }
  /**
   * Tells whether current environment supports ReportingObserver API
   * {@link supportsReportingObserver}.
   *
   * @returns Answer to the given question.
   */
  function supportsReportingObserver() {
      return 'ReportingObserver' in Object(misc["f" /* getGlobalObject */])();
  }
  /**
   * Tells whether current environment supports Referrer Policy API
   * {@link supportsReferrerPolicy}.
   *
   * @returns Answer to the given question.
   */
  function supportsReferrerPolicy() {
      // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default
      // https://caniuse.com/#feat=referrer-policy
      // It doesn't. And it throw exception instead of ignoring this parameter...
      // REF: https://github.com/getsentry/raven-js/issues/1233
      if (!supportsFetch()) {
          return false;
      }
      try {
          new Request('_', {
              referrerPolicy: 'origin',
          });
          return true;
      }
      catch (e) {
          return false;
      }
  }
  /**
   * Tells whether current environment supports History API
   * {@link supportsHistory}.
   *
   * @returns Answer to the given question.
   */
  function supportsHistory() {
      // NOTE: in Chrome App environment, touching history.pushState, *even inside
      //       a try/catch block*, will cause Chrome to output an error to console.error
      // borrowed from: https://github.com/angular/angular.js/pull/13945/files
      var global = Object(misc["f" /* getGlobalObject */])();
      /* eslint-disable @typescript-eslint/no-unsafe-member-access */
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      var chrome = global.chrome;
      var isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;
      /* eslint-enable @typescript-eslint/no-unsafe-member-access */
      var hasHistoryApi = 'history' in global && !!global.history.pushState && !!global.history.replaceState;
      return !isChromePackagedApp && hasHistoryApi;
  }
  //# sourceMappingURL=supports.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/instrument.js
  
  
  
  
  
  
  
  var instrument_global = Object(misc["f" /* getGlobalObject */])();
  /**
   * Instrument native APIs to call handlers that can be used to create breadcrumbs, APM spans etc.
   *  - Console API
   *  - Fetch API
   *  - XHR API
   *  - History API
   *  - DOM API (click/typing)
   *  - Error API
   *  - UnhandledRejection API
   */
  var handlers = {};
  var instrumented = {};
  /** Instruments given API */
  function instrument(type) {
      if (instrumented[type]) {
          return;
      }
      instrumented[type] = true;
      switch (type) {
          case 'console':
              instrumentConsole();
              break;
          case 'dom':
              instrumentDOM();
              break;
          case 'xhr':
              instrumentXHR();
              break;
          case 'fetch':
              instrumentFetch();
              break;
          case 'history':
              instrumentHistory();
              break;
          case 'error':
              instrumentError();
              break;
          case 'unhandledrejection':
              instrumentUnhandledRejection();
              break;
          default:
              logger["a" /* logger */].warn('unknown instrumentation type:', type);
      }
  }
  /**
   * Add handler that will be called when given type of instrumentation triggers.
   * Use at your own risk, this might break without changelog notice, only used internally.
   * @hidden
   */
  function addInstrumentationHandler(handler) {
      if (!handler || typeof handler.type !== 'string' || typeof handler.callback !== 'function') {
          return;
      }
      handlers[handler.type] = handlers[handler.type] || [];
      handlers[handler.type].push(handler.callback);
      instrument(handler.type);
  }
  /** JSDoc */
  function triggerHandlers(type, data) {
      var e_1, _a;
      if (!type || !handlers[type]) {
          return;
      }
      try {
          for (var _b = Object(tslib_es6["d" /* __values */])(handlers[type] || []), _c = _b.next(); !_c.done; _c = _b.next()) {
              var handler = _c.value;
              try {
                  handler(data);
              }
              catch (e) {
                  logger["a" /* logger */].error("Error while triggering instrumentation handler.\nType: " + type + "\nName: " + Object(stacktrace["a" /* getFunctionName */])(handler) + "\nError: " + e);
              }
          }
      }
      catch (e_1_1) { e_1 = { error: e_1_1 }; }
      finally {
          try {
              if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
          }
          finally { if (e_1) throw e_1.error; }
      }
  }
  /** JSDoc */
  function instrumentConsole() {
      if (!('console' in instrument_global)) {
          return;
      }
      ['debug', 'info', 'warn', 'error', 'log', 'assert'].forEach(function (level) {
          if (!(level in instrument_global.console)) {
              return;
          }
          Object(object["c" /* fill */])(instrument_global.console, level, function (originalConsoleLevel) {
              return function () {
                  var args = [];
                  for (var _i = 0; _i < arguments.length; _i++) {
                      args[_i] = arguments[_i];
                  }
                  triggerHandlers('console', { args: args, level: level });
                  // this fails for some browsers. :(
                  if (originalConsoleLevel) {
                      Function.prototype.apply.call(originalConsoleLevel, instrument_global.console, args);
                  }
              };
          });
      });
  }
  /** JSDoc */
  function instrumentFetch() {
      if (!supportsNativeFetch()) {
          return;
      }
      Object(object["c" /* fill */])(instrument_global, 'fetch', function (originalFetch) {
          return function () {
              var args = [];
              for (var _i = 0; _i < arguments.length; _i++) {
                  args[_i] = arguments[_i];
              }
              var handlerData = {
                  args: args,
                  fetchData: {
                      method: getFetchMethod(args),
                      url: getFetchUrl(args),
                  },
                  startTimestamp: Date.now(),
              };
              triggerHandlers('fetch', Object(tslib_es6["a" /* __assign */])({}, handlerData));
              // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
              return originalFetch.apply(instrument_global, args).then(function (response) {
                  triggerHandlers('fetch', Object(tslib_es6["a" /* __assign */])(Object(tslib_es6["a" /* __assign */])({}, handlerData), { endTimestamp: Date.now(), response: response }));
                  return response;
              }, function (error) {
                  triggerHandlers('fetch', Object(tslib_es6["a" /* __assign */])(Object(tslib_es6["a" /* __assign */])({}, handlerData), { endTimestamp: Date.now(), error: error }));
                  // 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.
                  throw error;
              });
          };
      });
  }
  /* eslint-disable @typescript-eslint/no-unsafe-member-access */
  /** Extract `method` from fetch call arguments */
  function getFetchMethod(fetchArgs) {
      if (fetchArgs === void 0) { fetchArgs = []; }
      if ('Request' in instrument_global && Object(is["d" /* isInstanceOf */])(fetchArgs[0], Request) && fetchArgs[0].method) {
          return String(fetchArgs[0].method).toUpperCase();
      }
      if (fetchArgs[1] && fetchArgs[1].method) {
          return String(fetchArgs[1].method).toUpperCase();
      }
      return 'GET';
  }
  /** Extract `url` from fetch call arguments */
  function getFetchUrl(fetchArgs) {
      if (fetchArgs === void 0) { fetchArgs = []; }
      if (typeof fetchArgs[0] === 'string') {
          return fetchArgs[0];
      }
      if ('Request' in instrument_global && Object(is["d" /* isInstanceOf */])(fetchArgs[0], Request)) {
          return fetchArgs[0].url;
      }
      return String(fetchArgs[0]);
  }
  /* eslint-enable @typescript-eslint/no-unsafe-member-access */
  /** JSDoc */
  function instrumentXHR() {
      if (!('XMLHttpRequest' in instrument_global)) {
          return;
      }
      // Poor man's implementation of ES6 `Map`, tracking and keeping in sync key and value separately.
      var requestKeys = [];
      var requestValues = [];
      var xhrproto = XMLHttpRequest.prototype;
      Object(object["c" /* fill */])(xhrproto, 'open', function (originalOpen) {
          return function () {
              var args = [];
              for (var _i = 0; _i < arguments.length; _i++) {
                  args[_i] = arguments[_i];
              }
              // eslint-disable-next-line @typescript-eslint/no-this-alias
              var xhr = this;
              var url = args[1];
              xhr.__sentry_xhr__ = {
                  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                  method: Object(is["h" /* isString */])(args[0]) ? args[0].toUpperCase() : args[0],
                  url: args[1],
              };
              // if Sentry key appears in URL, don't capture it as a request
              // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
              if (Object(is["h" /* isString */])(url) && xhr.__sentry_xhr__.method === 'POST' && url.match(/sentry_key/)) {
                  xhr.__sentry_own_request__ = true;
              }
              var onreadystatechangeHandler = function () {
                  if (xhr.readyState === 4) {
                      try {
                          // touching statusCode in some platforms throws
                          // an exception
                          if (xhr.__sentry_xhr__) {
                              xhr.__sentry_xhr__.status_code = xhr.status;
                          }
                      }
                      catch (e) {
                          /* do nothing */
                      }
                      try {
                          var requestPos = requestKeys.indexOf(xhr);
                          if (requestPos !== -1) {
                              // Make sure to pop both key and value to keep it in sync.
                              requestKeys.splice(requestPos);
                              var args_1 = requestValues.splice(requestPos)[0];
                              if (xhr.__sentry_xhr__ && args_1[0] !== undefined) {
                                  xhr.__sentry_xhr__.body = args_1[0];
                              }
                          }
                      }
                      catch (e) {
                          /* do nothing */
                      }
                      triggerHandlers('xhr', {
                          args: args,
                          endTimestamp: Date.now(),
                          startTimestamp: Date.now(),
                          xhr: xhr,
                      });
                  }
              };
              if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {
                  Object(object["c" /* fill */])(xhr, 'onreadystatechange', function (original) {
                      return function () {
                          var readyStateArgs = [];
                          for (var _i = 0; _i < arguments.length; _i++) {
                              readyStateArgs[_i] = arguments[_i];
                          }
                          onreadystatechangeHandler();
                          return original.apply(xhr, readyStateArgs);
                      };
                  });
              }
              else {
                  xhr.addEventListener('readystatechange', onreadystatechangeHandler);
              }
              return originalOpen.apply(xhr, args);
          };
      });
      Object(object["c" /* fill */])(xhrproto, 'send', function (originalSend) {
          return function () {
              var args = [];
              for (var _i = 0; _i < arguments.length; _i++) {
                  args[_i] = arguments[_i];
              }
              requestKeys.push(this);
              requestValues.push(args);
              triggerHandlers('xhr', {
                  args: args,
                  startTimestamp: Date.now(),
                  xhr: this,
              });
              return originalSend.apply(this, args);
          };
      });
  }
  var lastHref;
  /** JSDoc */
  function instrumentHistory() {
      if (!supportsHistory()) {
          return;
      }
      var oldOnPopState = instrument_global.onpopstate;
      instrument_global.onpopstate = function () {
          var args = [];
          for (var _i = 0; _i < arguments.length; _i++) {
              args[_i] = arguments[_i];
          }
          var to = instrument_global.location.href;
          // keep track of the current URL state, as we always receive only the updated state
          var from = lastHref;
          lastHref = to;
          triggerHandlers('history', {
              from: from,
              to: to,
          });
          if (oldOnPopState) {
              // Apparently this can throw in Firefox when incorrectly implemented plugin is installed.
              // https://github.com/getsentry/sentry-javascript/issues/3344
              // https://github.com/bugsnag/bugsnag-js/issues/469
              try {
                  return oldOnPopState.apply(this, args);
              }
              catch (_oO) {
                  // no-empty
              }
          }
      };
      /** @hidden */
      function historyReplacementFunction(originalHistoryFunction) {
          return function () {
              var args = [];
              for (var _i = 0; _i < arguments.length; _i++) {
                  args[_i] = arguments[_i];
              }
              var url = args.length > 2 ? args[2] : undefined;
              if (url) {
                  // coerce to string (this is what pushState does)
                  var from = lastHref;
                  var to = String(url);
                  // keep track of the current URL state, as we always receive only the updated state
                  lastHref = to;
                  triggerHandlers('history', {
                      from: from,
                      to: to,
                  });
              }
              return originalHistoryFunction.apply(this, args);
          };
      }
      Object(object["c" /* fill */])(instrument_global.history, 'pushState', historyReplacementFunction);
      Object(object["c" /* fill */])(instrument_global.history, 'replaceState', historyReplacementFunction);
  }
  var debounceDuration = 1000;
  var debounceTimerID;
  var lastCapturedEvent;
  /**
   * Decide whether the current event should finish the debounce of previously captured one.
   * @param previous previously captured event
   * @param current event to be captured
   */
  function shouldShortcircuitPreviousDebounce(previous, current) {
      // If there was no previous event, it should always be swapped for the new one.
      if (!previous) {
          return true;
      }
      // If both events have different type, then user definitely performed two separate actions. e.g. click + keypress.
      if (previous.type !== current.type) {
          return true;
      }
      try {
          // If both events have the same type, it's still possible that actions were performed on different targets.
          // e.g. 2 clicks on different buttons.
          if (previous.target !== current.target) {
              return true;
          }
      }
      catch (e) {
          // just accessing `target` property can throw an exception in some rare circumstances
          // see: https://github.com/getsentry/sentry-javascript/issues/838
      }
      // If both events have the same type _and_ same `target` (an element which triggered an event, _not necessarily_
      // to which an event listener was attached), we treat them as the same action, as we want to capture
      // only one breadcrumb. e.g. multiple clicks on the same button, or typing inside a user input box.
      return false;
  }
  /**
   * Decide whether an event should be captured.
   * @param event event to be captured
   */
  function shouldSkipDOMEvent(event) {
      // We are only interested in filtering `keypress` events for now.
      if (event.type !== 'keypress') {
          return false;
      }
      try {
          var target = event.target;
          if (!target || !target.tagName) {
              return true;
          }
          // Only consider keypress events on actual input elements. This will disregard keypresses targeting body
          // e.g.tabbing through elements, hotkeys, etc.
          if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {
              return false;
          }
      }
      catch (e) {
          // just accessing `target` property can throw an exception in some rare circumstances
          // see: https://github.com/getsentry/sentry-javascript/issues/838
      }
      return true;
  }
  /**
   * Wraps addEventListener to capture UI breadcrumbs
   * @param handler function that will be triggered
   * @param globalListener indicates whether event was captured by the global event listener
   * @returns wrapped breadcrumb events handler
   * @hidden
   */
  function makeDOMEventHandler(handler, globalListener) {
      if (globalListener === void 0) { globalListener = false; }
      return function (event) {
          // It's possible this handler might trigger multiple times for the same
          // event (e.g. event propagation through node ancestors).
          // Ignore if we've already captured that event.
          if (!event || lastCapturedEvent === event) {
              return;
          }
          // We always want to skip _some_ events.
          if (shouldSkipDOMEvent(event)) {
              return;
          }
          var name = event.type === 'keypress' ? 'input' : event.type;
          // If there is no debounce timer, it means that we can safely capture the new event and store it for future comparisons.
          if (debounceTimerID === undefined) {
              handler({
                  event: event,
                  name: name,
                  global: globalListener,
              });
              lastCapturedEvent = event;
          }
          // If there is a debounce awaiting, see if the new event is different enough to treat it as a unique one.
          // If that's the case, emit the previous event and store locally the newly-captured DOM event.
          else if (shouldShortcircuitPreviousDebounce(lastCapturedEvent, event)) {
              handler({
                  event: event,
                  name: name,
                  global: globalListener,
              });
              lastCapturedEvent = event;
          }
          // Start a new debounce timer that will prevent us from capturing multiple events that should be grouped together.
          clearTimeout(debounceTimerID);
          debounceTimerID = instrument_global.setTimeout(function () {
              debounceTimerID = undefined;
          }, debounceDuration);
      };
  }
  /** JSDoc */
  function instrumentDOM() {
      if (!('document' in instrument_global)) {
          return;
      }
      // Make it so that any click or keypress that is unhandled / bubbled up all the way to the document triggers our dom
      // handlers. (Normally we have only one, which captures a breadcrumb for each click or keypress.) Do this before
      // we instrument `addEventListener` so that we don't end up attaching this handler twice.
      var triggerDOMHandler = triggerHandlers.bind(null, 'dom');
      var globalDOMEventHandler = makeDOMEventHandler(triggerDOMHandler, true);
      instrument_global.document.addEventListener('click', globalDOMEventHandler, false);
      instrument_global.document.addEventListener('keypress', globalDOMEventHandler, false);
      // After hooking into click and keypress events bubbled up to `document`, we also hook into user-handled
      // clicks & keypresses, by adding an event listener of our own to any element to which they add a listener. That
      // way, whenever one of their handlers is triggered, ours will be, too. (This is needed because their handler
      // could potentially prevent the event from bubbling up to our global listeners. This way, our handler are still
      // guaranteed to fire at least once.)
      ['EventTarget', 'Node'].forEach(function (target) {
          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
          var proto = instrument_global[target] && instrument_global[target].prototype;
          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins
          if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {
              return;
          }
          Object(object["c" /* fill */])(proto, 'addEventListener', function (originalAddEventListener) {
              return function (type, listener, options) {
                  if (type === 'click' || type == 'keypress') {
                      try {
                          var el = this;
                          var handlers_1 = (el.__sentry_instrumentation_handlers__ = el.__sentry_instrumentation_handlers__ || {});
                          var handlerForType = (handlers_1[type] = handlers_1[type] || { refCount: 0 });
                          if (!handlerForType.handler) {
                              var handler = makeDOMEventHandler(triggerDOMHandler);
                              handlerForType.handler = handler;
                              originalAddEventListener.call(this, type, handler, options);
                          }
                          handlerForType.refCount += 1;
                      }
                      catch (e) {
                          // Accessing dom properties is always fragile.
                          // Also allows us to skip `addEventListenrs` calls with no proper `this` context.
                      }
                  }
                  return originalAddEventListener.call(this, type, listener, options);
              };
          });
          Object(object["c" /* fill */])(proto, 'removeEventListener', function (originalRemoveEventListener) {
              return function (type, listener, options) {
                  if (type === 'click' || type == 'keypress') {
                      try {
                          var el = this;
                          var handlers_2 = el.__sentry_instrumentation_handlers__ || {};
                          var handlerForType = handlers_2[type];
                          if (handlerForType) {
                              handlerForType.refCount -= 1;
                              // If there are no longer any custom handlers of the current type on this element, we can remove ours, too.
                              if (handlerForType.refCount <= 0) {
                                  originalRemoveEventListener.call(this, type, handlerForType.handler, options);
                                  handlerForType.handler = undefined;
                                  delete handlers_2[type]; // eslint-disable-line @typescript-eslint/no-dynamic-delete
                              }
                              // If there are no longer any custom handlers of any type on this element, cleanup everything.
                              if (Object.keys(handlers_2).length === 0) {
                                  delete el.__sentry_instrumentation_handlers__;
                              }
                          }
                      }
                      catch (e) {
                          // Accessing dom properties is always fragile.
                          // Also allows us to skip `addEventListenrs` calls with no proper `this` context.
                      }
                  }
                  return originalRemoveEventListener.call(this, type, listener, options);
              };
          });
      });
  }
  var _oldOnErrorHandler = null;
  /** JSDoc */
  function instrumentError() {
      _oldOnErrorHandler = instrument_global.onerror;
      instrument_global.onerror = function (msg, url, line, column, error) {
          triggerHandlers('error', {
              column: column,
              error: error,
              line: line,
              msg: msg,
              url: url,
          });
          if (_oldOnErrorHandler) {
              // eslint-disable-next-line prefer-rest-params
              return _oldOnErrorHandler.apply(this, arguments);
          }
          return false;
      };
  }
  var _oldOnUnhandledRejectionHandler = null;
  /** JSDoc */
  function instrumentUnhandledRejection() {
      _oldOnUnhandledRejectionHandler = instrument_global.onunhandledrejection;
      instrument_global.onunhandledrejection = function (e) {
          triggerHandlers('unhandledrejection', e);
          if (_oldOnUnhandledRejectionHandler) {
              // eslint-disable-next-line prefer-rest-params
              return _oldOnUnhandledRejectionHandler.apply(this, arguments);
          }
          return true;
      };
  }
  //# sourceMappingURL=instrument.js.map
  
  /***/ }),
  
  /***/ 129:
  /***/ (function(module, exports) {
  
  module.exports = require("net");
  
  /***/ }),
  
  /***/ 130:
  /***/ (function(module, exports) {
  
  module.exports = require("tls");
  
  /***/ }),
  
  /***/ 14:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  
  // EXPORTS
  __webpack_require__.d(__webpack_exports__, "c", function() { return /* binding */ fill; });
  __webpack_require__.d(__webpack_exports__, "f", function() { return /* binding */ urlEncode; });
  __webpack_require__.d(__webpack_exports__, "e", function() { return /* binding */ normalizeToSize; });
  __webpack_require__.d(__webpack_exports__, "d", function() { return /* binding */ normalize; });
  __webpack_require__.d(__webpack_exports__, "b", function() { return /* binding */ extractExceptionKeysForMessage; });
  __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ dropUndefinedKeys; });
  
  // UNUSED EXPORTS: walk
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/node_modules/tslib/tslib.es6.js
  var tslib_es6 = __webpack_require__(16);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/browser.js
  var browser = __webpack_require__(81);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/is.js
  var is = __webpack_require__(9);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/memo.js
  /* eslint-disable @typescript-eslint/no-unsafe-member-access */
  /* eslint-disable @typescript-eslint/no-explicit-any */
  /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
  /**
   * Memo class used for decycle json objects. Uses WeakSet if available otherwise array.
   */
  var Memo = /** @class */ (function () {
      function Memo() {
          this._hasWeakSet = typeof WeakSet === 'function';
          this._inner = this._hasWeakSet ? new WeakSet() : [];
      }
      /**
       * Sets obj to remember.
       * @param obj Object to remember
       */
      Memo.prototype.memoize = function (obj) {
          if (this._hasWeakSet) {
              if (this._inner.has(obj)) {
                  return true;
              }
              this._inner.add(obj);
              return false;
          }
          // eslint-disable-next-line @typescript-eslint/prefer-for-of
          for (var i = 0; i < this._inner.length; i++) {
              var value = this._inner[i];
              if (value === obj) {
                  return true;
              }
          }
          this._inner.push(obj);
          return false;
      };
      /**
       * Removes object from internal storage.
       * @param obj Object to forget
       */
      Memo.prototype.unmemoize = function (obj) {
          if (this._hasWeakSet) {
              this._inner.delete(obj);
          }
          else {
              for (var i = 0; i < this._inner.length; i++) {
                  if (this._inner[i] === obj) {
                      this._inner.splice(i, 1);
                      break;
                  }
              }
          }
      };
      return Memo;
  }());
  
  //# sourceMappingURL=memo.js.map
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/stacktrace.js
  var stacktrace = __webpack_require__(56);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/string.js
  var string = __webpack_require__(30);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/object.js
  
  
  
  
  
  
  /**
   * Replace a method in an object with a wrapped version of itself.
   *
   * @param source An object that contains a method to be wrapped.
   * @param name The name of the method to be wrapped.
   * @param replacementFactory A higher-order function that takes the original version of the given method and returns a
   * wrapped version. Note: The function returned by `replacementFactory` needs to be a non-arrow function, in order to
   * preserve the correct value of `this`, and the original method must be called using `origMethod.call(this, <other
   * args>)` or `origMethod.apply(this, [<other args>])` (rather than being called directly), again to preserve `this`.
   * @returns void
   */
  function fill(source, name, replacementFactory) {
      if (!(name in source)) {
          return;
      }
      var original = source[name];
      var wrapped = replacementFactory(original);
      // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work
      // otherwise it'll throw "TypeError: Object.defineProperties called on non-object"
      if (typeof wrapped === 'function') {
          try {
              wrapped.prototype = wrapped.prototype || {};
              Object.defineProperties(wrapped, {
                  __sentry_original__: {
                      enumerable: false,
                      value: original,
                  },
              });
          }
          catch (_Oo) {
              // This can throw if multiple fill happens on a global object like XMLHttpRequest
              // Fixes https://github.com/getsentry/sentry-javascript/issues/2043
          }
      }
      source[name] = wrapped;
  }
  /**
   * Encodes given object into url-friendly format
   *
   * @param object An object that contains serializable values
   * @returns string Encoded
   */
  function urlEncode(object) {
      return Object.keys(object)
          .map(function (key) { return encodeURIComponent(key) + "=" + encodeURIComponent(object[key]); })
          .join('&');
  }
  /**
   * Transforms any object into an object literal with all its attributes
   * attached to it.
   *
   * @param value Initial source that we have to transform in order for it to be usable by the serializer
   */
  function getWalkSource(value) {
      if (Object(is["b" /* isError */])(value)) {
          var error = value;
          var err = {
              message: error.message,
              name: error.name,
              stack: error.stack,
          };
          for (var i in error) {
              if (Object.prototype.hasOwnProperty.call(error, i)) {
                  err[i] = error[i];
              }
          }
          return err;
      }
      if (Object(is["c" /* isEvent */])(value)) {
          var event_1 = value;
          var source = {};
          // Accessing event attributes can throw (see https://github.com/getsentry/sentry-javascript/issues/768 and
          // https://github.com/getsentry/sentry-javascript/issues/838), but accessing `type` hasn't been wrapped in a
          // try-catch in at least two years and no one's complained, so that's likely not an issue anymore
          source.type = event_1.type;
          try {
              source.target = Object(is["a" /* isElement */])(event_1.target)
                  ? Object(browser["a" /* htmlTreeAsString */])(event_1.target)
                  : Object.prototype.toString.call(event_1.target);
          }
          catch (_oO) {
              source.target = '<unknown>';
          }
          try {
              source.currentTarget = Object(is["a" /* isElement */])(event_1.currentTarget)
                  ? Object(browser["a" /* htmlTreeAsString */])(event_1.currentTarget)
                  : Object.prototype.toString.call(event_1.currentTarget);
          }
          catch (_oO) {
              source.currentTarget = '<unknown>';
          }
          if (typeof CustomEvent !== 'undefined' && Object(is["d" /* isInstanceOf */])(value, CustomEvent)) {
              source.detail = event_1.detail;
          }
          for (var attr in event_1) {
              if (Object.prototype.hasOwnProperty.call(event_1, attr)) {
                  source[attr] = event_1[attr];
              }
          }
          return source;
      }
      return value;
  }
  /** Calculates bytes size of input string */
  function utf8Length(value) {
      // eslint-disable-next-line no-bitwise
      return ~-encodeURI(value).split(/%..|./).length;
  }
  /** Calculates bytes size of input object */
  function jsonSize(value) {
      return utf8Length(JSON.stringify(value));
  }
  /** JSDoc */
  function normalizeToSize(object, 
  // Default Node.js REPL depth
  depth, 
  // 100kB, as 200kB is max payload size, so half sounds reasonable
  maxSize) {
      if (depth === void 0) { depth = 3; }
      if (maxSize === void 0) { maxSize = 100 * 1024; }
      var serialized = normalize(object, depth);
      if (jsonSize(serialized) > maxSize) {
          return normalizeToSize(object, depth - 1, maxSize);
      }
      return serialized;
  }
  /**
   * Transform any non-primitive, BigInt, or Symbol-type value into a string. Acts as a no-op on strings, numbers,
   * booleans, null, and undefined.
   *
   * @param value The value to stringify
   * @returns For non-primitive, BigInt, and Symbol-type values, a string denoting the value's type, type and value, or
   *  type and `description` property, respectively. For non-BigInt, non-Symbol primitives, returns the original value,
   *  unchanged.
   */
  function serializeValue(value) {
      var type = Object.prototype.toString.call(value);
      // Node.js REPL notation
      if (typeof value === 'string') {
          return value;
      }
      if (type === '[object Object]') {
          return '[Object]';
      }
      if (type === '[object Array]') {
          return '[Array]';
      }
      var normalized = normalizeValue(value);
      return Object(is["f" /* isPrimitive */])(normalized) ? normalized : type;
  }
  /**
   * normalizeValue()
   *
   * Takes unserializable input and make it serializable friendly
   *
   * - translates undefined/NaN values to "[undefined]"/"[NaN]" respectively,
   * - serializes Error objects
   * - filter global objects
   */
  function normalizeValue(value, key) {
      if (key === 'domain' && value && typeof value === 'object' && value._events) {
          return '[Domain]';
      }
      if (key === 'domainEmitter') {
          return '[DomainEmitter]';
      }
      if (typeof global !== 'undefined' && value === global) {
          return '[Global]';
      }
      // It's safe to use `window` and `document` here in this manner, as we are asserting using `typeof` first
      // which won't throw if they are not present.
      // eslint-disable-next-line no-restricted-globals
      if (typeof window !== 'undefined' && value === window) {
          return '[Window]';
      }
      // eslint-disable-next-line no-restricted-globals
      if (typeof document !== 'undefined' && value === document) {
          return '[Document]';
      }
      // React's SyntheticEvent thingy
      if (Object(is["i" /* isSyntheticEvent */])(value)) {
          return '[SyntheticEvent]';
      }
      if (typeof value === 'number' && value !== value) {
          return '[NaN]';
      }
      if (value === void 0) {
          return '[undefined]';
      }
      if (typeof value === 'function') {
          return "[Function: " + Object(stacktrace["a" /* getFunctionName */])(value) + "]";
      }
      // symbols and bigints are considered primitives by TS, but aren't natively JSON-serilaizable
      if (typeof value === 'symbol') {
          return "[" + String(value) + "]";
      }
      if (typeof value === 'bigint') {
          return "[BigInt: " + String(value) + "]";
      }
      return value;
  }
  /**
   * Walks an object to perform a normalization on it
   *
   * @param key of object that's walked in current iteration
   * @param value object to be walked
   * @param depth Optional number indicating how deep should walking be performed
   * @param memo Optional Memo class handling decycling
   */
  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
  function walk(key, value, depth, memo) {
      if (depth === void 0) { depth = +Infinity; }
      if (memo === void 0) { memo = new Memo(); }
      // If we reach the maximum depth, serialize whatever has left
      if (depth === 0) {
          return serializeValue(value);
      }
      /* eslint-disable @typescript-eslint/no-unsafe-member-access */
      // If value implements `toJSON` method, call it and return early
      if (value !== null && value !== undefined && typeof value.toJSON === 'function') {
          return value.toJSON();
      }
      /* eslint-enable @typescript-eslint/no-unsafe-member-access */
      // If normalized value is a primitive, there are no branches left to walk, so we can just bail out, as theres no point in going down that branch any further
      var normalized = normalizeValue(value, key);
      if (Object(is["f" /* isPrimitive */])(normalized)) {
          return normalized;
      }
      // Create source that we will use for next itterations, either objectified error object (Error type with extracted keys:value pairs) or the input itself
      var source = getWalkSource(value);
      // Create an accumulator that will act as a parent for all future itterations of that branch
      var acc = Array.isArray(value) ? [] : {};
      // If we already walked that branch, bail out, as it's circular reference
      if (memo.memoize(value)) {
          return '[Circular ~]';
      }
      // Walk all keys of the source
      for (var innerKey in source) {
          // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.
          if (!Object.prototype.hasOwnProperty.call(source, innerKey)) {
              continue;
          }
          // Recursively walk through all the child nodes
          acc[innerKey] = walk(innerKey, source[innerKey], depth - 1, memo);
      }
      // Once walked through all the branches, remove the parent from memo storage
      memo.unmemoize(value);
      // Return accumulated values
      return acc;
  }
  /**
   * normalize()
   *
   * - Creates a copy to prevent original input mutation
   * - Skip non-enumerablers
   * - Calls `toJSON` if implemented
   * - Removes circular references
   * - Translates non-serializeable values (undefined/NaN/Functions) to serializable format
   * - Translates known global objects/Classes to a string representations
   * - Takes care of Error objects serialization
   * - Optionally limit depth of final output
   */
  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
  function normalize(input, depth) {
      try {
          return JSON.parse(JSON.stringify(input, function (key, value) { return walk(key, value, depth); }));
      }
      catch (_oO) {
          return '**non-serializable**';
      }
  }
  /**
   * Given any captured exception, extract its keys and create a sorted
   * and truncated list that will be used inside the event message.
   * eg. `Non-error exception captured with keys: foo, bar, baz`
   */
  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
  function extractExceptionKeysForMessage(exception, maxLength) {
      if (maxLength === void 0) { maxLength = 40; }
      var keys = Object.keys(getWalkSource(exception));
      keys.sort();
      if (!keys.length) {
          return '[object has no keys]';
      }
      if (keys[0].length >= maxLength) {
          return Object(string["c" /* truncate */])(keys[0], maxLength);
      }
      for (var includedKeys = keys.length; includedKeys > 0; includedKeys--) {
          var serialized = keys.slice(0, includedKeys).join(', ');
          if (serialized.length > maxLength) {
              continue;
          }
          if (includedKeys === keys.length) {
              return serialized;
          }
          return Object(string["c" /* truncate */])(serialized, maxLength);
      }
      return '';
  }
  /**
   * Given any object, return the new object with removed keys that value was `undefined`.
   * Works recursively on objects and arrays.
   */
  function dropUndefinedKeys(val) {
      var e_1, _a;
      if (Object(is["e" /* isPlainObject */])(val)) {
          var obj = val;
          var rv = {};
          try {
              for (var _b = Object(tslib_es6["d" /* __values */])(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) {
                  var key = _c.value;
                  if (typeof obj[key] !== 'undefined') {
                      rv[key] = dropUndefinedKeys(obj[key]);
                  }
              }
          }
          catch (e_1_1) { e_1 = { error: e_1_1 }; }
          finally {
              try {
                  if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
              }
              finally { if (e_1) throw e_1.error; }
          }
          return rv;
      }
      if (Array.isArray(val)) {
          return val.map(dropUndefinedKeys);
      }
      return val;
  }
  //# sourceMappingURL=object.js.map
  
  /***/ }),
  
  /***/ 15:
  /***/ (function(module, exports) {
  
  module.exports = require("fs");
  
  /***/ }),
  
  /***/ 157:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.on_user_recognized = exports.on_error = void 0; // https://docs.sentry.io/error-reporting/quickstart/?platform=node
  // https://httptoolkit.tech/blog/netlify-function-error-reporting-with-sentry/
  
  const Sentry = __webpack_require__(195);
  
  const channel_1 = __webpack_require__(54); /////////////////////////////////////////////////
  
  
  Sentry.init({
    // https://getsentry.github.io/sentry-javascript/interfaces/node.nodeoptions.html
    dsn: 'https://a86696dcd573448a8fcc3bd7151349b4@sentry.io/1772719',
    debug: "production" === 'development',
    //release TODO
    environment: channel_1.CHANNEL,
    attachStacktrace: true,
    //shutdownTimeout TODO needed ?
    integrations: default_integrations => {
      // please Sentry! I don't want your crappy integrations!
      //console.log(default_integrations)
      // https://docs.sentry.io/platforms/node/#removing-an-integration
      return [];
    }
  });
  Sentry.configureScope(scope => {
    scope.setExtra('channel', channel_1.CHANNEL);
    scope.setExtra('node', process.versions.node); // TODO node version etc. ?
  });
  
  async function on_error(err) {
    console.log('💣 Reporting to Sentry...', err.message); // TODO inspect the SEC?
  
    Sentry.captureException(err);
    await Sentry.flush();
  }
  
  exports.on_error = on_error; // https://docs.sentry.io/enriching-error-data/context/?platform=node#capturing-the-user
  // TODO shared across invocations??
  
  function on_user_recognized(user) {
    Sentry.configureScope(scope => {
      scope.setUser(user);
    });
  }
  
  exports.on_user_recognized = on_user_recognized; // TODO self-triage?
  // https://docs.sentry.io/enriching-error-data/context/?platform=node#setting-the-level
  // TODO breadcrumb
  
  /***/ }),
  
  /***/ 158:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const net_1 = __importDefault(__webpack_require__(129));
  const tls_1 = __importDefault(__webpack_require__(130));
  const url_1 = __importDefault(__webpack_require__(23));
  const assert_1 = __importDefault(__webpack_require__(75));
  const debug_1 = __importDefault(__webpack_require__(33));
  const agent_base_1 = __webpack_require__(162);
  const parse_proxy_response_1 = __importDefault(__webpack_require__(164));
  const debug = debug_1.default('https-proxy-agent:agent');
  /**
   * The `HttpsProxyAgent` implements an HTTP Agent subclass that connects to
   * the specified "HTTP(s) proxy server" in order to proxy HTTPS requests.
   *
   * Outgoing HTTP requests are first tunneled through the proxy server using the
   * `CONNECT` HTTP request method to establish a connection to the proxy server,
   * and then the proxy server connects to the destination target and issues the
   * HTTP request from the proxy server.
   *
   * `https:` requests have their socket connection upgraded to TLS once
   * the connection to the proxy server has been established.
   *
   * @api public
   */
  class HttpsProxyAgent extends agent_base_1.Agent {
      constructor(_opts) {
          let opts;
          if (typeof _opts === 'string') {
              opts = url_1.default.parse(_opts);
          }
          else {
              opts = _opts;
          }
          if (!opts) {
              throw new Error('an HTTP(S) proxy server `host` and `port` must be specified!');
          }
          debug('creating new HttpsProxyAgent instance: %o', opts);
          super(opts);
          const proxy = Object.assign({}, opts);
          // If `true`, then connect to the proxy server over TLS.
          // Defaults to `false`.
          this.secureProxy = opts.secureProxy || isHTTPS(proxy.protocol);
          // Prefer `hostname` over `host`, and set the `port` if needed.
          proxy.host = proxy.hostname || proxy.host;
          if (typeof proxy.port === 'string') {
              proxy.port = parseInt(proxy.port, 10);
          }
          if (!proxy.port && proxy.host) {
              proxy.port = this.secureProxy ? 443 : 80;
          }
          // ALPN is supported by Node.js >= v5.
          // attempt to negotiate http/1.1 for proxy servers that support http/2
          if (this.secureProxy && !('ALPNProtocols' in proxy)) {
              proxy.ALPNProtocols = ['http 1.1'];
          }
          if (proxy.host && proxy.path) {
              // If both a `host` and `path` are specified then it's most likely
              // the result of a `url.parse()` call... we need to remove the
              // `path` portion so that `net.connect()` doesn't attempt to open
              // that as a Unix socket file.
              delete proxy.path;
              delete proxy.pathname;
          }
          this.proxy = proxy;
      }
      /**
       * Called when the node-core HTTP client library is creating a
       * new HTTP request.
       *
       * @api protected
       */
      callback(req, opts) {
          return __awaiter(this, void 0, void 0, function* () {
              const { proxy, secureProxy } = this;
              // Create a socket connection to the proxy server.
              let socket;
              if (secureProxy) {
                  debug('Creating `tls.Socket`: %o', proxy);
                  socket = tls_1.default.connect(proxy);
              }
              else {
                  debug('Creating `net.Socket`: %o', proxy);
                  socket = net_1.default.connect(proxy);
              }
              const headers = Object.assign({}, proxy.headers);
              const hostname = `${opts.host}:${opts.port}`;
              let payload = `CONNECT ${hostname} HTTP/1.1\r\n`;
              // Inject the `Proxy-Authorization` header if necessary.
              if (proxy.auth) {
                  headers['Proxy-Authorization'] = `Basic ${Buffer.from(proxy.auth).toString('base64')}`;
              }
              // The `Host` header should only include the port
              // number when it is not the default port.
              let { host, port, secureEndpoint } = opts;
              if (!isDefaultPort(port, secureEndpoint)) {
                  host += `:${port}`;
              }
              headers.Host = host;
              headers.Connection = 'close';
              for (const name of Object.keys(headers)) {
                  payload += `${name}: ${headers[name]}\r\n`;
              }
              const proxyResponsePromise = parse_proxy_response_1.default(socket);
              socket.write(`${payload}\r\n`);
              const { statusCode, buffered } = yield proxyResponsePromise;
              if (statusCode === 200) {
                  req.once('socket', resume);
                  if (opts.secureEndpoint) {
                      const servername = opts.servername || opts.host;
                      if (!servername) {
                          throw new Error('Could not determine "servername"');
                      }
                      // The proxy is connecting to a TLS server, so upgrade
                      // this socket connection to a TLS connection.
                      debug('Upgrading socket connection to TLS');
                      return tls_1.default.connect(Object.assign(Object.assign({}, omit(opts, 'host', 'hostname', 'path', 'port')), { socket,
                          servername }));
                  }
                  return socket;
              }
              // Some other status code that's not 200... need to re-play the HTTP
              // header "data" events onto the socket once the HTTP machinery is
              // attached so that the node core `http` can parse and handle the
              // error status code.
              // Close the original socket, and a new "fake" socket is returned
              // instead, so that the proxy doesn't get the HTTP request
              // written to it (which may contain `Authorization` headers or other
              // sensitive data).
              //
              // See: https://hackerone.com/reports/541502
              socket.destroy();
              const fakeSocket = new net_1.default.Socket();
              fakeSocket.readable = true;
              // Need to wait for the "socket" event to re-play the "data" events.
              req.once('socket', (s) => {
                  debug('replaying proxy buffer for failed request');
                  assert_1.default(s.listenerCount('data') > 0);
                  // Replay the "buffered" Buffer onto the fake `socket`, since at
                  // this point the HTTP module machinery has been hooked up for
                  // the user.
                  s.push(buffered);
                  s.push(null);
              });
              return fakeSocket;
          });
      }
  }
  exports.default = HttpsProxyAgent;
  function resume(socket) {
      socket.resume();
  }
  function isDefaultPort(port, secure) {
      return Boolean((!secure && port === 80) || (secure && port === 443));
  }
  function isHTTPS(protocol) {
      return typeof protocol === 'string' ? /^https:?$/i.test(protocol) : false;
  }
  function omit(obj, ...keys) {
      const ret = {};
      let key;
      for (key in obj) {
          if (!keys.includes(key)) {
              ret[key] = obj[key];
          }
      }
      return ret;
  }
  //# sourceMappingURL=agent.js.map
  
  /***/ }),
  
  /***/ 159:
  /***/ (function(module, exports, __webpack_require__) {
  
  /* eslint-env browser */
  
  /**
   * This is the web browser implementation of `debug()`.
   */
  
  exports.formatArgs = formatArgs;
  exports.save = save;
  exports.load = load;
  exports.useColors = useColors;
  exports.storage = localstorage();
  exports.destroy = (() => {
  	let warned = false;
  
  	return () => {
  		if (!warned) {
  			warned = true;
  			console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
  		}
  	};
  })();
  
  /**
   * Colors.
   */
  
  exports.colors = [
  	'#0000CC',
  	'#0000FF',
  	'#0033CC',
  	'#0033FF',
  	'#0066CC',
  	'#0066FF',
  	'#0099CC',
  	'#0099FF',
  	'#00CC00',
  	'#00CC33',
  	'#00CC66',
  	'#00CC99',
  	'#00CCCC',
  	'#00CCFF',
  	'#3300CC',
  	'#3300FF',
  	'#3333CC',
  	'#3333FF',
  	'#3366CC',
  	'#3366FF',
  	'#3399CC',
  	'#3399FF',
  	'#33CC00',
  	'#33CC33',
  	'#33CC66',
  	'#33CC99',
  	'#33CCCC',
  	'#33CCFF',
  	'#6600CC',
  	'#6600FF',
  	'#6633CC',
  	'#6633FF',
  	'#66CC00',
  	'#66CC33',
  	'#9900CC',
  	'#9900FF',
  	'#9933CC',
  	'#9933FF',
  	'#99CC00',
  	'#99CC33',
  	'#CC0000',
  	'#CC0033',
  	'#CC0066',
  	'#CC0099',
  	'#CC00CC',
  	'#CC00FF',
  	'#CC3300',
  	'#CC3333',
  	'#CC3366',
  	'#CC3399',
  	'#CC33CC',
  	'#CC33FF',
  	'#CC6600',
  	'#CC6633',
  	'#CC9900',
  	'#CC9933',
  	'#CCCC00',
  	'#CCCC33',
  	'#FF0000',
  	'#FF0033',
  	'#FF0066',
  	'#FF0099',
  	'#FF00CC',
  	'#FF00FF',
  	'#FF3300',
  	'#FF3333',
  	'#FF3366',
  	'#FF3399',
  	'#FF33CC',
  	'#FF33FF',
  	'#FF6600',
  	'#FF6633',
  	'#FF9900',
  	'#FF9933',
  	'#FFCC00',
  	'#FFCC33'
  ];
  
  /**
   * Currently only WebKit-based Web Inspectors, Firefox >= v31,
   * and the Firebug extension (any Firefox version) are known
   * to support "%c" CSS customizations.
   *
   * TODO: add a `localStorage` variable to explicitly enable/disable colors
   */
  
  // eslint-disable-next-line complexity
  function useColors() {
  	// NB: In an Electron preload script, document will be defined but not fully
  	// initialized. Since we know we're in Chrome, we'll just detect this case
  	// explicitly
  	if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
  		return true;
  	}
  
  	// Internet Explorer and Edge do not support colors.
  	if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
  		return false;
  	}
  
  	// Is webkit? http://stackoverflow.com/a/16459606/376773
  	// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
  	return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
  		// Is firebug? http://stackoverflow.com/a/398120/376773
  		(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
  		// Is firefox >= v31?
  		// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
  		(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
  		// Double check webkit in userAgent just in case we are in a worker
  		(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
  }
  
  /**
   * Colorize log arguments if enabled.
   *
   * @api public
   */
  
  function formatArgs(args) {
  	args[0] = (this.useColors ? '%c' : '') +
  		this.namespace +
  		(this.useColors ? ' %c' : ' ') +
  		args[0] +
  		(this.useColors ? '%c ' : ' ') +
  		'+' + module.exports.humanize(this.diff);
  
  	if (!this.useColors) {
  		return;
  	}
  
  	const c = 'color: ' + this.color;
  	args.splice(1, 0, c, 'color: inherit');
  
  	// The final "%c" is somewhat tricky, because there could be other
  	// arguments passed either before or after the %c, so we need to
  	// figure out the correct index to insert the CSS into
  	let index = 0;
  	let lastC = 0;
  	args[0].replace(/%[a-zA-Z%]/g, match => {
  		if (match === '%%') {
  			return;
  		}
  		index++;
  		if (match === '%c') {
  			// We only are interested in the *last* %c
  			// (the user may have provided their own)
  			lastC = index;
  		}
  	});
  
  	args.splice(lastC, 0, c);
  }
  
  /**
   * Invokes `console.debug()` when available.
   * No-op when `console.debug` is not a "function".
   * If `console.debug` is not available, falls back
   * to `console.log`.
   *
   * @api public
   */
  exports.log = console.debug || console.log || (() => {});
  
  /**
   * Save `namespaces`.
   *
   * @param {String} namespaces
   * @api private
   */
  function save(namespaces) {
  	try {
  		if (namespaces) {
  			exports.storage.setItem('debug', namespaces);
  		} else {
  			exports.storage.removeItem('debug');
  		}
  	} catch (error) {
  		// Swallow
  		// XXX (@Qix-) should we be logging these?
  	}
  }
  
  /**
   * Load `namespaces`.
   *
   * @return {String} returns the previously persisted debug modes
   * @api private
   */
  function load() {
  	let r;
  	try {
  		r = exports.storage.getItem('debug');
  	} catch (error) {
  		// Swallow
  		// XXX (@Qix-) should we be logging these?
  	}
  
  	// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
  	if (!r && typeof process !== 'undefined' && 'env' in process) {
  		r = process.env.DEBUG;
  	}
  
  	return r;
  }
  
  /**
   * Localstorage attempts to return the localstorage.
   *
   * This is necessary because safari throws
   * when a user disables cookies/localstorage
   * and you attempt to access it.
   *
   * @return {LocalStorage}
   * @api private
   */
  
  function localstorage() {
  	try {
  		// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
  		// The Browser also has localStorage in the global context.
  		return localStorage;
  	} catch (error) {
  		// Swallow
  		// XXX (@Qix-) should we be logging these?
  	}
  }
  
  module.exports = __webpack_require__(105)(exports);
  
  const {formatters} = module.exports;
  
  /**
   * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
   */
  
  formatters.j = function (v) {
  	try {
  		return JSON.stringify(v);
  	} catch (error) {
  		return '[UnexpectedJSONParseError]: ' + error.message;
  	}
  };
  
  
  /***/ }),
  
  /***/ 16:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return __extends; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return __assign; });
  /* unused harmony export __rest */
  /* unused harmony export __decorate */
  /* unused harmony export __param */
  /* unused harmony export __metadata */
  /* unused harmony export __awaiter */
  /* unused harmony export __generator */
  /* unused harmony export __createBinding */
  /* unused harmony export __exportStar */
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return __values; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return __read; });
  /* unused harmony export __spread */
  /* unused harmony export __spreadArrays */
  /* unused harmony export __await */
  /* unused harmony export __asyncGenerator */
  /* unused harmony export __asyncDelegator */
  /* unused harmony export __asyncValues */
  /* unused harmony export __makeTemplateObject */
  /* unused harmony export __importStar */
  /* unused harmony export __importDefault */
  /* unused harmony export __classPrivateFieldGet */
  /* unused harmony export __classPrivateFieldSet */
  /*! *****************************************************************************
  Copyright (c) Microsoft Corporation.
  
  Permission to use, copy, modify, and/or distribute this software for any
  purpose with or without fee is hereby granted.
  
  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  PERFORMANCE OF THIS SOFTWARE.
  ***************************************************************************** */
  /* global Reflect, Promise */
  
  var extendStatics = function(d, b) {
      extendStatics = Object.setPrototypeOf ||
          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
          function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
      return extendStatics(d, b);
  };
  
  function __extends(d, b) {
      extendStatics(d, b);
      function __() { this.constructor = d; }
      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  }
  
  var __assign = function() {
      __assign = Object.assign || function __assign(t) {
          for (var s, i = 1, n = arguments.length; i < n; i++) {
              s = arguments[i];
              for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
          }
          return t;
      }
      return __assign.apply(this, arguments);
  }
  
  function __rest(s, e) {
      var t = {};
      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
          t[p] = s[p];
      if (s != null && typeof Object.getOwnPropertySymbols === "function")
          for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
              if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                  t[p[i]] = s[p[i]];
          }
      return t;
  }
  
  function __decorate(decorators, target, key, desc) {
      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
      return c > 3 && r && Object.defineProperty(target, key, r), r;
  }
  
  function __param(paramIndex, decorator) {
      return function (target, key) { decorator(target, key, paramIndex); }
  }
  
  function __metadata(metadataKey, metadataValue) {
      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
  }
  
  function __awaiter(thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  }
  
  function __generator(thisArg, body) {
      var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
      function verb(n) { return function (v) { return step([n, v]); }; }
      function step(op) {
          if (f) throw new TypeError("Generator is already executing.");
          while (_) try {
              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
              if (y = 0, t) op = [op[0] & 2, t.value];
              switch (op[0]) {
                  case 0: case 1: t = op; break;
                  case 4: _.label++; return { value: op[1], done: false };
                  case 5: _.label++; y = op[1]; op = [0]; continue;
                  case 7: op = _.ops.pop(); _.trys.pop(); continue;
                  default:
                      if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                      if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                      if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                      if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                      if (t[2]) _.ops.pop();
                      _.trys.pop(); continue;
              }
              op = body.call(thisArg, _);
          } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
          if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
      }
  }
  
  function __createBinding(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }
  
  function __exportStar(m, exports) {
      for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];
  }
  
  function __values(o) {
      var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
      if (m) return m.call(o);
      if (o && typeof o.length === "number") return {
          next: function () {
              if (o && i >= o.length) o = void 0;
              return { value: o && o[i++], done: !o };
          }
      };
      throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
  }
  
  function __read(o, n) {
      var m = typeof Symbol === "function" && o[Symbol.iterator];
      if (!m) return o;
      var i = m.call(o), r, ar = [], e;
      try {
          while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
      }
      catch (error) { e = { error: error }; }
      finally {
          try {
              if (r && !r.done && (m = i["return"])) m.call(i);
          }
          finally { if (e) throw e.error; }
      }
      return ar;
  }
  
  function __spread() {
      for (var ar = [], i = 0; i < arguments.length; i++)
          ar = ar.concat(__read(arguments[i]));
      return ar;
  }
  
  function __spreadArrays() {
      for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
      for (var r = Array(s), k = 0, i = 0; i < il; i++)
          for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
              r[k] = a[j];
      return r;
  };
  
  function __await(v) {
      return this instanceof __await ? (this.v = v, this) : new __await(v);
  }
  
  function __asyncGenerator(thisArg, _arguments, generator) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var g = generator.apply(thisArg, _arguments || []), i, q = [];
      return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
      function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
      function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
      function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
      function fulfill(value) { resume("next", value); }
      function reject(value) { resume("throw", value); }
      function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
  }
  
  function __asyncDelegator(o) {
      var i, p;
      return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
      function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
  }
  
  function __asyncValues(o) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var m = o[Symbol.asyncIterator], i;
      return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
      function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
      function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
  }
  
  function __makeTemplateObject(cooked, raw) {
      if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
      return cooked;
  };
  
  function __importStar(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result.default = mod;
      return result;
  }
  
  function __importDefault(mod) {
      return (mod && mod.__esModule) ? mod : { default: mod };
  }
  
  function __classPrivateFieldGet(receiver, privateMap) {
      if (!privateMap.has(receiver)) {
          throw new TypeError("attempted to get private field on non-instance");
      }
      return privateMap.get(receiver);
  }
  
  function __classPrivateFieldSet(receiver, privateMap, value) {
      if (!privateMap.has(receiver)) {
          throw new TypeError("attempted to set private field on non-instance");
      }
      privateMap.set(receiver, value);
      return value;
  }
  
  
  /***/ }),
  
  /***/ 160:
  /***/ (function(module, exports) {
  
  /**
   * Helpers.
   */
  
  var s = 1000;
  var m = s * 60;
  var h = m * 60;
  var d = h * 24;
  var w = d * 7;
  var y = d * 365.25;
  
  /**
   * Parse or format the given `val`.
   *
   * Options:
   *
   *  - `long` verbose formatting [false]
   *
   * @param {String|Number} val
   * @param {Object} [options]
   * @throws {Error} throw an error if val is not a non-empty string or a number
   * @return {String|Number}
   * @api public
   */
  
  module.exports = function(val, options) {
    options = options || {};
    var type = typeof val;
    if (type === 'string' && val.length > 0) {
      return parse(val);
    } else if (type === 'number' && isFinite(val)) {
      return options.long ? fmtLong(val) : fmtShort(val);
    }
    throw new Error(
      'val is not a non-empty string or a valid number. val=' +
        JSON.stringify(val)
    );
  };
  
  /**
   * Parse the given `str` and return milliseconds.
   *
   * @param {String} str
   * @return {Number}
   * @api private
   */
  
  function parse(str) {
    str = String(str);
    if (str.length > 100) {
      return;
    }
    var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
      str
    );
    if (!match) {
      return;
    }
    var n = parseFloat(match[1]);
    var type = (match[2] || 'ms').toLowerCase();
    switch (type) {
      case 'years':
      case 'year':
      case 'yrs':
      case 'yr':
      case 'y':
        return n * y;
      case 'weeks':
      case 'week':
      case 'w':
        return n * w;
      case 'days':
      case 'day':
      case 'd':
        return n * d;
      case 'hours':
      case 'hour':
      case 'hrs':
      case 'hr':
      case 'h':
        return n * h;
      case 'minutes':
      case 'minute':
      case 'mins':
      case 'min':
      case 'm':
        return n * m;
      case 'seconds':
      case 'second':
      case 'secs':
      case 'sec':
      case 's':
        return n * s;
      case 'milliseconds':
      case 'millisecond':
      case 'msecs':
      case 'msec':
      case 'ms':
        return n;
      default:
        return undefined;
    }
  }
  
  /**
   * Short format for `ms`.
   *
   * @param {Number} ms
   * @return {String}
   * @api private
   */
  
  function fmtShort(ms) {
    var msAbs = Math.abs(ms);
    if (msAbs >= d) {
      return Math.round(ms / d) + 'd';
    }
    if (msAbs >= h) {
      return Math.round(ms / h) + 'h';
    }
    if (msAbs >= m) {
      return Math.round(ms / m) + 'm';
    }
    if (msAbs >= s) {
      return Math.round(ms / s) + 's';
    }
    return ms + 'ms';
  }
  
  /**
   * Long format for `ms`.
   *
   * @param {Number} ms
   * @return {String}
   * @api private
   */
  
  function fmtLong(ms) {
    var msAbs = Math.abs(ms);
    if (msAbs >= d) {
      return plural(ms, msAbs, d, 'day');
    }
    if (msAbs >= h) {
      return plural(ms, msAbs, h, 'hour');
    }
    if (msAbs >= m) {
      return plural(ms, msAbs, m, 'minute');
    }
    if (msAbs >= s) {
      return plural(ms, msAbs, s, 'second');
    }
    return ms + ' ms';
  }
  
  /**
   * Pluralization helper.
   */
  
  function plural(ms, msAbs, n, name) {
    var isPlural = msAbs >= n * 1.5;
    return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
  }
  
  
  /***/ }),
  
  /***/ 161:
  /***/ (function(module, exports, __webpack_require__) {
  
  /**
   * Module dependencies.
   */
  
  const tty = __webpack_require__(73);
  const util = __webpack_require__(19);
  
  /**
   * This is the Node.js implementation of `debug()`.
   */
  
  exports.init = init;
  exports.log = log;
  exports.formatArgs = formatArgs;
  exports.save = save;
  exports.load = load;
  exports.useColors = useColors;
  exports.destroy = util.deprecate(
  	() => {},
  	'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'
  );
  
  /**
   * Colors.
   */
  
  exports.colors = [6, 2, 3, 4, 5, 1];
  
  try {
  	// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
  	// eslint-disable-next-line import/no-extraneous-dependencies
  	const supportsColor = __webpack_require__(72);
  
  	if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
  		exports.colors = [
  			20,
  			21,
  			26,
  			27,
  			32,
  			33,
  			38,
  			39,
  			40,
  			41,
  			42,
  			43,
  			44,
  			45,
  			56,
  			57,
  			62,
  			63,
  			68,
  			69,
  			74,
  			75,
  			76,
  			77,
  			78,
  			79,
  			80,
  			81,
  			92,
  			93,
  			98,
  			99,
  			112,
  			113,
  			128,
  			129,
  			134,
  			135,
  			148,
  			149,
  			160,
  			161,
  			162,
  			163,
  			164,
  			165,
  			166,
  			167,
  			168,
  			169,
  			170,
  			171,
  			172,
  			173,
  			178,
  			179,
  			184,
  			185,
  			196,
  			197,
  			198,
  			199,
  			200,
  			201,
  			202,
  			203,
  			204,
  			205,
  			206,
  			207,
  			208,
  			209,
  			214,
  			215,
  			220,
  			221
  		];
  	}
  } catch (error) {
  	// Swallow - we only care if `supports-color` is available; it doesn't have to be.
  }
  
  /**
   * Build up the default `inspectOpts` object from the environment variables.
   *
   *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
   */
  
  exports.inspectOpts = Object.keys(process.env).filter(key => {
  	return /^debug_/i.test(key);
  }).reduce((obj, key) => {
  	// Camel-case
  	const prop = key
  		.substring(6)
  		.toLowerCase()
  		.replace(/_([a-z])/g, (_, k) => {
  			return k.toUpperCase();
  		});
  
  	// Coerce string value into JS value
  	let val = process.env[key];
  	if (/^(yes|on|true|enabled)$/i.test(val)) {
  		val = true;
  	} else if (/^(no|off|false|disabled)$/i.test(val)) {
  		val = false;
  	} else if (val === 'null') {
  		val = null;
  	} else {
  		val = Number(val);
  	}
  
  	obj[prop] = val;
  	return obj;
  }, {});
  
  /**
   * Is stdout a TTY? Colored output is enabled when `true`.
   */
  
  function useColors() {
  	return 'colors' in exports.inspectOpts ?
  		Boolean(exports.inspectOpts.colors) :
  		tty.isatty(process.stderr.fd);
  }
  
  /**
   * Adds ANSI color escape codes if enabled.
   *
   * @api public
   */
  
  function formatArgs(args) {
  	const {namespace: name, useColors} = this;
  
  	if (useColors) {
  		const c = this.color;
  		const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
  		const prefix = `  ${colorCode};1m${name} \u001B[0m`;
  
  		args[0] = prefix + args[0].split('\n').join('\n' + prefix);
  		args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
  	} else {
  		args[0] = getDate() + name + ' ' + args[0];
  	}
  }
  
  function getDate() {
  	if (exports.inspectOpts.hideDate) {
  		return '';
  	}
  	return new Date().toISOString() + ' ';
  }
  
  /**
   * Invokes `util.format()` with the specified arguments and writes to stderr.
   */
  
  function log(...args) {
  	return process.stderr.write(util.format(...args) + '\n');
  }
  
  /**
   * Save `namespaces`.
   *
   * @param {String} namespaces
   * @api private
   */
  function save(namespaces) {
  	if (namespaces) {
  		process.env.DEBUG = namespaces;
  	} else {
  		// If you set a process.env field to null or undefined, it gets cast to the
  		// string 'null' or 'undefined'. Just delete instead.
  		delete process.env.DEBUG;
  	}
  }
  
  /**
   * Load `namespaces`.
   *
   * @return {String} returns the previously persisted debug modes
   * @api private
   */
  
  function load() {
  	return process.env.DEBUG;
  }
  
  /**
   * Init logic for `debug` instances.
   *
   * Create a new `inspectOpts` object in case `useColors` is set
   * differently for a particular `debug` instance.
   */
  
  function init(debug) {
  	debug.inspectOpts = {};
  
  	const keys = Object.keys(exports.inspectOpts);
  	for (let i = 0; i < keys.length; i++) {
  		debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
  	}
  }
  
  module.exports = __webpack_require__(105)(exports);
  
  const {formatters} = module.exports;
  
  /**
   * Map %o to `util.inspect()`, all on a single line.
   */
  
  formatters.o = function (v) {
  	this.inspectOpts.colors = this.useColors;
  	return util.inspect(v, this.inspectOpts)
  		.split('\n')
  		.map(str => str.trim())
  		.join(' ');
  };
  
  /**
   * Map %O to `util.inspect()`, allowing multiple lines if needed.
   */
  
  formatters.O = function (v) {
  	this.inspectOpts.colors = this.useColors;
  	return util.inspect(v, this.inspectOpts);
  };
  
  
  /***/ }),
  
  /***/ 162:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  const events_1 = __webpack_require__(25);
  const debug_1 = __importDefault(__webpack_require__(33));
  const promisify_1 = __importDefault(__webpack_require__(163));
  const debug = debug_1.default('agent-base');
  function isAgent(v) {
      return Boolean(v) && typeof v.addRequest === 'function';
  }
  function isSecureEndpoint() {
      const { stack } = new Error();
      if (typeof stack !== 'string')
          return false;
      return stack.split('\n').some(l => l.indexOf('(https.js:') !== -1 || l.indexOf('node:https:') !== -1);
  }
  function createAgent(callback, opts) {
      return new createAgent.Agent(callback, opts);
  }
  (function (createAgent) {
      /**
       * Base `http.Agent` implementation.
       * No pooling/keep-alive is implemented by default.
       *
       * @param {Function} callback
       * @api public
       */
      class Agent extends events_1.EventEmitter {
          constructor(callback, _opts) {
              super();
              let opts = _opts;
              if (typeof callback === 'function') {
                  this.callback = callback;
              }
              else if (callback) {
                  opts = callback;
              }
              // Timeout for the socket to be returned from the callback
              this.timeout = null;
              if (opts && typeof opts.timeout === 'number') {
                  this.timeout = opts.timeout;
              }
              // These aren't actually used by `agent-base`, but are required
              // for the TypeScript definition files in `@types/node` :/
              this.maxFreeSockets = 1;
              this.maxSockets = 1;
              this.maxTotalSockets = Infinity;
              this.sockets = {};
              this.freeSockets = {};
              this.requests = {};
              this.options = {};
          }
          get defaultPort() {
              if (typeof this.explicitDefaultPort === 'number') {
                  return this.explicitDefaultPort;
              }
              return isSecureEndpoint() ? 443 : 80;
          }
          set defaultPort(v) {
              this.explicitDefaultPort = v;
          }
          get protocol() {
              if (typeof this.explicitProtocol === 'string') {
                  return this.explicitProtocol;
              }
              return isSecureEndpoint() ? 'https:' : 'http:';
          }
          set protocol(v) {
              this.explicitProtocol = v;
          }
          callback(req, opts, fn) {
              throw new Error('"agent-base" has no default implementation, you must subclass and override `callback()`');
          }
          /**
           * Called by node-core's "_http_client.js" module when creating
           * a new HTTP request with this Agent instance.
           *
           * @api public
           */
          addRequest(req, _opts) {
              const opts = Object.assign({}, _opts);
              if (typeof opts.secureEndpoint !== 'boolean') {
                  opts.secureEndpoint = isSecureEndpoint();
              }
              if (opts.host == null) {
                  opts.host = 'localhost';
              }
              if (opts.port == null) {
                  opts.port = opts.secureEndpoint ? 443 : 80;
              }
              if (opts.protocol == null) {
                  opts.protocol = opts.secureEndpoint ? 'https:' : 'http:';
              }
              if (opts.host && opts.path) {
                  // If both a `host` and `path` are specified then it's most
                  // likely the result of a `url.parse()` call... we need to
                  // remove the `path` portion so that `net.connect()` doesn't
                  // attempt to open that as a unix socket file.
                  delete opts.path;
              }
              delete opts.agent;
              delete opts.hostname;
              delete opts._defaultAgent;
              delete opts.defaultPort;
              delete opts.createConnection;
              // Hint to use "Connection: close"
              // XXX: non-documented `http` module API :(
              req._last = true;
              req.shouldKeepAlive = false;
              let timedOut = false;
              let timeoutId = null;
              const timeoutMs = opts.timeout || this.timeout;
              const onerror = (err) => {
                  if (req._hadError)
                      return;
                  req.emit('error', err);
                  // For Safety. Some additional errors might fire later on
                  // and we need to make sure we don't double-fire the error event.
                  req._hadError = true;
              };
              const ontimeout = () => {
                  timeoutId = null;
                  timedOut = true;
                  const err = new Error(`A "socket" was not created for HTTP request before ${timeoutMs}ms`);
                  err.code = 'ETIMEOUT';
                  onerror(err);
              };
              const callbackError = (err) => {
                  if (timedOut)
                      return;
                  if (timeoutId !== null) {
                      clearTimeout(timeoutId);
                      timeoutId = null;
                  }
                  onerror(err);
              };
              const onsocket = (socket) => {
                  if (timedOut)
                      return;
                  if (timeoutId != null) {
                      clearTimeout(timeoutId);
                      timeoutId = null;
                  }
                  if (isAgent(socket)) {
                      // `socket` is actually an `http.Agent` instance, so
                      // relinquish responsibility for this `req` to the Agent
                      // from here on
                      debug('Callback returned another Agent instance %o', socket.constructor.name);
                      socket.addRequest(req, opts);
                      return;
                  }
                  if (socket) {
                      socket.once('free', () => {
                          this.freeSocket(socket, opts);
                      });
                      req.onSocket(socket);
                      return;
                  }
                  const err = new Error(`no Duplex stream was returned to agent-base for \`${req.method} ${req.path}\``);
                  onerror(err);
              };
              if (typeof this.callback !== 'function') {
                  onerror(new Error('`callback` is not defined'));
                  return;
              }
              if (!this.promisifiedCallback) {
                  if (this.callback.length >= 3) {
                      debug('Converting legacy callback function to promise');
                      this.promisifiedCallback = promisify_1.default(this.callback);
                  }
                  else {
                      this.promisifiedCallback = this.callback;
                  }
              }
              if (typeof timeoutMs === 'number' && timeoutMs > 0) {
                  timeoutId = setTimeout(ontimeout, timeoutMs);
              }
              if ('port' in opts && typeof opts.port !== 'number') {
                  opts.port = Number(opts.port);
              }
              try {
                  debug('Resolving socket for %o request: %o', opts.protocol, `${req.method} ${req.path}`);
                  Promise.resolve(this.promisifiedCallback(req, opts)).then(onsocket, callbackError);
              }
              catch (err) {
                  Promise.reject(err).catch(callbackError);
              }
          }
          freeSocket(socket, opts) {
              debug('Freeing socket %o %o', socket.constructor.name, opts);
              socket.destroy();
          }
          destroy() {
              debug('Destroying agent %o', this.constructor.name);
          }
      }
      createAgent.Agent = Agent;
      // So that `instanceof` works correctly
      createAgent.prototype = createAgent.Agent.prototype;
  })(createAgent || (createAgent = {}));
  module.exports = createAgent;
  //# sourceMappingURL=index.js.map
  
  /***/ }),
  
  /***/ 163:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  function promisify(fn) {
      return function (req, opts) {
          return new Promise((resolve, reject) => {
              fn.call(this, req, opts, (err, rtn) => {
                  if (err) {
                      reject(err);
                  }
                  else {
                      resolve(rtn);
                  }
              });
          });
      };
  }
  exports.default = promisify;
  //# sourceMappingURL=promisify.js.map
  
  /***/ }),
  
  /***/ 164:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const debug_1 = __importDefault(__webpack_require__(33));
  const debug = debug_1.default('https-proxy-agent:parse-proxy-response');
  function parseProxyResponse(socket) {
      return new Promise((resolve, reject) => {
          // we need to buffer any HTTP traffic that happens with the proxy before we get
          // the CONNECT response, so that if the response is anything other than an "200"
          // response code, then we can re-play the "data" events on the socket once the
          // HTTP parser is hooked up...
          let buffersLength = 0;
          const buffers = [];
          function read() {
              const b = socket.read();
              if (b)
                  ondata(b);
              else
                  socket.once('readable', read);
          }
          function cleanup() {
              socket.removeListener('end', onend);
              socket.removeListener('error', onerror);
              socket.removeListener('close', onclose);
              socket.removeListener('readable', read);
          }
          function onclose(err) {
              debug('onclose had error %o', err);
          }
          function onend() {
              debug('onend');
          }
          function onerror(err) {
              cleanup();
              debug('onerror %o', err);
              reject(err);
          }
          function ondata(b) {
              buffers.push(b);
              buffersLength += b.length;
              const buffered = Buffer.concat(buffers, buffersLength);
              const endOfHeaders = buffered.indexOf('\r\n\r\n');
              if (endOfHeaders === -1) {
                  // keep buffering
                  debug('have not received end of HTTP headers yet...');
                  read();
                  return;
              }
              const firstLine = buffered.toString('ascii', 0, buffered.indexOf('\r\n'));
              const statusCode = +firstLine.split(' ')[1];
              debug('got proxy server response: %o', firstLine);
              resolve({
                  statusCode,
                  buffered
              });
          }
          socket.on('error', onerror);
          socket.on('close', onclose);
          socket.on('end', onend);
          read();
      });
  }
  exports.default = parseProxyResponse;
  //# sourceMappingURL=parse-proxy-response.js.map
  
  /***/ }),
  
  /***/ 17:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* unused harmony export default */
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return getGlobalThis; });
  /* global globalThis, self, window, global */
  const lastResort = {};
  function getGlobalThis() {
    // @ts-ignore
    if (typeof globalThis !== 'undefined') return globalThis; // check node first https://github.com/ljharb/globalThis/issues/2
    // @ts-ignore
  
    if (typeof global !== 'undefined') return global; // @ts-ignore
  
    if (typeof self !== 'undefined') return self; // @ts-ignore
  
    if (typeof window !== 'undefined') return window;
    if (typeof this !== 'undefined') return this;
    return lastResort; // should never happen
  }
  
  
  /***/ }),
  
  /***/ 19:
  /***/ (function(module, exports) {
  
  module.exports = require("util");
  
  /***/ }),
  
  /***/ 195:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  // ESM COMPAT FLAG
  __webpack_require__.r(__webpack_exports__);
  
  // EXPORTS
  __webpack_require__.d(__webpack_exports__, "Severity", function() { return /* reexport */ Severity; });
  __webpack_require__.d(__webpack_exports__, "Status", function() { return /* reexport */ Status; });
  __webpack_require__.d(__webpack_exports__, "addGlobalEventProcessor", function() { return /* reexport */ esm_scope["b" /* addGlobalEventProcessor */]; });
  __webpack_require__.d(__webpack_exports__, "addBreadcrumb", function() { return /* reexport */ addBreadcrumb; });
  __webpack_require__.d(__webpack_exports__, "captureException", function() { return /* reexport */ captureException; });
  __webpack_require__.d(__webpack_exports__, "captureEvent", function() { return /* reexport */ captureEvent; });
  __webpack_require__.d(__webpack_exports__, "captureMessage", function() { return /* reexport */ captureMessage; });
  __webpack_require__.d(__webpack_exports__, "configureScope", function() { return /* reexport */ configureScope; });
  __webpack_require__.d(__webpack_exports__, "getHubFromCarrier", function() { return /* reexport */ esm_hub["c" /* getHubFromCarrier */]; });
  __webpack_require__.d(__webpack_exports__, "getCurrentHub", function() { return /* reexport */ esm_hub["b" /* getCurrentHub */]; });
  __webpack_require__.d(__webpack_exports__, "Hub", function() { return /* reexport */ esm_hub["a" /* Hub */]; });
  __webpack_require__.d(__webpack_exports__, "makeMain", function() { return /* reexport */ esm_hub["e" /* makeMain */]; });
  __webpack_require__.d(__webpack_exports__, "Scope", function() { return /* reexport */ esm_scope["a" /* Scope */]; });
  __webpack_require__.d(__webpack_exports__, "startTransaction", function() { return /* reexport */ startTransaction; });
  __webpack_require__.d(__webpack_exports__, "SDK_VERSION", function() { return /* reexport */ SDK_VERSION; });
  __webpack_require__.d(__webpack_exports__, "setContext", function() { return /* reexport */ setContext; });
  __webpack_require__.d(__webpack_exports__, "setExtra", function() { return /* reexport */ setExtra; });
  __webpack_require__.d(__webpack_exports__, "setExtras", function() { return /* reexport */ setExtras; });
  __webpack_require__.d(__webpack_exports__, "setTag", function() { return /* reexport */ setTag; });
  __webpack_require__.d(__webpack_exports__, "setTags", function() { return /* reexport */ setTags; });
  __webpack_require__.d(__webpack_exports__, "setUser", function() { return /* reexport */ setUser; });
  __webpack_require__.d(__webpack_exports__, "withScope", function() { return /* reexport */ withScope; });
  __webpack_require__.d(__webpack_exports__, "NodeBackend", function() { return /* reexport */ backend_NodeBackend; });
  __webpack_require__.d(__webpack_exports__, "NodeClient", function() { return /* reexport */ client_NodeClient; });
  __webpack_require__.d(__webpack_exports__, "defaultIntegrations", function() { return /* reexport */ sdk_defaultIntegrations; });
  __webpack_require__.d(__webpack_exports__, "init", function() { return /* reexport */ init; });
  __webpack_require__.d(__webpack_exports__, "lastEventId", function() { return /* reexport */ lastEventId; });
  __webpack_require__.d(__webpack_exports__, "flush", function() { return /* reexport */ flush; });
  __webpack_require__.d(__webpack_exports__, "close", function() { return /* reexport */ sdk_close; });
  __webpack_require__.d(__webpack_exports__, "getSentryRelease", function() { return /* reexport */ getSentryRelease; });
  __webpack_require__.d(__webpack_exports__, "deepReadDirSync", function() { return /* reexport */ deepReadDirSync; });
  __webpack_require__.d(__webpack_exports__, "SDK_NAME", function() { return /* reexport */ SDK_NAME; });
  __webpack_require__.d(__webpack_exports__, "Integrations", function() { return /* binding */ INTEGRATIONS; });
  __webpack_require__.d(__webpack_exports__, "Transports", function() { return /* reexport */ transports_namespaceObject; });
  __webpack_require__.d(__webpack_exports__, "Handlers", function() { return /* reexport */ handlers_namespaceObject; });
  
  // NAMESPACE OBJECT: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/transports/index.js
  var transports_namespaceObject = {};
  __webpack_require__.r(transports_namespaceObject);
  __webpack_require__.d(transports_namespaceObject, "BaseTransport", function() { return base_BaseTransport; });
  __webpack_require__.d(transports_namespaceObject, "HTTPTransport", function() { return http_HTTPTransport; });
  __webpack_require__.d(transports_namespaceObject, "HTTPSTransport", function() { return https_HTTPSTransport; });
  
  // NAMESPACE OBJECT: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/core/esm/integrations/index.js
  var integrations_namespaceObject = {};
  __webpack_require__.r(integrations_namespaceObject);
  __webpack_require__.d(integrations_namespaceObject, "FunctionToString", function() { return FunctionToString; });
  __webpack_require__.d(integrations_namespaceObject, "InboundFilters", function() { return inboundfilters_InboundFilters; });
  
  // NAMESPACE OBJECT: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/integrations/index.js
  var esm_integrations_namespaceObject = {};
  __webpack_require__.r(esm_integrations_namespaceObject);
  __webpack_require__.d(esm_integrations_namespaceObject, "Console", function() { return console_Console; });
  __webpack_require__.d(esm_integrations_namespaceObject, "Http", function() { return http_Http; });
  __webpack_require__.d(esm_integrations_namespaceObject, "OnUncaughtException", function() { return onuncaughtexception_OnUncaughtException; });
  __webpack_require__.d(esm_integrations_namespaceObject, "OnUnhandledRejection", function() { return onunhandledrejection_OnUnhandledRejection; });
  __webpack_require__.d(esm_integrations_namespaceObject, "LinkedErrors", function() { return linkederrors_LinkedErrors; });
  __webpack_require__.d(esm_integrations_namespaceObject, "Modules", function() { return modules_Modules; });
  
  // NAMESPACE OBJECT: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/integrations/index.js
  var tracing_esm_integrations_namespaceObject = {};
  __webpack_require__.r(tracing_esm_integrations_namespaceObject);
  __webpack_require__.d(tracing_esm_integrations_namespaceObject, "Express", function() { return express_Express; });
  __webpack_require__.d(tracing_esm_integrations_namespaceObject, "Postgres", function() { return postgres_Postgres; });
  __webpack_require__.d(tracing_esm_integrations_namespaceObject, "Mysql", function() { return mysql_Mysql; });
  __webpack_require__.d(tracing_esm_integrations_namespaceObject, "Mongo", function() { return mongo_Mongo; });
  
  // NAMESPACE OBJECT: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/handlers.js
  var handlers_namespaceObject = {};
  __webpack_require__.r(handlers_namespaceObject);
  __webpack_require__.d(handlers_namespaceObject, "tracingHandler", function() { return tracingHandler; });
  __webpack_require__.d(handlers_namespaceObject, "extractRequestData", function() { return extractRequestData; });
  __webpack_require__.d(handlers_namespaceObject, "parseRequest", function() { return parseRequest; });
  __webpack_require__.d(handlers_namespaceObject, "requestHandler", function() { return requestHandler; });
  __webpack_require__.d(handlers_namespaceObject, "errorHandler", function() { return errorHandler; });
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/node_modules/tslib/tslib.es6.js
  /*! *****************************************************************************
  Copyright (c) Microsoft Corporation.
  
  Permission to use, copy, modify, and/or distribute this software for any
  purpose with or without fee is hereby granted.
  
  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  PERFORMANCE OF THIS SOFTWARE.
  ***************************************************************************** */
  /* global Reflect, Promise */
  
  var extendStatics = function(d, b) {
      extendStatics = Object.setPrototypeOf ||
          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
          function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
      return extendStatics(d, b);
  };
  
  function __extends(d, b) {
      extendStatics(d, b);
      function __() { this.constructor = d; }
      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  }
  
  var __assign = function() {
      __assign = Object.assign || function __assign(t) {
          for (var s, i = 1, n = arguments.length; i < n; i++) {
              s = arguments[i];
              for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
          }
          return t;
      }
      return __assign.apply(this, arguments);
  }
  
  function __rest(s, e) {
      var t = {};
      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
          t[p] = s[p];
      if (s != null && typeof Object.getOwnPropertySymbols === "function")
          for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
              if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                  t[p[i]] = s[p[i]];
          }
      return t;
  }
  
  function __decorate(decorators, target, key, desc) {
      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
      return c > 3 && r && Object.defineProperty(target, key, r), r;
  }
  
  function __param(paramIndex, decorator) {
      return function (target, key) { decorator(target, key, paramIndex); }
  }
  
  function __metadata(metadataKey, metadataValue) {
      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
  }
  
  function __awaiter(thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  }
  
  function __generator(thisArg, body) {
      var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
      function verb(n) { return function (v) { return step([n, v]); }; }
      function step(op) {
          if (f) throw new TypeError("Generator is already executing.");
          while (_) try {
              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
              if (y = 0, t) op = [op[0] & 2, t.value];
              switch (op[0]) {
                  case 0: case 1: t = op; break;
                  case 4: _.label++; return { value: op[1], done: false };
                  case 5: _.label++; y = op[1]; op = [0]; continue;
                  case 7: op = _.ops.pop(); _.trys.pop(); continue;
                  default:
                      if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                      if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                      if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                      if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                      if (t[2]) _.ops.pop();
                      _.trys.pop(); continue;
              }
              op = body.call(thisArg, _);
          } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
          if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
      }
  }
  
  function __createBinding(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }
  
  function __exportStar(m, exports) {
      for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];
  }
  
  function __values(o) {
      var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
      if (m) return m.call(o);
      if (o && typeof o.length === "number") return {
          next: function () {
              if (o && i >= o.length) o = void 0;
              return { value: o && o[i++], done: !o };
          }
      };
      throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
  }
  
  function __read(o, n) {
      var m = typeof Symbol === "function" && o[Symbol.iterator];
      if (!m) return o;
      var i = m.call(o), r, ar = [], e;
      try {
          while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
      }
      catch (error) { e = { error: error }; }
      finally {
          try {
              if (r && !r.done && (m = i["return"])) m.call(i);
          }
          finally { if (e) throw e.error; }
      }
      return ar;
  }
  
  function __spread() {
      for (var ar = [], i = 0; i < arguments.length; i++)
          ar = ar.concat(__read(arguments[i]));
      return ar;
  }
  
  function __spreadArrays() {
      for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
      for (var r = Array(s), k = 0, i = 0; i < il; i++)
          for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
              r[k] = a[j];
      return r;
  };
  
  function __await(v) {
      return this instanceof __await ? (this.v = v, this) : new __await(v);
  }
  
  function __asyncGenerator(thisArg, _arguments, generator) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var g = generator.apply(thisArg, _arguments || []), i, q = [];
      return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
      function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
      function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
      function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
      function fulfill(value) { resume("next", value); }
      function reject(value) { resume("throw", value); }
      function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
  }
  
  function __asyncDelegator(o) {
      var i, p;
      return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
      function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
  }
  
  function __asyncValues(o) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var m = o[Symbol.asyncIterator], i;
      return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
      function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
      function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
  }
  
  function __makeTemplateObject(cooked, raw) {
      if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
      return cooked;
  };
  
  function __importStar(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result.default = mod;
      return result;
  }
  
  function __importDefault(mod) {
      return (mod && mod.__esModule) ? mod : { default: mod };
  }
  
  function __classPrivateFieldGet(receiver, privateMap) {
      if (!privateMap.has(receiver)) {
          throw new TypeError("attempted to get private field on non-instance");
      }
      return privateMap.get(receiver);
  }
  
  function __classPrivateFieldSet(receiver, privateMap, value) {
      if (!privateMap.has(receiver)) {
          throw new TypeError("attempted to set private field on non-instance");
      }
      privateMap.set(receiver, value);
      return value;
  }
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/types/esm/severity.js
  /** JSDoc */
  // eslint-disable-next-line import/export
  var Severity;
  (function (Severity) {
      /** JSDoc */
      Severity["Fatal"] = "fatal";
      /** JSDoc */
      Severity["Error"] = "error";
      /** JSDoc */
      Severity["Warning"] = "warning";
      /** JSDoc */
      Severity["Log"] = "log";
      /** JSDoc */
      Severity["Info"] = "info";
      /** JSDoc */
      Severity["Debug"] = "debug";
      /** JSDoc */
      Severity["Critical"] = "critical";
  })(Severity || (Severity = {}));
  // eslint-disable-next-line @typescript-eslint/no-namespace, import/export
  (function (Severity) {
      /**
       * Converts a string-based level into a {@link Severity}.
       *
       * @param level string representation of Severity
       * @returns Severity
       */
      function fromString(level) {
          switch (level) {
              case 'debug':
                  return Severity.Debug;
              case 'info':
                  return Severity.Info;
              case 'warn':
              case 'warning':
                  return Severity.Warning;
              case 'error':
                  return Severity.Error;
              case 'fatal':
                  return Severity.Fatal;
              case 'critical':
                  return Severity.Critical;
              case 'log':
              default:
                  return Severity.Log;
          }
      }
      Severity.fromString = fromString;
  })(Severity || (Severity = {}));
  //# sourceMappingURL=severity.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/types/esm/status.js
  /** The status of an event. */
  // eslint-disable-next-line import/export
  var Status;
  (function (Status) {
      /** The status could not be determined. */
      Status["Unknown"] = "unknown";
      /** The event was skipped due to configuration or callbacks. */
      Status["Skipped"] = "skipped";
      /** The event was sent to Sentry successfully. */
      Status["Success"] = "success";
      /** The client is currently rate limited and will try again later. */
      Status["RateLimit"] = "rate_limit";
      /** The event could not be processed. */
      Status["Invalid"] = "invalid";
      /** A server-side error occurred during submission. */
      Status["Failed"] = "failed";
  })(Status || (Status = {}));
  // eslint-disable-next-line @typescript-eslint/no-namespace, import/export
  (function (Status) {
      /**
       * Converts a HTTP status code into a {@link Status}.
       *
       * @param code The HTTP response status code.
       * @returns The send status or {@link Status.Unknown}.
       */
      function fromHttpCode(code) {
          if (code >= 200 && code < 300) {
              return Status.Success;
          }
          if (code === 429) {
              return Status.RateLimit;
          }
          if (code >= 400 && code < 500) {
              return Status.Invalid;
          }
          if (code >= 500) {
              return Status.Failed;
          }
          return Status.Unknown;
      }
      Status.fromHttpCode = fromHttpCode;
  })(Status || (Status = {}));
  //# sourceMappingURL=status.js.map
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/hub/esm/scope.js
  var esm_scope = __webpack_require__(58);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/minimal/node_modules/tslib/tslib.es6.js
  /*! *****************************************************************************
  Copyright (c) Microsoft Corporation.
  
  Permission to use, copy, modify, and/or distribute this software for any
  purpose with or without fee is hereby granted.
  
  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  PERFORMANCE OF THIS SOFTWARE.
  ***************************************************************************** */
  /* global Reflect, Promise */
  
  var tslib_es6_extendStatics = function(d, b) {
      tslib_es6_extendStatics = Object.setPrototypeOf ||
          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
          function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
      return tslib_es6_extendStatics(d, b);
  };
  
  function tslib_es6_extends(d, b) {
      tslib_es6_extendStatics(d, b);
      function __() { this.constructor = d; }
      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  }
  
  var tslib_es6_assign = function() {
      tslib_es6_assign = Object.assign || function __assign(t) {
          for (var s, i = 1, n = arguments.length; i < n; i++) {
              s = arguments[i];
              for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
          }
          return t;
      }
      return tslib_es6_assign.apply(this, arguments);
  }
  
  function tslib_es6_rest(s, e) {
      var t = {};
      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
          t[p] = s[p];
      if (s != null && typeof Object.getOwnPropertySymbols === "function")
          for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
              if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                  t[p[i]] = s[p[i]];
          }
      return t;
  }
  
  function tslib_es6_decorate(decorators, target, key, desc) {
      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
      return c > 3 && r && Object.defineProperty(target, key, r), r;
  }
  
  function tslib_es6_param(paramIndex, decorator) {
      return function (target, key) { decorator(target, key, paramIndex); }
  }
  
  function tslib_es6_metadata(metadataKey, metadataValue) {
      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
  }
  
  function tslib_es6_awaiter(thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  }
  
  function tslib_es6_generator(thisArg, body) {
      var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
      function verb(n) { return function (v) { return step([n, v]); }; }
      function step(op) {
          if (f) throw new TypeError("Generator is already executing.");
          while (_) try {
              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
              if (y = 0, t) op = [op[0] & 2, t.value];
              switch (op[0]) {
                  case 0: case 1: t = op; break;
                  case 4: _.label++; return { value: op[1], done: false };
                  case 5: _.label++; y = op[1]; op = [0]; continue;
                  case 7: op = _.ops.pop(); _.trys.pop(); continue;
                  default:
                      if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                      if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                      if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                      if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                      if (t[2]) _.ops.pop();
                      _.trys.pop(); continue;
              }
              op = body.call(thisArg, _);
          } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
          if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
      }
  }
  
  function tslib_es6_createBinding(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }
  
  function tslib_es6_exportStar(m, exports) {
      for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];
  }
  
  function tslib_es6_values(o) {
      var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
      if (m) return m.call(o);
      if (o && typeof o.length === "number") return {
          next: function () {
              if (o && i >= o.length) o = void 0;
              return { value: o && o[i++], done: !o };
          }
      };
      throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
  }
  
  function tslib_es6_read(o, n) {
      var m = typeof Symbol === "function" && o[Symbol.iterator];
      if (!m) return o;
      var i = m.call(o), r, ar = [], e;
      try {
          while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
      }
      catch (error) { e = { error: error }; }
      finally {
          try {
              if (r && !r.done && (m = i["return"])) m.call(i);
          }
          finally { if (e) throw e.error; }
      }
      return ar;
  }
  
  function tslib_es6_spread() {
      for (var ar = [], i = 0; i < arguments.length; i++)
          ar = ar.concat(tslib_es6_read(arguments[i]));
      return ar;
  }
  
  function tslib_es6_spreadArrays() {
      for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
      for (var r = Array(s), k = 0, i = 0; i < il; i++)
          for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
              r[k] = a[j];
      return r;
  };
  
  function tslib_es6_await(v) {
      return this instanceof tslib_es6_await ? (this.v = v, this) : new tslib_es6_await(v);
  }
  
  function tslib_es6_asyncGenerator(thisArg, _arguments, generator) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var g = generator.apply(thisArg, _arguments || []), i, q = [];
      return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
      function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
      function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
      function step(r) { r.value instanceof tslib_es6_await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
      function fulfill(value) { resume("next", value); }
      function reject(value) { resume("throw", value); }
      function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
  }
  
  function tslib_es6_asyncDelegator(o) {
      var i, p;
      return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
      function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: tslib_es6_await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
  }
  
  function tslib_es6_asyncValues(o) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var m = o[Symbol.asyncIterator], i;
      return m ? m.call(o) : (o = typeof tslib_es6_values === "function" ? tslib_es6_values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
      function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
      function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
  }
  
  function tslib_es6_makeTemplateObject(cooked, raw) {
      if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
      return cooked;
  };
  
  function tslib_es6_importStar(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result.default = mod;
      return result;
  }
  
  function tslib_es6_importDefault(mod) {
      return (mod && mod.__esModule) ? mod : { default: mod };
  }
  
  function tslib_es6_classPrivateFieldGet(receiver, privateMap) {
      if (!privateMap.has(receiver)) {
          throw new TypeError("attempted to get private field on non-instance");
      }
      return privateMap.get(receiver);
  }
  
  function tslib_es6_classPrivateFieldSet(receiver, privateMap, value) {
      if (!privateMap.has(receiver)) {
          throw new TypeError("attempted to set private field on non-instance");
      }
      privateMap.set(receiver, value);
      return value;
  }
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/hub/esm/hub.js + 1 modules
  var esm_hub = __webpack_require__(26);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/minimal/esm/index.js
  
  
  /**
   * This calls a function on the current hub.
   * @param method function to call on hub.
   * @param args to pass to function.
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function callOnHub(method) {
      var args = [];
      for (var _i = 1; _i < arguments.length; _i++) {
          args[_i - 1] = arguments[_i];
      }
      var hub = Object(esm_hub["b" /* getCurrentHub */])();
      if (hub && hub[method]) {
          // eslint-disable-next-line @typescript-eslint/no-explicit-any
          return hub[method].apply(hub, tslib_es6_spread(args));
      }
      throw new Error("No hub defined or " + method + " was not found on the hub, please open a bug report.");
  }
  /**
   * Captures an exception event and sends it to Sentry.
   *
   * @param exception An exception-like object.
   * @returns The generated eventId.
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
  function captureException(exception, captureContext) {
      var syntheticException;
      try {
          throw new Error('Sentry syntheticException');
      }
      catch (exception) {
          syntheticException = exception;
      }
      return callOnHub('captureException', exception, {
          captureContext: captureContext,
          originalException: exception,
          syntheticException: syntheticException,
      });
  }
  /**
   * Captures a message event and sends it to Sentry.
   *
   * @param message The message to send to Sentry.
   * @param level Define the level of the message.
   * @returns The generated eventId.
   */
  function captureMessage(message, captureContext) {
      var syntheticException;
      try {
          throw new Error(message);
      }
      catch (exception) {
          syntheticException = exception;
      }
      // This is necessary to provide explicit scopes upgrade, without changing the original
      // arity of the `captureMessage(message, level)` method.
      var level = typeof captureContext === 'string' ? captureContext : undefined;
      var context = typeof captureContext !== 'string' ? { captureContext: captureContext } : undefined;
      return callOnHub('captureMessage', message, level, tslib_es6_assign({ originalException: message, syntheticException: syntheticException }, context));
  }
  /**
   * Captures a manually created event and sends it to Sentry.
   *
   * @param event The event to send to Sentry.
   * @returns The generated eventId.
   */
  function captureEvent(event) {
      return callOnHub('captureEvent', event);
  }
  /**
   * Callback to set context information onto the scope.
   * @param callback Callback function that receives Scope.
   */
  function configureScope(callback) {
      callOnHub('configureScope', callback);
  }
  /**
   * Records a new breadcrumb which will be attached to future events.
   *
   * Breadcrumbs will be added to subsequent events to provide more context on
   * user's actions prior to an error or crash.
   *
   * @param breadcrumb The breadcrumb to record.
   */
  function addBreadcrumb(breadcrumb) {
      callOnHub('addBreadcrumb', breadcrumb);
  }
  /**
   * Sets context data with the given name.
   * @param name of the context
   * @param context Any kind of data. This data will be normalized.
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function setContext(name, context) {
      callOnHub('setContext', name, context);
  }
  /**
   * Set an object that will be merged sent as extra data with the event.
   * @param extras Extras object to merge into current context.
   */
  function setExtras(extras) {
      callOnHub('setExtras', extras);
  }
  /**
   * Set an object that will be merged sent as tags data with the event.
   * @param tags Tags context object to merge into current context.
   */
  function setTags(tags) {
      callOnHub('setTags', tags);
  }
  /**
   * Set key:value that will be sent as extra data with the event.
   * @param key String of extra
   * @param extra Any kind of data. This data will be normalized.
   */
  function setExtra(key, extra) {
      callOnHub('setExtra', key, extra);
  }
  /**
   * Set key:value that will be sent as tags data with the event.
   *
   * Can also be used to unset a tag, by passing `undefined`.
   *
   * @param key String key of tag
   * @param value Value of tag
   */
  function setTag(key, value) {
      callOnHub('setTag', key, value);
  }
  /**
   * Updates user context information for future events.
   *
   * @param user User context object to be set in the current context. Pass `null` to unset the user.
   */
  function setUser(user) {
      callOnHub('setUser', user);
  }
  /**
   * Creates a new scope with and executes the given operation within.
   * The scope is automatically removed once the operation
   * finishes or throws.
   *
   * This is essentially a convenience function for:
   *
   *     pushScope();
   *     callback();
   *     popScope();
   *
   * @param callback that will be enclosed into push/popScope.
   */
  function withScope(callback) {
      callOnHub('withScope', callback);
  }
  /**
   * Calls a function on the latest client. Use this with caution, it's meant as
   * in "internal" helper so we don't need to expose every possible function in
   * the shim. It is not guaranteed that the client actually implements the
   * function.
   *
   * @param method The method to call on the client/client.
   * @param args Arguments to pass to the client/fontend.
   * @hidden
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function _callOnClient(method) {
      var args = [];
      for (var _i = 1; _i < arguments.length; _i++) {
          args[_i - 1] = arguments[_i];
      }
      callOnHub.apply(void 0, tslib_es6_spread(['_invokeClient', method], args));
  }
  /**
   * Starts a new `Transaction` and returns it. This is the entry point to manual tracing instrumentation.
   *
   * A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a
   * new child span within the transaction or any span, call the respective `.startChild()` method.
   *
   * Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.
   *
   * The transaction must be finished with a call to its `.finish()` method, at which point the transaction with all its
   * finished child spans will be sent to Sentry.
   *
   * @param context Properties of the new `Transaction`.
   * @param customSamplingContext Information given to the transaction sampling function (along with context-dependent
   * default values). See {@link Options.tracesSampler}.
   *
   * @returns The transaction which was just started
   */
  function startTransaction(context, customSamplingContext) {
      return callOnHub('startTransaction', tslib_es6_assign({}, context), customSamplingContext);
  }
  //# sourceMappingURL=index.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/core/esm/version.js
  var SDK_VERSION = '6.13.3';
  //# sourceMappingURL=version.js.map
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/logger.js
  var logger = __webpack_require__(8);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/node_modules/tslib/tslib.es6.js
  var tslib_es6 = __webpack_require__(16);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/polyfill.js
  var setPrototypeOf = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties);
  /**
   * setPrototypeOf polyfill using __proto__
   */
  // eslint-disable-next-line @typescript-eslint/ban-types
  function setProtoOf(obj, proto) {
      // @ts-ignore __proto__ does not exist on obj
      obj.__proto__ = proto;
      return obj;
  }
  /**
   * setPrototypeOf polyfill using mixin
   */
  // eslint-disable-next-line @typescript-eslint/ban-types
  function mixinProperties(obj, proto) {
      for (var prop in proto) {
          // eslint-disable-next-line no-prototype-builtins
          if (!obj.hasOwnProperty(prop)) {
              // @ts-ignore typescript complains about indexing so we remove
              obj[prop] = proto[prop];
          }
      }
      return obj;
  }
  //# sourceMappingURL=polyfill.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/error.js
  
  
  /** An error emitted by Sentry SDKs and related utilities. */
  var error_SentryError = /** @class */ (function (_super) {
      Object(tslib_es6["b" /* __extends */])(SentryError, _super);
      function SentryError(message) {
          var _newTarget = this.constructor;
          var _this = _super.call(this, message) || this;
          _this.message = message;
          _this.name = _newTarget.prototype.constructor.name;
          setPrototypeOf(_this, _newTarget.prototype);
          return _this;
      }
      return SentryError;
  }(Error));
  
  //# sourceMappingURL=error.js.map
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/syncpromise.js
  var syncpromise = __webpack_require__(48);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/core/esm/transports/noop.js
  
  
  /** Noop transport */
  var noop_NoopTransport = /** @class */ (function () {
      function NoopTransport() {
      }
      /**
       * @inheritDoc
       */
      NoopTransport.prototype.sendEvent = function (_) {
          return syncpromise["a" /* SyncPromise */].resolve({
              reason: "NoopTransport: Event has been skipped because no Dsn is configured.",
              status: Status.Skipped,
          });
      };
      /**
       * @inheritDoc
       */
      NoopTransport.prototype.close = function (_) {
          return syncpromise["a" /* SyncPromise */].resolve(true);
      };
      return NoopTransport;
  }());
  
  //# sourceMappingURL=noop.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/core/esm/basebackend.js
  
  
  /**
   * This is the base implemention of a Backend.
   * @hidden
   */
  var basebackend_BaseBackend = /** @class */ (function () {
      /** Creates a new backend instance. */
      function BaseBackend(options) {
          this._options = options;
          if (!this._options.dsn) {
              logger["a" /* logger */].warn('No DSN provided, backend will not do anything.');
          }
          this._transport = this._setupTransport();
      }
      /**
       * @inheritDoc
       */
      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
      BaseBackend.prototype.eventFromException = function (_exception, _hint) {
          throw new error_SentryError('Backend has to implement `eventFromException` method');
      };
      /**
       * @inheritDoc
       */
      BaseBackend.prototype.eventFromMessage = function (_message, _level, _hint) {
          throw new error_SentryError('Backend has to implement `eventFromMessage` method');
      };
      /**
       * @inheritDoc
       */
      BaseBackend.prototype.sendEvent = function (event) {
          void this._transport.sendEvent(event).then(null, function (reason) {
              logger["a" /* logger */].error("Error while sending event: " + reason);
          });
      };
      /**
       * @inheritDoc
       */
      BaseBackend.prototype.sendSession = function (session) {
          if (!this._transport.sendSession) {
              logger["a" /* logger */].warn("Dropping session because custom transport doesn't implement sendSession");
              return;
          }
          void this._transport.sendSession(session).then(null, function (reason) {
              logger["a" /* logger */].error("Error while sending session: " + reason);
          });
      };
      /**
       * @inheritDoc
       */
      BaseBackend.prototype.getTransport = function () {
          return this._transport;
      };
      /**
       * Sets up the transport so it can be used later to send requests.
       */
      BaseBackend.prototype._setupTransport = function () {
          return new noop_NoopTransport();
      };
      return BaseBackend;
  }());
  
  //# sourceMappingURL=basebackend.js.map
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/is.js
  var is = __webpack_require__(9);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/object.js + 1 modules
  var object = __webpack_require__(14);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/misc.js
  var misc = __webpack_require__(11);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/dsn.js
  
  
  /** Regular expression used to parse a Dsn. */
  var DSN_REGEX = /^(?:(\w+):)\/\/(?:(\w+)(?::(\w+))?@)([\w.-]+)(?::(\d+))?\/(.+)/;
  /** Error message */
  var ERROR_MESSAGE = 'Invalid Dsn';
  /** The Sentry Dsn, identifying a Sentry instance and project. */
  var dsn_Dsn = /** @class */ (function () {
      /** Creates a new Dsn component */
      function Dsn(from) {
          if (typeof from === 'string') {
              this._fromString(from);
          }
          else {
              this._fromComponents(from);
          }
          this._validate();
      }
      /**
       * Renders the string representation of this Dsn.
       *
       * By default, this will render the public representation without the password
       * component. To get the deprecated private representation, set `withPassword`
       * to true.
       *
       * @param withPassword When set to true, the password will be included.
       */
      Dsn.prototype.toString = function (withPassword) {
          if (withPassword === void 0) { withPassword = false; }
          var _a = this, host = _a.host, path = _a.path, pass = _a.pass, port = _a.port, projectId = _a.projectId, protocol = _a.protocol, publicKey = _a.publicKey;
          return (protocol + "://" + publicKey + (withPassword && pass ? ":" + pass : '') +
              ("@" + host + (port ? ":" + port : '') + "/" + (path ? path + "/" : path) + projectId));
      };
      /** Parses a string into this Dsn. */
      Dsn.prototype._fromString = function (str) {
          var match = DSN_REGEX.exec(str);
          if (!match) {
              throw new error_SentryError(ERROR_MESSAGE);
          }
          var _a = Object(tslib_es6["c" /* __read */])(match.slice(1), 6), protocol = _a[0], publicKey = _a[1], _b = _a[2], pass = _b === void 0 ? '' : _b, host = _a[3], _c = _a[4], port = _c === void 0 ? '' : _c, lastPath = _a[5];
          var path = '';
          var projectId = lastPath;
          var split = projectId.split('/');
          if (split.length > 1) {
              path = split.slice(0, -1).join('/');
              projectId = split.pop();
          }
          if (projectId) {
              var projectMatch = projectId.match(/^\d+/);
              if (projectMatch) {
                  projectId = projectMatch[0];
              }
          }
          this._fromComponents({ host: host, pass: pass, path: path, projectId: projectId, port: port, protocol: protocol, publicKey: publicKey });
      };
      /** Maps Dsn components into this instance. */
      Dsn.prototype._fromComponents = function (components) {
          // TODO this is for backwards compatibility, and can be removed in a future version
          if ('user' in components && !('publicKey' in components)) {
              components.publicKey = components.user;
          }
          this.user = components.publicKey || '';
          this.protocol = components.protocol;
          this.publicKey = components.publicKey || '';
          this.pass = components.pass || '';
          this.host = components.host;
          this.port = components.port || '';
          this.path = components.path || '';
          this.projectId = components.projectId;
      };
      /** Validates this Dsn and throws on error. */
      Dsn.prototype._validate = function () {
          var _this = this;
          ['protocol', 'publicKey', 'host', 'projectId'].forEach(function (component) {
              if (!_this[component]) {
                  throw new error_SentryError(ERROR_MESSAGE + ": " + component + " missing");
              }
          });
          if (!this.projectId.match(/^\d+$/)) {
              throw new error_SentryError(ERROR_MESSAGE + ": Invalid projectId " + this.projectId);
          }
          if (this.protocol !== 'http' && this.protocol !== 'https') {
              throw new error_SentryError(ERROR_MESSAGE + ": Invalid protocol " + this.protocol);
          }
          if (this.port && isNaN(parseInt(this.port, 10))) {
              throw new error_SentryError(ERROR_MESSAGE + ": Invalid port " + this.port);
          }
      };
      return Dsn;
  }());
  
  //# sourceMappingURL=dsn.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/path.js
  // Slightly modified (no IE8 support, ES6) and transcribed to TypeScript
  // https://raw.githubusercontent.com/calvinmetcalf/rollup-plugin-node-builtins/master/src/es6/path.js
  /** JSDoc */
  function normalizeArray(parts, allowAboveRoot) {
      // if the path tries to go above the root, `up` ends up > 0
      var up = 0;
      for (var i = parts.length - 1; i >= 0; i--) {
          var last = parts[i];
          if (last === '.') {
              parts.splice(i, 1);
          }
          else if (last === '..') {
              parts.splice(i, 1);
              // eslint-disable-next-line no-plusplus
              up++;
          }
          else if (up) {
              parts.splice(i, 1);
              // eslint-disable-next-line no-plusplus
              up--;
          }
      }
      // if the path is allowed to go above the root, restore leading ..s
      if (allowAboveRoot) {
          // eslint-disable-next-line no-plusplus
          for (; up--; up) {
              parts.unshift('..');
          }
      }
      return parts;
  }
  // Split a filename into [root, dir, basename, ext], unix version
  // 'root' is just a slash, or nothing.
  var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^/]+?|)(\.[^./]*|))(?:[/]*)$/;
  /** JSDoc */
  function splitPath(filename) {
      var parts = splitPathRe.exec(filename);
      return parts ? parts.slice(1) : [];
  }
  // path.resolve([from ...], to)
  // posix version
  /** JSDoc */
  function path_resolve() {
      var args = [];
      for (var _i = 0; _i < arguments.length; _i++) {
          args[_i] = arguments[_i];
      }
      var resolvedPath = '';
      var resolvedAbsolute = false;
      for (var i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
          var path = i >= 0 ? args[i] : '/';
          // Skip empty entries
          if (!path) {
              continue;
          }
          resolvedPath = path + "/" + resolvedPath;
          resolvedAbsolute = path.charAt(0) === '/';
      }
      // At this point the path should be resolved to a full absolute path, but
      // handle relative paths to be safe (might happen when process.cwd() fails)
      // Normalize the path
      resolvedPath = normalizeArray(resolvedPath.split('/').filter(function (p) { return !!p; }), !resolvedAbsolute).join('/');
      return (resolvedAbsolute ? '/' : '') + resolvedPath || '.';
  }
  /** JSDoc */
  function trim(arr) {
      var start = 0;
      for (; start < arr.length; start++) {
          if (arr[start] !== '') {
              break;
          }
      }
      var end = arr.length - 1;
      for (; end >= 0; end--) {
          if (arr[end] !== '') {
              break;
          }
      }
      if (start > end) {
          return [];
      }
      return arr.slice(start, end - start + 1);
  }
  // path.relative(from, to)
  // posix version
  /** JSDoc */
  function relative(from, to) {
      /* eslint-disable no-param-reassign */
      from = path_resolve(from).substr(1);
      to = path_resolve(to).substr(1);
      /* eslint-enable no-param-reassign */
      var fromParts = trim(from.split('/'));
      var toParts = trim(to.split('/'));
      var length = Math.min(fromParts.length, toParts.length);
      var samePartsLength = length;
      for (var i = 0; i < length; i++) {
          if (fromParts[i] !== toParts[i]) {
              samePartsLength = i;
              break;
          }
      }
      var outputParts = [];
      for (var i = samePartsLength; i < fromParts.length; i++) {
          outputParts.push('..');
      }
      outputParts = outputParts.concat(toParts.slice(samePartsLength));
      return outputParts.join('/');
  }
  // path.normalize(path)
  // posix version
  /** JSDoc */
  function normalizePath(path) {
      var isPathAbsolute = isAbsolute(path);
      var trailingSlash = path.substr(-1) === '/';
      // Normalize the path
      var normalizedPath = normalizeArray(path.split('/').filter(function (p) { return !!p; }), !isPathAbsolute).join('/');
      if (!normalizedPath && !isPathAbsolute) {
          normalizedPath = '.';
      }
      if (normalizedPath && trailingSlash) {
          normalizedPath += '/';
      }
      return (isPathAbsolute ? '/' : '') + normalizedPath;
  }
  // posix version
  /** JSDoc */
  function isAbsolute(path) {
      return path.charAt(0) === '/';
  }
  // posix version
  /** JSDoc */
  function join() {
      var args = [];
      for (var _i = 0; _i < arguments.length; _i++) {
          args[_i] = arguments[_i];
      }
      return normalizePath(args.join('/'));
  }
  /** JSDoc */
  function dirname(path) {
      var result = splitPath(path);
      var root = result[0];
      var dir = result[1];
      if (!root && !dir) {
          // No dirname whatsoever
          return '.';
      }
      if (dir) {
          // It has a dirname, strip trailing slash
          dir = dir.substr(0, dir.length - 1);
      }
      return root + dir;
  }
  /** JSDoc */
  function basename(path, ext) {
      var f = splitPath(path)[2];
      if (ext && f.substr(ext.length * -1) === ext) {
          f = f.substr(0, f.length - ext.length);
      }
      return f;
  }
  //# sourceMappingURL=path.js.map
  // EXTERNAL MODULE: external "fs"
  var external_fs_ = __webpack_require__(15);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/lru_map/lru.js
  var lru = __webpack_require__(120);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/stacktrace.js
  /**
   * stack-trace - Parses node.js stack traces
   *
   * This was originally forked to fix this issue:
   * https://github.com/felixge/node-stack-trace/issues/31
   *
   * Mar 19,2019 - #4fd379e
   *
   * https://github.com/felixge/node-stack-trace/
   * @license MIT
   */
  /** Extracts StackFrames from the Error */
  function parse(err) {
      if (!err.stack) {
          return [];
      }
      var lines = err.stack.split('\n').slice(1);
      return lines
          .map(function (line) {
          if (line.match(/^\s*[-]{4,}$/)) {
              return {
                  columnNumber: null,
                  fileName: line,
                  functionName: null,
                  lineNumber: null,
                  methodName: null,
                  native: null,
                  typeName: null,
              };
          }
          var lineMatch = line.match(/at (?:(.+?)\s+\()?(?:(.+?):(\d+)(?::(\d+))?|([^)]+))\)?/);
          if (!lineMatch) {
              return undefined;
          }
          var object = null;
          var method = null;
          var functionName = null;
          var typeName = null;
          var methodName = null;
          var isNative = lineMatch[5] === 'native';
          if (lineMatch[1]) {
              functionName = lineMatch[1];
              var methodStart = functionName.lastIndexOf('.');
              if (functionName[methodStart - 1] === '.') {
                  // eslint-disable-next-line no-plusplus
                  methodStart--;
              }
              if (methodStart > 0) {
                  object = functionName.substr(0, methodStart);
                  method = functionName.substr(methodStart + 1);
                  var objectEnd = object.indexOf('.Module');
                  if (objectEnd > 0) {
                      functionName = functionName.substr(objectEnd + 1);
                      object = object.substr(0, objectEnd);
                  }
              }
              typeName = null;
          }
          if (method) {
              typeName = object;
              methodName = method;
          }
          if (method === '<anonymous>') {
              methodName = null;
              functionName = null;
          }
          var properties = {
              columnNumber: parseInt(lineMatch[4], 10) || null,
              fileName: lineMatch[2] || null,
              functionName: functionName,
              lineNumber: parseInt(lineMatch[3], 10) || null,
              methodName: methodName,
              native: isNative,
              typeName: typeName,
          };
          return properties;
      })
          .filter(function (callSite) { return !!callSite; });
  }
  //# sourceMappingURL=stacktrace.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/parsers.js
  
  
  
  
  var DEFAULT_LINES_OF_CONTEXT = 7;
  var FILE_CONTENT_CACHE = new lru["LRUMap"](100);
  /**
   * Resets the file cache. Exists for testing purposes.
   * @hidden
   */
  function resetFileContentCache() {
      FILE_CONTENT_CACHE.clear();
  }
  /** JSDoc */
  function getFunction(frame) {
      try {
          return frame.functionName || frame.typeName + "." + (frame.methodName || '<anonymous>');
      }
      catch (e) {
          // This seems to happen sometimes when using 'use strict',
          // stemming from `getTypeName`.
          // [TypeError: Cannot read property 'constructor' of undefined]
          return '<anonymous>';
      }
  }
  var mainModule = ((__webpack_require__.c[__webpack_require__.s] && __webpack_require__.c[__webpack_require__.s].filename && dirname(__webpack_require__.c[__webpack_require__.s].filename)) ||
      global.process.cwd()) + "/";
  /** JSDoc */
  function getModule(filename, base) {
      if (!base) {
          // eslint-disable-next-line no-param-reassign
          base = mainModule;
      }
      // It's specifically a module
      var file = basename(filename, '.js');
      // eslint-disable-next-line no-param-reassign
      filename = dirname(filename);
      var n = filename.lastIndexOf('/node_modules/');
      if (n > -1) {
          // /node_modules/ is 14 chars
          return filename.substr(n + 14).replace(/\//g, '.') + ":" + file;
      }
      // Let's see if it's a part of the main module
      // To be a part of main module, it has to share the same base
      n = (filename + "/").lastIndexOf(base, 0);
      if (n === 0) {
          var moduleName = filename.substr(base.length).replace(/\//g, '.');
          if (moduleName) {
              moduleName += ':';
          }
          moduleName += file;
          return moduleName;
      }
      return file;
  }
  /**
   * This function reads file contents and caches them in a global LRU cache.
   * Returns a Promise filepath => content array for all files that we were able to read.
   *
   * @param filenames Array of filepaths to read content from.
   */
  function readSourceFiles(filenames) {
      // we're relying on filenames being de-duped already
      if (filenames.length === 0) {
          return syncpromise["a" /* SyncPromise */].resolve({});
      }
      return new syncpromise["a" /* SyncPromise */](function (resolve) {
          var sourceFiles = {};
          var count = 0;
          var _loop_1 = function (i) {
              var filename = filenames[i];
              var cache = FILE_CONTENT_CACHE.get(filename);
              // We have a cache hit
              if (cache !== undefined) {
                  // If it's not null (which means we found a file and have a content)
                  // we set the content and return it later.
                  if (cache !== null) {
                      sourceFiles[filename] = cache;
                  }
                  // eslint-disable-next-line no-plusplus
                  count++;
                  // In any case we want to skip here then since we have a content already or we couldn't
                  // read the file and don't want to try again.
                  if (count === filenames.length) {
                      resolve(sourceFiles);
                  }
                  return "continue";
              }
              Object(external_fs_["readFile"])(filename, function (err, data) {
                  var content = err ? null : data.toString();
                  sourceFiles[filename] = content;
                  // We always want to set the cache, even to null which means there was an error reading the file.
                  // We do not want to try to read the file again.
                  FILE_CONTENT_CACHE.set(filename, content);
                  // eslint-disable-next-line no-plusplus
                  count++;
                  if (count === filenames.length) {
                      resolve(sourceFiles);
                  }
              });
          };
          // eslint-disable-next-line @typescript-eslint/prefer-for-of
          for (var i = 0; i < filenames.length; i++) {
              _loop_1(i);
          }
      });
  }
  /**
   * @hidden
   */
  function extractStackFromError(error) {
      var stack = parse(error);
      if (!stack) {
          return [];
      }
      return stack;
  }
  /**
   * @hidden
   */
  function parseStack(stack, options) {
      var filesToRead = [];
      var linesOfContext = options && options.frameContextLines !== undefined ? options.frameContextLines : DEFAULT_LINES_OF_CONTEXT;
      var frames = stack.map(function (frame) {
          var _a;
          var parsedFrame = {
              colno: frame.columnNumber,
              filename: ((_a = frame.fileName) === null || _a === void 0 ? void 0 : _a.startsWith('file://')) ? frame.fileName.substr(7) : frame.fileName || '',
              function: getFunction(frame),
              lineno: frame.lineNumber,
          };
          var isInternal = frame.native ||
              (parsedFrame.filename &&
                  !parsedFrame.filename.startsWith('/') &&
                  !parsedFrame.filename.startsWith('.') &&
                  parsedFrame.filename.indexOf(':\\') !== 1);
          // in_app is all that's not an internal Node function or a module within node_modules
          // note that isNative appears to return true even for node core libraries
          // see https://github.com/getsentry/raven-node/issues/176
          parsedFrame.in_app =
              !isInternal && parsedFrame.filename !== undefined && parsedFrame.filename.indexOf('node_modules/') === -1;
          // Extract a module name based on the filename
          if (parsedFrame.filename) {
              parsedFrame.module = getModule(parsedFrame.filename);
              if (!isInternal && linesOfContext > 0 && filesToRead.indexOf(parsedFrame.filename) === -1) {
                  filesToRead.push(parsedFrame.filename);
              }
          }
          return parsedFrame;
      });
      // We do an early return if we do not want to fetch context liens
      if (linesOfContext <= 0) {
          return syncpromise["a" /* SyncPromise */].resolve(frames);
      }
      try {
          return addPrePostContext(filesToRead, frames, linesOfContext);
      }
      catch (_) {
          // This happens in electron for example where we are not able to read files from asar.
          // So it's fine, we recover be just returning all frames without pre/post context.
          return syncpromise["a" /* SyncPromise */].resolve(frames);
      }
  }
  /**
   * This function tries to read the source files + adding pre and post context (source code)
   * to a frame.
   * @param filesToRead string[] of filepaths
   * @param frames StackFrame[] containg all frames
   */
  function addPrePostContext(filesToRead, frames, linesOfContext) {
      return new syncpromise["a" /* SyncPromise */](function (resolve) {
          return readSourceFiles(filesToRead).then(function (sourceFiles) {
              var result = frames.map(function (frame) {
                  if (frame.filename && sourceFiles[frame.filename]) {
                      try {
                          var lines = sourceFiles[frame.filename].split('\n');
                          Object(misc["a" /* addContextToFrame */])(lines, frame, linesOfContext);
                      }
                      catch (e) {
                          // anomaly, being defensive in case
                          // unlikely to ever happen in practice but can definitely happen in theory
                      }
                  }
                  return frame;
              });
              resolve(result);
          });
      });
  }
  /**
   * @hidden
   */
  function getExceptionFromError(error, options) {
      var name = error.name || error.constructor.name;
      var stack = extractStackFromError(error);
      return new syncpromise["a" /* SyncPromise */](function (resolve) {
          return parseStack(stack, options).then(function (frames) {
              var result = {
                  stacktrace: {
                      frames: prepareFramesForEvent(frames),
                  },
                  type: name,
                  value: error.message,
              };
              resolve(result);
          });
      });
  }
  /**
   * @hidden
   */
  function parseError(error, options) {
      return new syncpromise["a" /* SyncPromise */](function (resolve) {
          return getExceptionFromError(error, options).then(function (exception) {
              resolve({
                  exception: {
                      values: [exception],
                  },
              });
          });
      });
  }
  /**
   * @hidden
   */
  function prepareFramesForEvent(stack) {
      if (!stack || !stack.length) {
          return [];
      }
      var localStack = stack;
      var firstFrameFunction = localStack[0].function || '';
      if (firstFrameFunction.indexOf('captureMessage') !== -1 || firstFrameFunction.indexOf('captureException') !== -1) {
          localStack = localStack.slice(1);
      }
      // The frame where the crash happened, should be the last entry in the array
      return localStack.reverse();
  }
  //# sourceMappingURL=parsers.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/core/esm/api.js
  
  var SENTRY_API_VERSION = '7';
  /**
   * Helper class to provide urls, headers and metadata that can be used to form
   * different types of requests to Sentry endpoints.
   * Supports both envelopes and regular event requests.
   **/
  var api_API = /** @class */ (function () {
      /** Create a new instance of API */
      function API(dsn, metadata, tunnel) {
          if (metadata === void 0) { metadata = {}; }
          this.dsn = dsn;
          this._dsnObject = new dsn_Dsn(dsn);
          this.metadata = metadata;
          this._tunnel = tunnel;
      }
      /** Returns the Dsn object. */
      API.prototype.getDsn = function () {
          return this._dsnObject;
      };
      /** Does this transport force envelopes? */
      API.prototype.forceEnvelope = function () {
          return !!this._tunnel;
      };
      /** Returns the prefix to construct Sentry ingestion API endpoints. */
      API.prototype.getBaseApiEndpoint = function () {
          var dsn = this.getDsn();
          var protocol = dsn.protocol ? dsn.protocol + ":" : '';
          var port = dsn.port ? ":" + dsn.port : '';
          return protocol + "//" + dsn.host + port + (dsn.path ? "/" + dsn.path : '') + "/api/";
      };
      /** Returns the store endpoint URL. */
      API.prototype.getStoreEndpoint = function () {
          return this._getIngestEndpoint('store');
      };
      /**
       * Returns the store endpoint URL with auth in the query string.
       *
       * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.
       */
      API.prototype.getStoreEndpointWithUrlEncodedAuth = function () {
          return this.getStoreEndpoint() + "?" + this._encodedAuth();
      };
      /**
       * Returns the envelope endpoint URL with auth in the query string.
       *
       * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.
       */
      API.prototype.getEnvelopeEndpointWithUrlEncodedAuth = function () {
          if (this.forceEnvelope()) {
              return this._tunnel;
          }
          return this._getEnvelopeEndpoint() + "?" + this._encodedAuth();
      };
      /** Returns only the path component for the store endpoint. */
      API.prototype.getStoreEndpointPath = function () {
          var dsn = this.getDsn();
          return (dsn.path ? "/" + dsn.path : '') + "/api/" + dsn.projectId + "/store/";
      };
      /**
       * Returns an object that can be used in request headers.
       * This is needed for node and the old /store endpoint in sentry
       */
      API.prototype.getRequestHeaders = function (clientName, clientVersion) {
          // CHANGE THIS to use metadata but keep clientName and clientVersion compatible
          var dsn = this.getDsn();
          var header = ["Sentry sentry_version=" + SENTRY_API_VERSION];
          header.push("sentry_client=" + clientName + "/" + clientVersion);
          header.push("sentry_key=" + dsn.publicKey);
          if (dsn.pass) {
              header.push("sentry_secret=" + dsn.pass);
          }
          return {
              'Content-Type': 'application/json',
              'X-Sentry-Auth': header.join(', '),
          };
      };
      /** Returns the url to the report dialog endpoint. */
      API.prototype.getReportDialogEndpoint = function (dialogOptions) {
          if (dialogOptions === void 0) { dialogOptions = {}; }
          var dsn = this.getDsn();
          var endpoint = this.getBaseApiEndpoint() + "embed/error-page/";
          var encodedOptions = [];
          encodedOptions.push("dsn=" + dsn.toString());
          for (var key in dialogOptions) {
              if (key === 'dsn') {
                  continue;
              }
              if (key === 'user') {
                  if (!dialogOptions.user) {
                      continue;
                  }
                  if (dialogOptions.user.name) {
                      encodedOptions.push("name=" + encodeURIComponent(dialogOptions.user.name));
                  }
                  if (dialogOptions.user.email) {
                      encodedOptions.push("email=" + encodeURIComponent(dialogOptions.user.email));
                  }
              }
              else {
                  encodedOptions.push(encodeURIComponent(key) + "=" + encodeURIComponent(dialogOptions[key]));
              }
          }
          if (encodedOptions.length) {
              return endpoint + "?" + encodedOptions.join('&');
          }
          return endpoint;
      };
      /** Returns the envelope endpoint URL. */
      API.prototype._getEnvelopeEndpoint = function () {
          return this._getIngestEndpoint('envelope');
      };
      /** Returns the ingest API endpoint for target. */
      API.prototype._getIngestEndpoint = function (target) {
          if (this._tunnel) {
              return this._tunnel;
          }
          var base = this.getBaseApiEndpoint();
          var dsn = this.getDsn();
          return "" + base + dsn.projectId + "/" + target + "/";
      };
      /** Returns a URL-encoded string with auth config suitable for a query string. */
      API.prototype._encodedAuth = function () {
          var dsn = this.getDsn();
          var auth = {
              // We send only the minimum set of required information. See
              // https://github.com/getsentry/sentry-javascript/issues/2572.
              sentry_key: dsn.publicKey,
              sentry_version: SENTRY_API_VERSION,
          };
          return Object(object["f" /* urlEncode */])(auth);
      };
      return API;
  }());
  
  //# sourceMappingURL=api.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/promisebuffer.js
  
  
  /** A simple queue that holds promises. */
  var promisebuffer_PromiseBuffer = /** @class */ (function () {
      function PromiseBuffer(_limit) {
          this._limit = _limit;
          /** Internal set of queued Promises */
          this._buffer = [];
      }
      /**
       * Says if the buffer is ready to take more requests
       */
      PromiseBuffer.prototype.isReady = function () {
          return this._limit === undefined || this.length() < this._limit;
      };
      /**
       * Add a promise (representing an in-flight action) to the queue, and set it to remove itself on fulfillment.
       *
       * @param taskProducer A function producing any PromiseLike<T>; In previous versions this used to be `task:
       *        PromiseLike<T>`, but under that model, Promises were instantly created on the call-site and their executor
       *        functions therefore ran immediately. Thus, even if the buffer was full, the action still happened. By
       *        requiring the promise to be wrapped in a function, we can defer promise creation until after the buffer
       *        limit check.
       * @returns The original promise.
       */
      PromiseBuffer.prototype.add = function (taskProducer) {
          var _this = this;
          if (!this.isReady()) {
              return syncpromise["a" /* SyncPromise */].reject(new error_SentryError('Not adding Promise due to buffer limit reached.'));
          }
          // start the task and add its promise to the queue
          var task = taskProducer();
          if (this._buffer.indexOf(task) === -1) {
              this._buffer.push(task);
          }
          void task
              .then(function () { return _this.remove(task); })
              // Use `then(null, rejectionHandler)` rather than `catch(rejectionHandler)` so that we can use `PromiseLike`
              // rather than `Promise`. `PromiseLike` doesn't have a `.catch` method, making its polyfill smaller. (ES5 didn't
              // have promises, so TS has to polyfill when down-compiling.)
              .then(null, function () {
              return _this.remove(task).then(null, function () {
                  // We have to add another catch here because `this.remove()` starts a new promise chain.
              });
          });
          return task;
      };
      /**
       * Remove a promise from the queue.
       *
       * @param task Can be any PromiseLike<T>
       * @returns Removed promise.
       */
      PromiseBuffer.prototype.remove = function (task) {
          var removedTask = this._buffer.splice(this._buffer.indexOf(task), 1)[0];
          return removedTask;
      };
      /**
       * This function returns the number of unresolved promises in the queue.
       */
      PromiseBuffer.prototype.length = function () {
          return this._buffer.length;
      };
      /**
       * Wait for all promises in the queue to resolve or for timeout to expire, whichever comes first.
       *
       * @param timeout The time, in ms, after which to resolve to `false` if the queue is still non-empty. Passing `0` (or
       * not passing anything) will make the promise wait as long as it takes for the queue to drain before resolving to
       * `true`.
       * @returns A promise which will resolve to `true` if the queue is already empty or drains before the timeout, and
       * `false` otherwise
       */
      PromiseBuffer.prototype.drain = function (timeout) {
          var _this = this;
          return new syncpromise["a" /* SyncPromise */](function (resolve) {
              // wait for `timeout` ms and then resolve to `false` (if not cancelled first)
              var capturedSetTimeout = setTimeout(function () {
                  if (timeout && timeout > 0) {
                      resolve(false);
                  }
              }, timeout);
              // if all promises resolve in time, cancel the timer and resolve to `true`
              void syncpromise["a" /* SyncPromise */].all(_this._buffer)
                  .then(function () {
                  clearTimeout(capturedSetTimeout);
                  resolve(true);
              })
                  .then(null, function () {
                  resolve(true);
              });
          });
      };
      return PromiseBuffer;
  }());
  
  //# sourceMappingURL=promisebuffer.js.map
  // EXTERNAL MODULE: external "url"
  var external_url_ = __webpack_require__(23);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/version.js
  // TODO: Remove in the next major release and rely only on @sentry/core SDK_VERSION and SdkMetadata
  var SDK_NAME = 'sentry.javascript.node';
  //# sourceMappingURL=version.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/transports/base/index.js
  
  
  
  
  
  
  
  var CATEGORY_MAPPING = {
      event: 'error',
      transaction: 'transaction',
      session: 'session',
      attachment: 'attachment',
  };
  /** Base Transport class implementation */
  var base_BaseTransport = /** @class */ (function () {
      /** Create instance and set this.dsn */
      function BaseTransport(options) {
          this.options = options;
          /** A simple buffer holding all requests. */
          this._buffer = new promisebuffer_PromiseBuffer(30);
          /** Locks transport after receiving rate limits in a response */
          this._rateLimits = {};
          /** Default function used to parse URLs */
          this.urlParser = function (url) { return new external_url_["URL"](url); };
          this._api = new api_API(options.dsn, options._metadata, options.tunnel);
      }
      /**
       * @inheritDoc
       */
      BaseTransport.prototype.sendEvent = function (_) {
          throw new error_SentryError('Transport Class has to implement `sendEvent` method.');
      };
      /**
       * @inheritDoc
       */
      BaseTransport.prototype.close = function (timeout) {
          return this._buffer.drain(timeout);
      };
      /**
       * Extracts proxy settings from client options and env variables.
       *
       * Honors `no_proxy` env variable with the highest priority to allow for hosts exclusion.
       *
       * An order of priority for available protocols is:
       * `http`  => `options.httpProxy` | `process.env.http_proxy`
       * `https` => `options.httpsProxy` | `options.httpProxy` | `process.env.https_proxy` | `process.env.http_proxy`
       */
      BaseTransport.prototype._getProxy = function (protocol) {
          var e_1, _a;
          var _b = process.env, no_proxy = _b.no_proxy, http_proxy = _b.http_proxy, https_proxy = _b.https_proxy;
          var _c = this.options, httpProxy = _c.httpProxy, httpsProxy = _c.httpsProxy;
          var proxy = protocol === 'http' ? httpProxy || http_proxy : httpsProxy || httpProxy || https_proxy || http_proxy;
          if (!no_proxy) {
              return proxy;
          }
          var _d = this._api.getDsn(), host = _d.host, port = _d.port;
          try {
              for (var _e = __values(no_proxy.split(',')), _f = _e.next(); !_f.done; _f = _e.next()) {
                  var np = _f.value;
                  if (host.endsWith(np) || (host + ":" + port).endsWith(np)) {
                      return;
                  }
              }
          }
          catch (e_1_1) { e_1 = { error: e_1_1 }; }
          finally {
              try {
                  if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
              }
              finally { if (e_1) throw e_1.error; }
          }
          return proxy;
      };
      /** Returns a build request option object used by request */
      BaseTransport.prototype._getRequestOptions = function (urlParts) {
          var headers = __assign(__assign({}, this._api.getRequestHeaders(SDK_NAME, SDK_VERSION)), this.options.headers);
          var hostname = urlParts.hostname, pathname = urlParts.pathname, port = urlParts.port, protocol = urlParts.protocol;
          // See https://github.com/nodejs/node/blob/38146e717fed2fabe3aacb6540d839475e0ce1c6/lib/internal/url.js#L1268-L1290
          // We ignore the query string on purpose
          var path = "" + pathname;
          return __assign({ agent: this.client, headers: headers,
              hostname: hostname, method: 'POST', path: path,
              port: port,
              protocol: protocol }, (this.options.caCerts && {
              ca: external_fs_["readFileSync"](this.options.caCerts),
          }));
      };
      /**
       * Gets the time that given category is disabled until for rate limiting
       */
      BaseTransport.prototype._disabledUntil = function (requestType) {
          var category = CATEGORY_MAPPING[requestType];
          return this._rateLimits[category] || this._rateLimits.all;
      };
      /**
       * Checks if a category is rate limited
       */
      BaseTransport.prototype._isRateLimited = function (requestType) {
          return this._disabledUntil(requestType) > new Date(Date.now());
      };
      /**
       * Sets internal _rateLimits from incoming headers. Returns true if headers contains a non-empty rate limiting header.
       */
      BaseTransport.prototype._handleRateLimit = function (headers) {
          var e_2, _a, e_3, _b;
          var now = Date.now();
          var rlHeader = headers['x-sentry-rate-limits'];
          var raHeader = headers['retry-after'];
          if (rlHeader) {
              try {
                  // rate limit headers are of the form
                  //     <header>,<header>,..
                  // where each <header> is of the form
                  //     <retry_after>: <categories>: <scope>: <reason_code>
                  // where
                  //     <retry_after> is a delay in ms
                  //     <categories> is the event type(s) (error, transaction, etc) being rate limited and is of the form
                  //         <category>;<category>;...
                  //     <scope> is what's being limited (org, project, or key) - ignored by SDK
                  //     <reason_code> is an arbitrary string like "org_quota" - ignored by SDK
                  for (var _c = __values(rlHeader.trim().split(',')), _d = _c.next(); !_d.done; _d = _c.next()) {
                      var limit = _d.value;
                      var parameters = limit.split(':', 2);
                      var headerDelay = parseInt(parameters[0], 10);
                      var delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default
                      try {
                          for (var _e = (e_3 = void 0, __values((parameters[1] && parameters[1].split(';')) || ['all'])), _f = _e.next(); !_f.done; _f = _e.next()) {
                              var category = _f.value;
                              // categoriesAllowed is added here to ensure we are only storing rate limits for categories we support in this
                              // sdk and any categories that are not supported will not be added redundantly to the rateLimits object
                              var categoriesAllowed = __spread(Object.keys(CATEGORY_MAPPING).map(function (k) { return CATEGORY_MAPPING[k]; }), [
                                  'all',
                              ]);
                              if (categoriesAllowed.includes(category))
                                  this._rateLimits[category] = new Date(now + delay);
                          }
                      }
                      catch (e_3_1) { e_3 = { error: e_3_1 }; }
                      finally {
                          try {
                              if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
                          }
                          finally { if (e_3) throw e_3.error; }
                      }
                  }
              }
              catch (e_2_1) { e_2 = { error: e_2_1 }; }
              finally {
                  try {
                      if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
                  }
                  finally { if (e_2) throw e_2.error; }
              }
              return true;
          }
          else if (raHeader) {
              this._rateLimits.all = new Date(now + Object(misc["g" /* parseRetryAfterHeader */])(now, raHeader));
              return true;
          }
          return false;
      };
      /** JSDoc */
      BaseTransport.prototype._send = function (sentryRequest, originalPayload) {
          return __awaiter(this, void 0, void 0, function () {
              var _this = this;
              return __generator(this, function (_a) {
                  if (!this.module) {
                      throw new error_SentryError('No module available');
                  }
                  if (originalPayload && this._isRateLimited(sentryRequest.type)) {
                      return [2 /*return*/, Promise.reject({
                              payload: originalPayload,
                              type: sentryRequest.type,
                              reason: "Transport for " + sentryRequest.type + " requests locked till " + this._disabledUntil(sentryRequest.type) + " due to too many requests.",
                              status: 429,
                          })];
                  }
                  return [2 /*return*/, this._buffer.add(function () {
                          return new Promise(function (resolve, reject) {
                              if (!_this.module) {
                                  throw new error_SentryError('No module available');
                              }
                              var options = _this._getRequestOptions(_this.urlParser(sentryRequest.url));
                              var req = _this.module.request(options, function (res) {
                                  var statusCode = res.statusCode || 500;
                                  var status = Status.fromHttpCode(statusCode);
                                  res.setEncoding('utf8');
                                  /**
                                   * "Key-value pairs of header names and values. Header names are lower-cased."
                                   * https://nodejs.org/api/http.html#http_message_headers
                                   */
                                  var retryAfterHeader = res.headers ? res.headers['retry-after'] : '';
                                  retryAfterHeader = (Array.isArray(retryAfterHeader) ? retryAfterHeader[0] : retryAfterHeader);
                                  var rlHeader = res.headers ? res.headers['x-sentry-rate-limits'] : '';
                                  rlHeader = (Array.isArray(rlHeader) ? rlHeader[0] : rlHeader);
                                  var headers = {
                                      'x-sentry-rate-limits': rlHeader,
                                      'retry-after': retryAfterHeader,
                                  };
                                  var limited = _this._handleRateLimit(headers);
                                  if (limited)
                                      logger["a" /* logger */].warn("Too many " + sentryRequest.type + " requests, backing off until: " + _this._disabledUntil(sentryRequest.type));
                                  if (status === Status.Success) {
                                      resolve({ status: status });
                                  }
                                  else {
                                      var rejectionMessage = "HTTP Error (" + statusCode + ")";
                                      if (res.headers && res.headers['x-sentry-error']) {
                                          rejectionMessage += ": " + res.headers['x-sentry-error'];
                                      }
                                      reject(new error_SentryError(rejectionMessage));
                                  }
                                  // Force the socket to drain
                                  res.on('data', function () {
                                      // Drain
                                  });
                                  res.on('end', function () {
                                      // Drain
                                  });
                              });
                              req.on('error', reject);
                              req.end(sentryRequest.body);
                          });
                      })];
              });
          });
      };
      return BaseTransport;
  }());
  
  //# sourceMappingURL=index.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/core/node_modules/tslib/tslib.es6.js
  /*! *****************************************************************************
  Copyright (c) Microsoft Corporation.
  
  Permission to use, copy, modify, and/or distribute this software for any
  purpose with or without fee is hereby granted.
  
  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  PERFORMANCE OF THIS SOFTWARE.
  ***************************************************************************** */
  /* global Reflect, Promise */
  
  var tslib_tslib_es6_extendStatics = function(d, b) {
      tslib_tslib_es6_extendStatics = Object.setPrototypeOf ||
          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
          function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
      return tslib_tslib_es6_extendStatics(d, b);
  };
  
  function tslib_tslib_es6_extends(d, b) {
      tslib_tslib_es6_extendStatics(d, b);
      function __() { this.constructor = d; }
      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  }
  
  var tslib_tslib_es6_assign = function() {
      tslib_tslib_es6_assign = Object.assign || function __assign(t) {
          for (var s, i = 1, n = arguments.length; i < n; i++) {
              s = arguments[i];
              for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
          }
          return t;
      }
      return tslib_tslib_es6_assign.apply(this, arguments);
  }
  
  function tslib_tslib_es6_rest(s, e) {
      var t = {};
      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
          t[p] = s[p];
      if (s != null && typeof Object.getOwnPropertySymbols === "function")
          for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
              if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                  t[p[i]] = s[p[i]];
          }
      return t;
  }
  
  function tslib_tslib_es6_decorate(decorators, target, key, desc) {
      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
      return c > 3 && r && Object.defineProperty(target, key, r), r;
  }
  
  function tslib_tslib_es6_param(paramIndex, decorator) {
      return function (target, key) { decorator(target, key, paramIndex); }
  }
  
  function tslib_tslib_es6_metadata(metadataKey, metadataValue) {
      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
  }
  
  function tslib_tslib_es6_awaiter(thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  }
  
  function tslib_tslib_es6_generator(thisArg, body) {
      var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
      function verb(n) { return function (v) { return step([n, v]); }; }
      function step(op) {
          if (f) throw new TypeError("Generator is already executing.");
          while (_) try {
              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
              if (y = 0, t) op = [op[0] & 2, t.value];
              switch (op[0]) {
                  case 0: case 1: t = op; break;
                  case 4: _.label++; return { value: op[1], done: false };
                  case 5: _.label++; y = op[1]; op = [0]; continue;
                  case 7: op = _.ops.pop(); _.trys.pop(); continue;
                  default:
                      if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                      if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                      if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                      if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                      if (t[2]) _.ops.pop();
                      _.trys.pop(); continue;
              }
              op = body.call(thisArg, _);
          } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
          if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
      }
  }
  
  function tslib_tslib_es6_createBinding(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }
  
  function tslib_tslib_es6_exportStar(m, exports) {
      for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];
  }
  
  function tslib_tslib_es6_values(o) {
      var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
      if (m) return m.call(o);
      if (o && typeof o.length === "number") return {
          next: function () {
              if (o && i >= o.length) o = void 0;
              return { value: o && o[i++], done: !o };
          }
      };
      throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
  }
  
  function tslib_tslib_es6_read(o, n) {
      var m = typeof Symbol === "function" && o[Symbol.iterator];
      if (!m) return o;
      var i = m.call(o), r, ar = [], e;
      try {
          while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
      }
      catch (error) { e = { error: error }; }
      finally {
          try {
              if (r && !r.done && (m = i["return"])) m.call(i);
          }
          finally { if (e) throw e.error; }
      }
      return ar;
  }
  
  function tslib_tslib_es6_spread() {
      for (var ar = [], i = 0; i < arguments.length; i++)
          ar = ar.concat(tslib_tslib_es6_read(arguments[i]));
      return ar;
  }
  
  function tslib_tslib_es6_spreadArrays() {
      for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
      for (var r = Array(s), k = 0, i = 0; i < il; i++)
          for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
              r[k] = a[j];
      return r;
  };
  
  function tslib_tslib_es6_await(v) {
      return this instanceof tslib_tslib_es6_await ? (this.v = v, this) : new tslib_tslib_es6_await(v);
  }
  
  function tslib_tslib_es6_asyncGenerator(thisArg, _arguments, generator) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var g = generator.apply(thisArg, _arguments || []), i, q = [];
      return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
      function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
      function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
      function step(r) { r.value instanceof tslib_tslib_es6_await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
      function fulfill(value) { resume("next", value); }
      function reject(value) { resume("throw", value); }
      function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
  }
  
  function tslib_tslib_es6_asyncDelegator(o) {
      var i, p;
      return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
      function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: tslib_tslib_es6_await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
  }
  
  function tslib_tslib_es6_asyncValues(o) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var m = o[Symbol.asyncIterator], i;
      return m ? m.call(o) : (o = typeof tslib_tslib_es6_values === "function" ? tslib_tslib_es6_values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
      function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
      function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
  }
  
  function tslib_tslib_es6_makeTemplateObject(cooked, raw) {
      if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
      return cooked;
  };
  
  function tslib_tslib_es6_importStar(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result.default = mod;
      return result;
  }
  
  function tslib_tslib_es6_importDefault(mod) {
      return (mod && mod.__esModule) ? mod : { default: mod };
  }
  
  function tslib_tslib_es6_classPrivateFieldGet(receiver, privateMap) {
      if (!privateMap.has(receiver)) {
          throw new TypeError("attempted to get private field on non-instance");
      }
      return privateMap.get(receiver);
  }
  
  function tslib_tslib_es6_classPrivateFieldSet(receiver, privateMap, value) {
      if (!privateMap.has(receiver)) {
          throw new TypeError("attempted to set private field on non-instance");
      }
      privateMap.set(receiver, value);
      return value;
  }
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/core/esm/request.js
  
  /** Extract sdk info from from the API metadata */
  function getSdkMetadataForEnvelopeHeader(api) {
      if (!api.metadata || !api.metadata.sdk) {
          return;
      }
      var _a = api.metadata.sdk, name = _a.name, version = _a.version;
      return { name: name, version: version };
  }
  /**
   * Apply SdkInfo (name, version, packages, integrations) to the corresponding event key.
   * Merge with existing data if any.
   **/
  function enhanceEventWithSdkInfo(event, sdkInfo) {
      if (!sdkInfo) {
          return event;
      }
      event.sdk = event.sdk || {};
      event.sdk.name = event.sdk.name || sdkInfo.name;
      event.sdk.version = event.sdk.version || sdkInfo.version;
      event.sdk.integrations = tslib_tslib_es6_spread((event.sdk.integrations || []), (sdkInfo.integrations || []));
      event.sdk.packages = tslib_tslib_es6_spread((event.sdk.packages || []), (sdkInfo.packages || []));
      return event;
  }
  /** Creates a SentryRequest from a Session. */
  function sessionToSentryRequest(session, api) {
      var sdkInfo = getSdkMetadataForEnvelopeHeader(api);
      var envelopeHeaders = JSON.stringify(tslib_tslib_es6_assign(tslib_tslib_es6_assign({ sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })), (api.forceEnvelope() && { dsn: api.getDsn().toString() })));
      // I know this is hacky but we don't want to add `session` to request type since it's never rate limited
      var type = 'aggregates' in session ? 'sessions' : 'session';
      var itemHeaders = JSON.stringify({
          type: type,
      });
      return {
          body: envelopeHeaders + "\n" + itemHeaders + "\n" + JSON.stringify(session),
          type: type,
          url: api.getEnvelopeEndpointWithUrlEncodedAuth(),
      };
  }
  /** Creates a SentryRequest from an event. */
  function eventToSentryRequest(event, api) {
      var sdkInfo = getSdkMetadataForEnvelopeHeader(api);
      var eventType = event.type || 'event';
      var useEnvelope = eventType === 'transaction' || api.forceEnvelope();
      var _a = event.debug_meta || {}, transactionSampling = _a.transactionSampling, metadata = tslib_tslib_es6_rest(_a, ["transactionSampling"]);
      var _b = transactionSampling || {}, samplingMethod = _b.method, sampleRate = _b.rate;
      if (Object.keys(metadata).length === 0) {
          delete event.debug_meta;
      }
      else {
          event.debug_meta = metadata;
      }
      var req = {
          body: JSON.stringify(sdkInfo ? enhanceEventWithSdkInfo(event, api.metadata.sdk) : event),
          type: eventType,
          url: useEnvelope ? api.getEnvelopeEndpointWithUrlEncodedAuth() : api.getStoreEndpointWithUrlEncodedAuth(),
      };
      // https://develop.sentry.dev/sdk/envelopes/
      // Since we don't need to manipulate envelopes nor store them, there is no
      // exported concept of an Envelope with operations including serialization and
      // deserialization. Instead, we only implement a minimal subset of the spec to
      // serialize events inline here.
      if (useEnvelope) {
          var envelopeHeaders = JSON.stringify(tslib_tslib_es6_assign(tslib_tslib_es6_assign({ event_id: event.event_id, sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })), (api.forceEnvelope() && { dsn: api.getDsn().toString() })));
          var itemHeaders = JSON.stringify({
              type: eventType,
              // TODO: Right now, sampleRate may or may not be defined (it won't be in the cases of inheritance and
              // explicitly-set sampling decisions). Are we good with that?
              sample_rates: [{ id: samplingMethod, rate: sampleRate }],
          });
          // The trailing newline is optional. We intentionally don't send it to avoid
          // sending unnecessary bytes.
          //
          // const envelope = `${envelopeHeaders}\n${itemHeaders}\n${req.body}\n`;
          var envelope = envelopeHeaders + "\n" + itemHeaders + "\n" + req.body;
          req.body = envelope;
      }
      return req;
  }
  //# sourceMappingURL=request.js.map
  // EXTERNAL MODULE: external "http"
  var external_http_ = __webpack_require__(44);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/transports/http.js
  
  
  
  
  /** Node http module transport */
  var http_HTTPTransport = /** @class */ (function (_super) {
      __extends(HTTPTransport, _super);
      /** Create a new instance and set this.agent */
      function HTTPTransport(options) {
          var _this = _super.call(this, options) || this;
          _this.options = options;
          var proxy = _this._getProxy('http');
          _this.module = external_http_;
          _this.client = proxy
              ? new (__webpack_require__(104))(proxy)
              : new external_http_["Agent"]({ keepAlive: false, maxSockets: 30, timeout: 2000 });
          return _this;
      }
      /**
       * @inheritDoc
       */
      HTTPTransport.prototype.sendEvent = function (event) {
          return this._send(eventToSentryRequest(event, this._api), event);
      };
      /**
       * @inheritDoc
       */
      HTTPTransport.prototype.sendSession = function (session) {
          return this._send(sessionToSentryRequest(session, this._api), session);
      };
      return HTTPTransport;
  }(base_BaseTransport));
  
  //# sourceMappingURL=http.js.map
  // EXTERNAL MODULE: external "https"
  var external_https_ = __webpack_require__(57);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/transports/https.js
  
  
  
  
  /** Node https module transport */
  var https_HTTPSTransport = /** @class */ (function (_super) {
      __extends(HTTPSTransport, _super);
      /** Create a new instance and set this.agent */
      function HTTPSTransport(options) {
          var _this = _super.call(this, options) || this;
          _this.options = options;
          var proxy = _this._getProxy('https');
          _this.module = external_https_;
          _this.client = proxy
              ? new (__webpack_require__(104))(proxy)
              : new external_https_["Agent"]({ keepAlive: false, maxSockets: 30, timeout: 2000 });
          return _this;
      }
      /**
       * @inheritDoc
       */
      HTTPSTransport.prototype.sendEvent = function (event) {
          return this._send(eventToSentryRequest(event, this._api), event);
      };
      /**
       * @inheritDoc
       */
      HTTPSTransport.prototype.sendSession = function (session) {
          return this._send(sessionToSentryRequest(session, this._api), session);
      };
      return HTTPSTransport;
  }(base_BaseTransport));
  
  //# sourceMappingURL=https.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/transports/index.js
  
  
  
  //# sourceMappingURL=index.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/backend.js
  
  
  
  
  
  
  /**
   * The Sentry Node SDK Backend.
   * @hidden
   */
  var backend_NodeBackend = /** @class */ (function (_super) {
      __extends(NodeBackend, _super);
      function NodeBackend() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      /**
       * @inheritDoc
       */
      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
      NodeBackend.prototype.eventFromException = function (exception, hint) {
          var _this = this;
          // eslint-disable-next-line @typescript-eslint/no-explicit-any
          var ex = exception;
          var providedMechanism = hint && hint.data && hint.data.mechanism;
          var mechanism = providedMechanism || {
              handled: true,
              type: 'generic',
          };
          if (!Object(is["b" /* isError */])(exception)) {
              if (Object(is["e" /* isPlainObject */])(exception)) {
                  // This will allow us to group events based on top-level keys
                  // which is much better than creating new group when any key/value change
                  var message = "Non-Error exception captured with keys: " + Object(object["b" /* extractExceptionKeysForMessage */])(exception);
                  Object(esm_hub["b" /* getCurrentHub */])().configureScope(function (scope) {
                      scope.setExtra('__serialized__', Object(object["e" /* normalizeToSize */])(exception));
                  });
                  ex = (hint && hint.syntheticException) || new Error(message);
                  ex.message = message;
              }
              else {
                  // This handles when someone does: `throw "something awesome";`
                  // We use synthesized Error here so we can extract a (rough) stack trace.
                  ex = (hint && hint.syntheticException) || new Error(exception);
                  ex.message = exception;
              }
              mechanism.synthetic = true;
          }
          return new syncpromise["a" /* SyncPromise */](function (resolve, reject) {
              return parseError(ex, _this._options)
                  .then(function (event) {
                  Object(misc["c" /* addExceptionTypeValue */])(event, undefined, undefined);
                  Object(misc["b" /* addExceptionMechanism */])(event, mechanism);
                  resolve(__assign(__assign({}, event), { event_id: hint && hint.event_id }));
              })
                  .then(null, reject);
          });
      };
      /**
       * @inheritDoc
       */
      NodeBackend.prototype.eventFromMessage = function (message, level, hint) {
          var _this = this;
          if (level === void 0) { level = Severity.Info; }
          var event = {
              event_id: hint && hint.event_id,
              level: level,
              message: message,
          };
          return new syncpromise["a" /* SyncPromise */](function (resolve) {
              if (_this._options.attachStacktrace && hint && hint.syntheticException) {
                  var stack = hint.syntheticException ? extractStackFromError(hint.syntheticException) : [];
                  void parseStack(stack, _this._options)
                      .then(function (frames) {
                      event.stacktrace = {
                          frames: prepareFramesForEvent(frames),
                      };
                      resolve(event);
                  })
                      .then(null, function () {
                      resolve(event);
                  });
              }
              else {
                  resolve(event);
              }
          });
      };
      /**
       * @inheritDoc
       */
      NodeBackend.prototype._setupTransport = function () {
          if (!this._options.dsn) {
              // We return the noop transport here in case there is no Dsn.
              return _super.prototype._setupTransport.call(this);
          }
          var dsn = new dsn_Dsn(this._options.dsn);
          var transportOptions = __assign(__assign(__assign(__assign(__assign({}, this._options.transportOptions), (this._options.httpProxy && { httpProxy: this._options.httpProxy })), (this._options.httpsProxy && { httpsProxy: this._options.httpsProxy })), (this._options.caCerts && { caCerts: this._options.caCerts })), { dsn: this._options.dsn, tunnel: this._options.tunnel, _metadata: this._options._metadata });
          if (this._options.transport) {
              return new this._options.transport(transportOptions);
          }
          if (dsn.protocol === 'http') {
              return new http_HTTPTransport(transportOptions);
          }
          return new https_HTTPSTransport(transportOptions);
      };
      return NodeBackend;
  }(basebackend_BaseBackend));
  
  //# sourceMappingURL=backend.js.map
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/types/esm/session.js
  var esm_session = __webpack_require__(316);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/types/esm/transport.js
  var esm_transport = __webpack_require__(196);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/time.js
  var time = __webpack_require__(37);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/string.js
  var string = __webpack_require__(30);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/core/esm/integration.js
  
  
  
  var installedIntegrations = [];
  /**
   * @private
   */
  function filterDuplicates(integrations) {
      return integrations.reduce(function (acc, integrations) {
          if (acc.every(function (accIntegration) { return integrations.name !== accIntegration.name; })) {
              acc.push(integrations);
          }
          return acc;
      }, []);
  }
  /** Gets integration to install */
  function getIntegrationsToSetup(options) {
      var defaultIntegrations = (options.defaultIntegrations && tslib_tslib_es6_spread(options.defaultIntegrations)) || [];
      var userIntegrations = options.integrations;
      var integrations = tslib_tslib_es6_spread(filterDuplicates(defaultIntegrations));
      if (Array.isArray(userIntegrations)) {
          // Filter out integrations that are also included in user options
          integrations = tslib_tslib_es6_spread(integrations.filter(function (integrations) {
              return userIntegrations.every(function (userIntegration) { return userIntegration.name !== integrations.name; });
          }), filterDuplicates(userIntegrations));
      }
      else if (typeof userIntegrations === 'function') {
          integrations = userIntegrations(integrations);
          integrations = Array.isArray(integrations) ? integrations : [integrations];
      }
      // Make sure that if present, `Debug` integration will always run last
      var integrationsNames = integrations.map(function (i) { return i.name; });
      var alwaysLastToRun = 'Debug';
      if (integrationsNames.indexOf(alwaysLastToRun) !== -1) {
          integrations.push.apply(integrations, tslib_tslib_es6_spread(integrations.splice(integrationsNames.indexOf(alwaysLastToRun), 1)));
      }
      return integrations;
  }
  /** Setup given integration */
  function setupIntegration(integration) {
      if (installedIntegrations.indexOf(integration.name) !== -1) {
          return;
      }
      integration.setupOnce(esm_scope["b" /* addGlobalEventProcessor */], esm_hub["b" /* getCurrentHub */]);
      installedIntegrations.push(integration.name);
      logger["a" /* logger */].log("Integration installed: " + integration.name);
  }
  /**
   * Given a list of integration instances this installs them all. When `withDefaults` is set to `true` then all default
   * integrations are added unless they were already provided before.
   * @param integrations array of integration instances
   * @param withDefault should enable default integrations
   */
  function setupIntegrations(options) {
      var integrations = {};
      getIntegrationsToSetup(options).forEach(function (integration) {
          integrations[integration.name] = integration;
          setupIntegration(integration);
      });
      // set the `initialized` flag so we don't run through the process again unecessarily; use `Object.defineProperty`
      // because by default it creates a property which is nonenumerable, which we want since `initialized` shouldn't be
      // considered a member of the index the way the actual integrations are
      Object.defineProperty(integrations, 'initialized', { value: true });
      return integrations;
  }
  //# sourceMappingURL=integration.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/core/esm/baseclient.js
  
  /* eslint-disable max-lines */
  
  
  
  
  /**
   * Base implementation for all JavaScript SDK clients.
   *
   * Call the constructor with the corresponding backend constructor and options
   * specific to the client subclass. To access these options later, use
   * {@link Client.getOptions}. Also, the Backend instance is available via
   * {@link Client.getBackend}.
   *
   * If a Dsn is specified in the options, it will be parsed and stored. Use
   * {@link Client.getDsn} to retrieve the Dsn at any moment. In case the Dsn is
   * invalid, the constructor will throw a {@link SentryException}. Note that
   * without a valid Dsn, the SDK will not send any events to Sentry.
   *
   * Before sending an event via the backend, it is passed through
   * {@link BaseClient._prepareEvent} to add SDK information and scope data
   * (breadcrumbs and context). To add more custom information, override this
   * method and extend the resulting prepared event.
   *
   * To issue automatically created events (e.g. via instrumentation), use
   * {@link Client.captureEvent}. It will prepare the event and pass it through
   * the callback lifecycle. To issue auto-breadcrumbs, use
   * {@link Client.addBreadcrumb}.
   *
   * @example
   * class NodeClient extends BaseClient<NodeBackend, NodeOptions> {
   *   public constructor(options: NodeOptions) {
   *     super(NodeBackend, options);
   *   }
   *
   *   // ...
   * }
   */
  var baseclient_BaseClient = /** @class */ (function () {
      /**
       * Initializes this client instance.
       *
       * @param backendClass A constructor function to create the backend.
       * @param options Options for the client.
       */
      function BaseClient(backendClass, options) {
          /** Array of used integrations. */
          this._integrations = {};
          /** Number of calls being processed */
          this._numProcessing = 0;
          this._backend = new backendClass(options);
          this._options = options;
          if (options.dsn) {
              this._dsn = new dsn_Dsn(options.dsn);
          }
      }
      /**
       * @inheritDoc
       */
      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
      BaseClient.prototype.captureException = function (exception, hint, scope) {
          var _this = this;
          var eventId = hint && hint.event_id;
          this._process(this._getBackend()
              .eventFromException(exception, hint)
              .then(function (event) { return _this._captureEvent(event, hint, scope); })
              .then(function (result) {
              eventId = result;
          }));
          return eventId;
      };
      /**
       * @inheritDoc
       */
      BaseClient.prototype.captureMessage = function (message, level, hint, scope) {
          var _this = this;
          var eventId = hint && hint.event_id;
          var promisedEvent = Object(is["f" /* isPrimitive */])(message)
              ? this._getBackend().eventFromMessage(String(message), level, hint)
              : this._getBackend().eventFromException(message, hint);
          this._process(promisedEvent
              .then(function (event) { return _this._captureEvent(event, hint, scope); })
              .then(function (result) {
              eventId = result;
          }));
          return eventId;
      };
      /**
       * @inheritDoc
       */
      BaseClient.prototype.captureEvent = function (event, hint, scope) {
          var eventId = hint && hint.event_id;
          this._process(this._captureEvent(event, hint, scope).then(function (result) {
              eventId = result;
          }));
          return eventId;
      };
      /**
       * @inheritDoc
       */
      BaseClient.prototype.captureSession = function (session) {
          if (!this._isEnabled()) {
              logger["a" /* logger */].warn('SDK not enabled, will not capture session.');
              return;
          }
          if (!(typeof session.release === 'string')) {
              logger["a" /* logger */].warn('Discarded session because of missing or non-string release');
          }
          else {
              this._sendSession(session);
              // After sending, we set init false to indicate it's not the first occurrence
              session.update({ init: false });
          }
      };
      /**
       * @inheritDoc
       */
      BaseClient.prototype.getDsn = function () {
          return this._dsn;
      };
      /**
       * @inheritDoc
       */
      BaseClient.prototype.getOptions = function () {
          return this._options;
      };
      /**
       * @inheritDoc
       */
      BaseClient.prototype.getTransport = function () {
          return this._getBackend().getTransport();
      };
      /**
       * @inheritDoc
       */
      BaseClient.prototype.flush = function (timeout) {
          var _this = this;
          return this._isClientDoneProcessing(timeout).then(function (clientFinished) {
              return _this.getTransport()
                  .close(timeout)
                  .then(function (transportFlushed) { return clientFinished && transportFlushed; });
          });
      };
      /**
       * @inheritDoc
       */
      BaseClient.prototype.close = function (timeout) {
          var _this = this;
          return this.flush(timeout).then(function (result) {
              _this.getOptions().enabled = false;
              return result;
          });
      };
      /**
       * Sets up the integrations
       */
      BaseClient.prototype.setupIntegrations = function () {
          if (this._isEnabled() && !this._integrations.initialized) {
              this._integrations = setupIntegrations(this._options);
          }
      };
      /**
       * @inheritDoc
       */
      BaseClient.prototype.getIntegration = function (integration) {
          try {
              return this._integrations[integration.id] || null;
          }
          catch (_oO) {
              logger["a" /* logger */].warn("Cannot retrieve integration " + integration.id + " from the current Client");
              return null;
          }
      };
      /** Updates existing session based on the provided event */
      BaseClient.prototype._updateSessionFromEvent = function (session, event) {
          var e_1, _a;
          var crashed = false;
          var errored = false;
          var exceptions = event.exception && event.exception.values;
          if (exceptions) {
              errored = true;
              try {
                  for (var exceptions_1 = tslib_tslib_es6_values(exceptions), exceptions_1_1 = exceptions_1.next(); !exceptions_1_1.done; exceptions_1_1 = exceptions_1.next()) {
                      var ex = exceptions_1_1.value;
                      var mechanism = ex.mechanism;
                      if (mechanism && mechanism.handled === false) {
                          crashed = true;
                          break;
                      }
                  }
              }
              catch (e_1_1) { e_1 = { error: e_1_1 }; }
              finally {
                  try {
                      if (exceptions_1_1 && !exceptions_1_1.done && (_a = exceptions_1.return)) _a.call(exceptions_1);
                  }
                  finally { if (e_1) throw e_1.error; }
              }
          }
          // A session is updated and that session update is sent in only one of the two following scenarios:
          // 1. Session with non terminal status and 0 errors + an error occurred -> Will set error count to 1 and send update
          // 2. Session with non terminal status and 1 error + a crash occurred -> Will set status crashed and send update
          var sessionNonTerminal = session.status === esm_session["b" /* SessionStatus */].Ok;
          var shouldUpdateAndSend = (sessionNonTerminal && session.errors === 0) || (sessionNonTerminal && crashed);
          if (shouldUpdateAndSend) {
              session.update(tslib_tslib_es6_assign(tslib_tslib_es6_assign({}, (crashed && { status: esm_session["b" /* SessionStatus */].Crashed })), { errors: session.errors || Number(errored || crashed) }));
              this.captureSession(session);
          }
      };
      /** Deliver captured session to Sentry */
      BaseClient.prototype._sendSession = function (session) {
          this._getBackend().sendSession(session);
      };
      /**
       * Determine if the client is finished processing. Returns a promise because it will wait `timeout` ms before saying
       * "no" (resolving to `false`) in order to give the client a chance to potentially finish first.
       *
       * @param timeout The time, in ms, after which to resolve to `false` if the client is still busy. Passing `0` (or not
       * passing anything) will make the promise wait as long as it takes for processing to finish before resolving to
       * `true`.
       * @returns A promise which will resolve to `true` if processing is already done or finishes before the timeout, and
       * `false` otherwise
       */
      BaseClient.prototype._isClientDoneProcessing = function (timeout) {
          var _this = this;
          return new syncpromise["a" /* SyncPromise */](function (resolve) {
              var ticked = 0;
              var tick = 1;
              var interval = setInterval(function () {
                  if (_this._numProcessing == 0) {
                      clearInterval(interval);
                      resolve(true);
                  }
                  else {
                      ticked += tick;
                      if (timeout && ticked >= timeout) {
                          clearInterval(interval);
                          resolve(false);
                      }
                  }
              }, tick);
          });
      };
      /** Returns the current backend. */
      BaseClient.prototype._getBackend = function () {
          return this._backend;
      };
      /** Determines whether this SDK is enabled and a valid Dsn is present. */
      BaseClient.prototype._isEnabled = function () {
          return this.getOptions().enabled !== false && this._dsn !== undefined;
      };
      /**
       * Adds common information to events.
       *
       * The information includes release and environment from `options`,
       * breadcrumbs and context (extra, tags and user) from the scope.
       *
       * Information that is already present in the event is never overwritten. For
       * nested objects, such as the context, keys are merged.
       *
       * @param event The original event.
       * @param hint May contain additional information about the original exception.
       * @param scope A scope containing event metadata.
       * @returns A new event with more information.
       */
      BaseClient.prototype._prepareEvent = function (event, scope, hint) {
          var _this = this;
          var _a = this.getOptions().normalizeDepth, normalizeDepth = _a === void 0 ? 3 : _a;
          var prepared = tslib_tslib_es6_assign(tslib_tslib_es6_assign({}, event), { event_id: event.event_id || (hint && hint.event_id ? hint.event_id : Object(misc["j" /* uuid4 */])()), timestamp: event.timestamp || Object(time["b" /* dateTimestampInSeconds */])() });
          this._applyClientOptions(prepared);
          this._applyIntegrationsMetadata(prepared);
          // If we have scope given to us, use it as the base for further modifications.
          // This allows us to prevent unnecessary copying of data if `captureContext` is not provided.
          var finalScope = scope;
          if (hint && hint.captureContext) {
              finalScope = esm_scope["a" /* Scope */].clone(finalScope).update(hint.captureContext);
          }
          // We prepare the result here with a resolved Event.
          var result = syncpromise["a" /* SyncPromise */].resolve(prepared);
          // This should be the last thing called, since we want that
          // {@link Hub.addEventProcessor} gets the finished prepared event.
          if (finalScope) {
              // In case we have a hub we reassign it.
              result = finalScope.applyToEvent(prepared, hint);
          }
          return result.then(function (evt) {
              if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {
                  return _this._normalizeEvent(evt, normalizeDepth);
              }
              return evt;
          });
      };
      /**
       * Applies `normalize` function on necessary `Event` attributes to make them safe for serialization.
       * Normalized keys:
       * - `breadcrumbs.data`
       * - `user`
       * - `contexts`
       * - `extra`
       * @param event Event
       * @returns Normalized event
       */
      BaseClient.prototype._normalizeEvent = function (event, depth) {
          if (!event) {
              return null;
          }
          var normalized = tslib_tslib_es6_assign(tslib_tslib_es6_assign(tslib_tslib_es6_assign(tslib_tslib_es6_assign(tslib_tslib_es6_assign({}, event), (event.breadcrumbs && {
              breadcrumbs: event.breadcrumbs.map(function (b) { return (tslib_tslib_es6_assign(tslib_tslib_es6_assign({}, b), (b.data && {
                  data: Object(object["d" /* normalize */])(b.data, depth),
              }))); }),
          })), (event.user && {
              user: Object(object["d" /* normalize */])(event.user, depth),
          })), (event.contexts && {
              contexts: Object(object["d" /* normalize */])(event.contexts, depth),
          })), (event.extra && {
              extra: Object(object["d" /* normalize */])(event.extra, depth),
          }));
          // event.contexts.trace stores information about a Transaction. Similarly,
          // event.spans[] stores information about child Spans. Given that a
          // Transaction is conceptually a Span, normalization should apply to both
          // Transactions and Spans consistently.
          // For now the decision is to skip normalization of Transactions and Spans,
          // so this block overwrites the normalized event to add back the original
          // Transaction information prior to normalization.
          if (event.contexts && event.contexts.trace) {
              // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
              normalized.contexts.trace = event.contexts.trace;
          }
          var _a = this.getOptions()._experiments, _experiments = _a === void 0 ? {} : _a;
          if (_experiments.ensureNoCircularStructures) {
              return Object(object["d" /* normalize */])(normalized);
          }
          return normalized;
      };
      /**
       *  Enhances event using the client configuration.
       *  It takes care of all "static" values like environment, release and `dist`,
       *  as well as truncating overly long values.
       * @param event event instance to be enhanced
       */
      BaseClient.prototype._applyClientOptions = function (event) {
          var options = this.getOptions();
          var environment = options.environment, release = options.release, dist = options.dist, _a = options.maxValueLength, maxValueLength = _a === void 0 ? 250 : _a;
          if (!('environment' in event)) {
              event.environment = 'environment' in options ? environment : 'production';
          }
          if (event.release === undefined && release !== undefined) {
              event.release = release;
          }
          if (event.dist === undefined && dist !== undefined) {
              event.dist = dist;
          }
          if (event.message) {
              event.message = Object(string["c" /* truncate */])(event.message, maxValueLength);
          }
          var exception = event.exception && event.exception.values && event.exception.values[0];
          if (exception && exception.value) {
              exception.value = Object(string["c" /* truncate */])(exception.value, maxValueLength);
          }
          var request = event.request;
          if (request && request.url) {
              request.url = Object(string["c" /* truncate */])(request.url, maxValueLength);
          }
      };
      /**
       * This function adds all used integrations to the SDK info in the event.
       * @param event The event that will be filled with all integrations.
       */
      BaseClient.prototype._applyIntegrationsMetadata = function (event) {
          var integrationsArray = Object.keys(this._integrations);
          if (integrationsArray.length > 0) {
              event.sdk = event.sdk || {};
              event.sdk.integrations = tslib_tslib_es6_spread((event.sdk.integrations || []), integrationsArray);
          }
      };
      /**
       * Tells the backend to send this event
       * @param event The Sentry event to send
       */
      BaseClient.prototype._sendEvent = function (event) {
          this._getBackend().sendEvent(event);
      };
      /**
       * Processes the event and logs an error in case of rejection
       * @param event
       * @param hint
       * @param scope
       */
      BaseClient.prototype._captureEvent = function (event, hint, scope) {
          return this._processEvent(event, hint, scope).then(function (finalEvent) {
              return finalEvent.event_id;
          }, function (reason) {
              logger["a" /* logger */].error(reason);
              return undefined;
          });
      };
      /**
       * Processes an event (either error or message) and sends it to Sentry.
       *
       * This also adds breadcrumbs and context information to the event. However,
       * platform specific meta data (such as the User's IP address) must be added
       * by the SDK implementor.
       *
       *
       * @param event The event to send to Sentry.
       * @param hint May contain additional information about the original exception.
       * @param scope A scope containing event metadata.
       * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.
       */
      BaseClient.prototype._processEvent = function (event, hint, scope) {
          var _this = this;
          var _a, _b;
          // eslint-disable-next-line @typescript-eslint/unbound-method
          var _c = this.getOptions(), beforeSend = _c.beforeSend, sampleRate = _c.sampleRate;
          var transport = this.getTransport();
          if (!this._isEnabled()) {
              return syncpromise["a" /* SyncPromise */].reject(new error_SentryError('SDK not enabled, will not capture event.'));
          }
          var isTransaction = event.type === 'transaction';
          // 1.0 === 100% events are sent
          // 0.0 === 0% events are sent
          // Sampling for transaction happens somewhere else
          if (!isTransaction && typeof sampleRate === 'number' && Math.random() > sampleRate) {
              (_b = (_a = transport).recordLostEvent) === null || _b === void 0 ? void 0 : _b.call(_a, esm_transport["a" /* Outcome */].SampleRate, 'event');
              return syncpromise["a" /* SyncPromise */].reject(new error_SentryError("Discarding event because it's not included in the random sample (sampling rate = " + sampleRate + ")"));
          }
          return this._prepareEvent(event, scope, hint)
              .then(function (prepared) {
              var _a, _b;
              if (prepared === null) {
                  (_b = (_a = transport).recordLostEvent) === null || _b === void 0 ? void 0 : _b.call(_a, esm_transport["a" /* Outcome */].EventProcessor, event.type || 'event');
                  throw new error_SentryError('An event processor returned null, will not send event.');
              }
              var isInternalException = hint && hint.data && hint.data.__sentry__ === true;
              if (isInternalException || isTransaction || !beforeSend) {
                  return prepared;
              }
              var beforeSendResult = beforeSend(prepared, hint);
              return _this._ensureBeforeSendRv(beforeSendResult);
          })
              .then(function (processedEvent) {
              var _a, _b;
              if (processedEvent === null) {
                  (_b = (_a = transport).recordLostEvent) === null || _b === void 0 ? void 0 : _b.call(_a, esm_transport["a" /* Outcome */].BeforeSend, event.type || 'event');
                  throw new error_SentryError('`beforeSend` returned `null`, will not send event.');
              }
              var session = scope && scope.getSession && scope.getSession();
              if (!isTransaction && session) {
                  _this._updateSessionFromEvent(session, processedEvent);
              }
              _this._sendEvent(processedEvent);
              return processedEvent;
          })
              .then(null, function (reason) {
              if (reason instanceof error_SentryError) {
                  throw reason;
              }
              _this.captureException(reason, {
                  data: {
                      __sentry__: true,
                  },
                  originalException: reason,
              });
              throw new error_SentryError("Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\nReason: " + reason);
          });
      };
      /**
       * Occupies the client with processing and event
       */
      BaseClient.prototype._process = function (promise) {
          var _this = this;
          this._numProcessing += 1;
          void promise.then(function (value) {
              _this._numProcessing -= 1;
              return value;
          }, function (reason) {
              _this._numProcessing -= 1;
              return reason;
          });
      };
      /**
       * Verifies that return value of configured `beforeSend` is of expected type.
       */
      BaseClient.prototype._ensureBeforeSendRv = function (rv) {
          var nullErr = '`beforeSend` method has to return `null` or a valid event.';
          if (Object(is["j" /* isThenable */])(rv)) {
              return rv.then(function (event) {
                  if (!(Object(is["e" /* isPlainObject */])(event) || event === null)) {
                      throw new error_SentryError(nullErr);
                  }
                  return event;
              }, function (e) {
                  throw new error_SentryError("beforeSend rejected with " + e);
              });
          }
          else if (!(Object(is["e" /* isPlainObject */])(rv) || rv === null)) {
              throw new error_SentryError(nullErr);
          }
          return rv;
      };
      return BaseClient;
  }());
  
  //# sourceMappingURL=baseclient.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/hub/esm/sessionflusher.js
  
  
  
  /**
   * @inheritdoc
   */
  var sessionflusher_SessionFlusher = /** @class */ (function () {
      function SessionFlusher(transport, attrs) {
          var _this = this;
          this.flushTimeout = 60;
          this._pendingAggregates = {};
          this._isEnabled = true;
          this._transport = transport;
          // Call to setInterval, so that flush is called every 60 seconds
          this._intervalId = setInterval(function () { return _this.flush(); }, this.flushTimeout * 1000);
          this._sessionAttrs = attrs;
      }
      /** Sends session aggregates to Transport */
      SessionFlusher.prototype.sendSessionAggregates = function (sessionAggregates) {
          if (!this._transport.sendSession) {
              logger["a" /* logger */].warn("Dropping session because custom transport doesn't implement sendSession");
              return;
          }
          void this._transport.sendSession(sessionAggregates).then(null, function (reason) {
              logger["a" /* logger */].error("Error while sending session: " + reason);
          });
      };
      /** Checks if `pendingAggregates` has entries, and if it does flushes them by calling `sendSessions` */
      SessionFlusher.prototype.flush = function () {
          var sessionAggregates = this.getSessionAggregates();
          if (sessionAggregates.aggregates.length === 0) {
              return;
          }
          this._pendingAggregates = {};
          this.sendSessionAggregates(sessionAggregates);
      };
      /** Massages the entries in `pendingAggregates` and returns aggregated sessions */
      SessionFlusher.prototype.getSessionAggregates = function () {
          var _this = this;
          var aggregates = Object.keys(this._pendingAggregates).map(function (key) {
              return _this._pendingAggregates[parseInt(key)];
          });
          var sessionAggregates = {
              attrs: this._sessionAttrs,
              aggregates: aggregates,
          };
          return Object(object["a" /* dropUndefinedKeys */])(sessionAggregates);
      };
      /** JSDoc */
      SessionFlusher.prototype.close = function () {
          clearInterval(this._intervalId);
          this._isEnabled = false;
          this.flush();
      };
      /**
       * Wrapper function for _incrementSessionStatusCount that checks if the instance of SessionFlusher is enabled then
       * fetches the session status of the request from `Scope.getRequestSession().status` on the scope and passes them to
       * `_incrementSessionStatusCount` along with the start date
       */
      SessionFlusher.prototype.incrementSessionStatusCount = function () {
          var _a, _b;
          if (!this._isEnabled) {
              return;
          }
          var scope = Object(esm_hub["b" /* getCurrentHub */])().getScope();
          var requestSession = (_a = scope) === null || _a === void 0 ? void 0 : _a.getRequestSession();
          if (requestSession && requestSession.status) {
              this._incrementSessionStatusCount(requestSession.status, new Date());
              // This is not entirely necessarily but is added as a safe guard to indicate the bounds of a request and so in
              // case captureRequestSession is called more than once to prevent double count
              (_b = scope) === null || _b === void 0 ? void 0 : _b.setRequestSession(undefined);
              /* eslint-enable @typescript-eslint/no-unsafe-member-access */
          }
      };
      /**
       * Increments status bucket in pendingAggregates buffer (internal state) corresponding to status of
       * the session received
       */
      SessionFlusher.prototype._incrementSessionStatusCount = function (status, date) {
          // Truncate minutes and seconds on Session Started attribute to have one minute bucket keys
          var sessionStartedTrunc = new Date(date).setSeconds(0, 0);
          this._pendingAggregates[sessionStartedTrunc] = this._pendingAggregates[sessionStartedTrunc] || {};
          // corresponds to aggregated sessions in one specific minute bucket
          // for example, {"started":"2021-03-16T08:00:00.000Z","exited":4, "errored": 1}
          var aggregationCounts = this._pendingAggregates[sessionStartedTrunc];
          if (!aggregationCounts.started) {
              aggregationCounts.started = new Date(sessionStartedTrunc).toISOString();
          }
          switch (status) {
              case esm_session["a" /* RequestSessionStatus */].Errored:
                  aggregationCounts.errored = (aggregationCounts.errored || 0) + 1;
                  return aggregationCounts.errored;
              case esm_session["a" /* RequestSessionStatus */].Ok:
                  aggregationCounts.exited = (aggregationCounts.exited || 0) + 1;
                  return aggregationCounts.exited;
              case esm_session["a" /* RequestSessionStatus */].Crashed:
                  aggregationCounts.crashed = (aggregationCounts.crashed || 0) + 1;
                  return aggregationCounts.crashed;
          }
      };
      return SessionFlusher;
  }());
  
  //# sourceMappingURL=sessionflusher.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/client.js
  
  
  
  
  
  
  /**
   * The Sentry Node SDK Client.
   *
   * @see NodeOptions for documentation on configuration options.
   * @see SentryClient for usage documentation.
   */
  var client_NodeClient = /** @class */ (function (_super) {
      __extends(NodeClient, _super);
      /**
       * Creates a new Node SDK instance.
       * @param options Configuration options for this SDK.
       */
      function NodeClient(options) {
          var _this = this;
          options._metadata = options._metadata || {};
          options._metadata.sdk = options._metadata.sdk || {
              name: 'sentry.javascript.node',
              packages: [
                  {
                      name: 'npm:@sentry/node',
                      version: SDK_VERSION,
                  },
              ],
              version: SDK_VERSION,
          };
          _this = _super.call(this, backend_NodeBackend, options) || this;
          return _this;
      }
      /**
       * @inheritDoc
       */
      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
      NodeClient.prototype.captureException = function (exception, hint, scope) {
          // Check if the flag `autoSessionTracking` is enabled, and if `_sessionFlusher` exists because it is initialised only
          // when the `requestHandler` middleware is used, and hence the expectation is to have SessionAggregates payload
          // sent to the Server only when the `requestHandler` middleware is used
          if (this._options.autoSessionTracking && this._sessionFlusher && scope) {
              var requestSession = scope.getRequestSession();
              // Necessary checks to ensure this is code block is executed only within a request
              // Should override the status only if `requestSession.status` is `Ok`, which is its initial stage
              if (requestSession && requestSession.status === esm_session["a" /* RequestSessionStatus */].Ok) {
                  requestSession.status = esm_session["a" /* RequestSessionStatus */].Errored;
              }
          }
          return _super.prototype.captureException.call(this, exception, hint, scope);
      };
      /**
       * @inheritDoc
       */
      NodeClient.prototype.captureEvent = function (event, hint, scope) {
          // Check if the flag `autoSessionTracking` is enabled, and if `_sessionFlusher` exists because it is initialised only
          // when the `requestHandler` middleware is used, and hence the expectation is to have SessionAggregates payload
          // sent to the Server only when the `requestHandler` middleware is used
          if (this._options.autoSessionTracking && this._sessionFlusher && scope) {
              var eventType = event.type || 'exception';
              var isException = eventType === 'exception' && event.exception && event.exception.values && event.exception.values.length > 0;
              // If the event is of type Exception, then a request session should be captured
              if (isException) {
                  var requestSession = scope.getRequestSession();
                  // Ensure that this is happening within the bounds of a request, and make sure not to override
                  // Session Status if Errored / Crashed
                  if (requestSession && requestSession.status === esm_session["a" /* RequestSessionStatus */].Ok) {
                      requestSession.status = esm_session["a" /* RequestSessionStatus */].Errored;
                  }
              }
          }
          return _super.prototype.captureEvent.call(this, event, hint, scope);
      };
      /**
       *
       * @inheritdoc
       */
      NodeClient.prototype.close = function (timeout) {
          var _a;
          (_a = this._sessionFlusher) === null || _a === void 0 ? void 0 : _a.close();
          return _super.prototype.close.call(this, timeout);
      };
      /** Method that initialises an instance of SessionFlusher on Client */
      NodeClient.prototype.initSessionFlusher = function () {
          var _a = this._options, release = _a.release, environment = _a.environment;
          if (!release) {
              logger["a" /* logger */].warn('Cannot initialise an instance of SessionFlusher if no release is provided!');
          }
          else {
              this._sessionFlusher = new sessionflusher_SessionFlusher(this.getTransport(), {
                  release: release,
                  environment: environment,
              });
          }
      };
      /**
       * @inheritDoc
       */
      NodeClient.prototype._prepareEvent = function (event, scope, hint) {
          event.platform = event.platform || 'node';
          if (this.getOptions().serverName) {
              event.server_name = this.getOptions().serverName;
          }
          return _super.prototype._prepareEvent.call(this, event, scope, hint);
      };
      /**
       * Method responsible for capturing/ending a request session by calling `incrementSessionStatusCount` to increment
       * appropriate session aggregates bucket
       */
      NodeClient.prototype._captureRequestSession = function () {
          if (!this._sessionFlusher) {
              logger["a" /* logger */].warn('Discarded request mode session because autoSessionTracking option was disabled');
          }
          else {
              this._sessionFlusher.incrementSessionStatusCount();
          }
      };
      return NodeClient;
  }(baseclient_BaseClient));
  
  //# sourceMappingURL=client.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/core/esm/integrations/functiontostring.js
  var originalFunctionToString;
  /** Patch toString calls to return proper name for wrapped functions */
  var FunctionToString = /** @class */ (function () {
      function FunctionToString() {
          /**
           * @inheritDoc
           */
          this.name = FunctionToString.id;
      }
      /**
       * @inheritDoc
       */
      FunctionToString.prototype.setupOnce = function () {
          // eslint-disable-next-line @typescript-eslint/unbound-method
          originalFunctionToString = Function.prototype.toString;
          // eslint-disable-next-line @typescript-eslint/no-explicit-any
          Function.prototype.toString = function () {
              var args = [];
              for (var _i = 0; _i < arguments.length; _i++) {
                  args[_i] = arguments[_i];
              }
              var context = this.__sentry_original__ || this;
              return originalFunctionToString.apply(context, args);
          };
      };
      /**
       * @inheritDoc
       */
      FunctionToString.id = 'FunctionToString';
      return FunctionToString;
  }());
  
  //# sourceMappingURL=functiontostring.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/core/esm/integrations/inboundfilters.js
  
  
  
  // "Script error." is hard coded into browsers for errors that it can't read.
  // this is the result of a script being pulled in from an external domain and CORS.
  var DEFAULT_IGNORE_ERRORS = [/^Script error\.?$/, /^Javascript error: Script error\.? on line 0$/];
  /** Inbound filters configurable by the user */
  var inboundfilters_InboundFilters = /** @class */ (function () {
      function InboundFilters(_options) {
          if (_options === void 0) { _options = {}; }
          this._options = _options;
          /**
           * @inheritDoc
           */
          this.name = InboundFilters.id;
      }
      /**
       * @inheritDoc
       */
      InboundFilters.prototype.setupOnce = function () {
          Object(esm_scope["b" /* addGlobalEventProcessor */])(function (event) {
              var hub = Object(esm_hub["b" /* getCurrentHub */])();
              if (!hub) {
                  return event;
              }
              var self = hub.getIntegration(InboundFilters);
              if (self) {
                  var client = hub.getClient();
                  var clientOptions = client ? client.getOptions() : {};
                  // This checks prevents most of the occurrences of the bug linked below:
                  // https://github.com/getsentry/sentry-javascript/issues/2622
                  // The bug is caused by multiple SDK instances, where one is minified and one is using non-mangled code.
                  // Unfortunatelly we cannot fix it reliably (thus reserved property in rollup's terser config),
                  // as we cannot force people using multiple instances in their apps to sync SDK versions.
                  var options = typeof self._mergeOptions === 'function' ? self._mergeOptions(clientOptions) : {};
                  if (typeof self._shouldDropEvent !== 'function') {
                      return event;
                  }
                  return self._shouldDropEvent(event, options) ? null : event;
              }
              return event;
          });
      };
      /** JSDoc */
      InboundFilters.prototype._shouldDropEvent = function (event, options) {
          if (this._isSentryError(event, options)) {
              logger["a" /* logger */].warn("Event dropped due to being internal Sentry Error.\nEvent: " + Object(misc["e" /* getEventDescription */])(event));
              return true;
          }
          if (this._isIgnoredError(event, options)) {
              logger["a" /* logger */].warn("Event dropped due to being matched by `ignoreErrors` option.\nEvent: " + Object(misc["e" /* getEventDescription */])(event));
              return true;
          }
          if (this._isDeniedUrl(event, options)) {
              logger["a" /* logger */].warn("Event dropped due to being matched by `denyUrls` option.\nEvent: " + Object(misc["e" /* getEventDescription */])(event) + ".\nUrl: " + this._getEventFilterUrl(event));
              return true;
          }
          if (!this._isAllowedUrl(event, options)) {
              logger["a" /* logger */].warn("Event dropped due to not being matched by `allowUrls` option.\nEvent: " + Object(misc["e" /* getEventDescription */])(event) + ".\nUrl: " + this._getEventFilterUrl(event));
              return true;
          }
          return false;
      };
      /** JSDoc */
      InboundFilters.prototype._isSentryError = function (event, options) {
          if (!options.ignoreInternal) {
              return false;
          }
          try {
              return ((event &&
                  event.exception &&
                  event.exception.values &&
                  event.exception.values[0] &&
                  event.exception.values[0].type === 'SentryError') ||
                  false);
          }
          catch (_oO) {
              return false;
          }
      };
      /** JSDoc */
      InboundFilters.prototype._isIgnoredError = function (event, options) {
          if (!options.ignoreErrors || !options.ignoreErrors.length) {
              return false;
          }
          return this._getPossibleEventMessages(event).some(function (message) {
              // Not sure why TypeScript complains here...
              return options.ignoreErrors.some(function (pattern) { return Object(string["a" /* isMatchingPattern */])(message, pattern); });
          });
      };
      /** JSDoc */
      InboundFilters.prototype._isDeniedUrl = function (event, options) {
          // TODO: Use Glob instead?
          if (!options.denyUrls || !options.denyUrls.length) {
              return false;
          }
          var url = this._getEventFilterUrl(event);
          return !url ? false : options.denyUrls.some(function (pattern) { return Object(string["a" /* isMatchingPattern */])(url, pattern); });
      };
      /** JSDoc */
      InboundFilters.prototype._isAllowedUrl = function (event, options) {
          // TODO: Use Glob instead?
          if (!options.allowUrls || !options.allowUrls.length) {
              return true;
          }
          var url = this._getEventFilterUrl(event);
          return !url ? true : options.allowUrls.some(function (pattern) { return Object(string["a" /* isMatchingPattern */])(url, pattern); });
      };
      /** JSDoc */
      InboundFilters.prototype._mergeOptions = function (clientOptions) {
          if (clientOptions === void 0) { clientOptions = {}; }
          return {
              allowUrls: tslib_tslib_es6_spread((this._options.whitelistUrls || []), (this._options.allowUrls || []), (clientOptions.whitelistUrls || []), (clientOptions.allowUrls || [])),
              denyUrls: tslib_tslib_es6_spread((this._options.blacklistUrls || []), (this._options.denyUrls || []), (clientOptions.blacklistUrls || []), (clientOptions.denyUrls || [])),
              ignoreErrors: tslib_tslib_es6_spread((this._options.ignoreErrors || []), (clientOptions.ignoreErrors || []), DEFAULT_IGNORE_ERRORS),
              ignoreInternal: typeof this._options.ignoreInternal !== 'undefined' ? this._options.ignoreInternal : true,
          };
      };
      /** JSDoc */
      InboundFilters.prototype._getPossibleEventMessages = function (event) {
          if (event.message) {
              return [event.message];
          }
          if (event.exception) {
              try {
                  var _a = (event.exception.values && event.exception.values[0]) || {}, _b = _a.type, type = _b === void 0 ? '' : _b, _c = _a.value, value = _c === void 0 ? '' : _c;
                  return ["" + value, type + ": " + value];
              }
              catch (oO) {
                  logger["a" /* logger */].error("Cannot extract message for event " + Object(misc["e" /* getEventDescription */])(event));
                  return [];
              }
          }
          return [];
      };
      /** JSDoc */
      InboundFilters.prototype._getLastValidUrl = function (frames) {
          if (frames === void 0) { frames = []; }
          var _a, _b;
          for (var i = frames.length - 1; i >= 0; i--) {
              var frame = frames[i];
              if (((_a = frame) === null || _a === void 0 ? void 0 : _a.filename) !== '<anonymous>' && ((_b = frame) === null || _b === void 0 ? void 0 : _b.filename) !== '[native code]') {
                  return frame.filename || null;
              }
          }
          return null;
      };
      /** JSDoc */
      InboundFilters.prototype._getEventFilterUrl = function (event) {
          try {
              if (event.stacktrace) {
                  var frames_1 = event.stacktrace.frames;
                  return this._getLastValidUrl(frames_1);
              }
              if (event.exception) {
                  var frames_2 = event.exception.values && event.exception.values[0].stacktrace && event.exception.values[0].stacktrace.frames;
                  return this._getLastValidUrl(frames_2);
              }
              return null;
          }
          catch (oO) {
              logger["a" /* logger */].error("Cannot extract url for event " + Object(misc["e" /* getEventDescription */])(event));
              return null;
          }
      };
      /**
       * @inheritDoc
       */
      InboundFilters.id = 'InboundFilters';
      return InboundFilters;
  }());
  
  //# sourceMappingURL=inboundfilters.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/core/esm/integrations/index.js
  
  
  //# sourceMappingURL=index.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/core/esm/index.js
  
  
  
  
  
  
  
  
  
  
  
  //# sourceMappingURL=index.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/core/esm/sdk.js
  
  
  /**
   * Internal function to create a new SDK client instance. The client is
   * installed and then bound to the current scope.
   *
   * @param clientClass The client class to instantiate.
   * @param options Options to pass to the client.
   */
  function initAndBind(clientClass, options) {
      var _a;
      if (options.debug === true) {
          logger["a" /* logger */].enable();
      }
      var hub = Object(esm_hub["b" /* getCurrentHub */])();
      (_a = hub.getScope()) === null || _a === void 0 ? void 0 : _a.update(options.initialScope);
      var client = new clientClass(options);
      hub.bindClient(client);
  }
  //# sourceMappingURL=sdk.js.map
  // EXTERNAL MODULE: external "domain"
  var external_domain_ = __webpack_require__(36);
  
  // EXTERNAL MODULE: external "util"
  var external_util_ = __webpack_require__(19);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/integrations/console.js
  
  
  
  
  
  /** Console module integration */
  var console_Console = /** @class */ (function () {
      function Console() {
          /**
           * @inheritDoc
           */
          this.name = Console.id;
      }
      /**
       * @inheritDoc
       */
      Console.prototype.setupOnce = function () {
          var e_1, _a;
          try {
              for (var _b = __values(['debug', 'info', 'warn', 'error', 'log']), _c = _b.next(); !_c.done; _c = _b.next()) {
                  var level = _c.value;
                  Object(object["c" /* fill */])(console, level, createConsoleWrapper(level));
              }
          }
          catch (e_1_1) { e_1 = { error: e_1_1 }; }
          finally {
              try {
                  if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
              }
              finally { if (e_1) throw e_1.error; }
          }
      };
      /**
       * @inheritDoc
       */
      Console.id = 'Console';
      return Console;
  }());
  
  /**
   * Wrapper function that'll be used for every console level
   */
  function createConsoleWrapper(level) {
      return function consoleWrapper(originalConsoleMethod) {
          var sentryLevel;
          switch (level) {
              case 'debug':
                  sentryLevel = Severity.Debug;
                  break;
              case 'error':
                  sentryLevel = Severity.Error;
                  break;
              case 'info':
                  sentryLevel = Severity.Info;
                  break;
              case 'warn':
                  sentryLevel = Severity.Warning;
                  break;
              default:
                  sentryLevel = Severity.Log;
          }
          return function () {
              if (Object(esm_hub["b" /* getCurrentHub */])().getIntegration(console_Console)) {
                  Object(esm_hub["b" /* getCurrentHub */])().addBreadcrumb({
                      category: 'console',
                      level: sentryLevel,
                      message: external_util_["format"].apply(undefined, arguments),
                  }, {
                      input: __spread(arguments),
                      level: level,
                  });
              }
              originalConsoleMethod.apply(this, arguments);
          };
      };
  }
  //# sourceMappingURL=console.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/integrations/utils/http.js
  
  
  
  /**
   * Checks whether given url points to Sentry server
   * @param url url to verify
   */
  function isSentryRequest(url) {
      var _a;
      var dsn = (_a = Object(esm_hub["b" /* getCurrentHub */])()
          .getClient()) === null || _a === void 0 ? void 0 : _a.getDsn();
      return dsn ? url.includes(dsn.host) : false;
  }
  /**
   * Assemble a URL to be used for breadcrumbs and spans.
   *
   * @param requestOptions RequestOptions object containing the component parts for a URL
   * @returns Fully-formed URL
   */
  function extractUrl(requestOptions) {
      var protocol = requestOptions.protocol || '';
      var hostname = requestOptions.hostname || requestOptions.host || '';
      // Don't log standard :80 (http) and :443 (https) ports to reduce the noise
      var port = !requestOptions.port || requestOptions.port === 80 || requestOptions.port === 443 ? '' : ":" + requestOptions.port;
      var path = requestOptions.path ? requestOptions.path : '/';
      return protocol + "//" + hostname + port + path;
  }
  /**
   * Handle various edge cases in the span description (for spans representing http(s) requests).
   *
   * @param description current `description` property of the span representing the request
   * @param requestOptions Configuration data for the request
   * @param Request Request object
   *
   * @returns The cleaned description
   */
  function cleanSpanDescription(description, requestOptions, request) {
      var _a, _b, _c;
      // nothing to clean
      if (!description) {
          return description;
      }
      // eslint-disable-next-line prefer-const
      var _d = __read(description.split(' '), 2), method = _d[0], requestUrl = _d[1];
      // superagent sticks the protocol in a weird place (we check for host because if both host *and* protocol are missing,
      // we're likely dealing with an internal route and this doesn't apply)
      if (requestOptions.host && !requestOptions.protocol) {
          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
          requestOptions.protocol = (_b = (_a = request) === null || _a === void 0 ? void 0 : _a.agent) === null || _b === void 0 ? void 0 : _b.protocol; // worst comes to worst, this is undefined and nothing changes
          requestUrl = extractUrl(requestOptions);
      }
      // internal routes can end up starting with a triple slash rather than a single one
      if ((_c = requestUrl) === null || _c === void 0 ? void 0 : _c.startsWith('///')) {
          requestUrl = requestUrl.slice(2);
      }
      return method + " " + requestUrl;
  }
  /**
   * Convert a URL object into a RequestOptions object.
   *
   * Copied from Node's internals (where it's used in http(s).request() and http(s).get()), modified only to use the
   * RequestOptions type above.
   *
   * See https://github.com/nodejs/node/blob/master/lib/internal/url.js.
   */
  function urlToOptions(url) {
      var options = {
          protocol: url.protocol,
          hostname: typeof url.hostname === 'string' && url.hostname.startsWith('[') ? url.hostname.slice(1, -1) : url.hostname,
          hash: url.hash,
          search: url.search,
          pathname: url.pathname,
          path: "" + (url.pathname || '') + (url.search || ''),
          href: url.href,
      };
      if (url.port !== '') {
          options.port = Number(url.port);
      }
      if (url.username || url.password) {
          options.auth = url.username + ":" + url.password;
      }
      return options;
  }
  /**
   * Normalize inputs to `http(s).request()` and `http(s).get()`.
   *
   * Legal inputs to `http(s).request()` and `http(s).get()` can take one of ten forms:
   *     [ RequestOptions | string | URL ],
   *     [ RequestOptions | string | URL, RequestCallback ],
   *     [ string | URL, RequestOptions ], and
   *     [ string | URL, RequestOptions, RequestCallback ].
   *
   * This standardizes to one of two forms: [ RequestOptions ] and [ RequestOptions, RequestCallback ]. A similar thing is
   * done as the first step of `http(s).request()` and `http(s).get()`; this just does it early so that we can interact
   * with the args in a standard way.
   *
   * @param requestArgs The inputs to `http(s).request()` or `http(s).get()`, as an array.
   *
   * @returns Equivalent args of the form [ RequestOptions ] or [ RequestOptions, RequestCallback ].
   */
  function normalizeRequestArgs(httpModule, requestArgs) {
      var _a, _b, _c;
      var callback, requestOptions;
      // pop off the callback, if there is one
      if (typeof requestArgs[requestArgs.length - 1] === 'function') {
          callback = requestArgs.pop();
      }
      // create a RequestOptions object of whatever's at index 0
      if (typeof requestArgs[0] === 'string') {
          requestOptions = urlToOptions(new external_url_["URL"](requestArgs[0]));
      }
      else if (requestArgs[0] instanceof external_url_["URL"]) {
          requestOptions = urlToOptions(requestArgs[0]);
      }
      else {
          requestOptions = requestArgs[0];
      }
      // if the options were given separately from the URL, fold them in
      if (requestArgs.length === 2) {
          requestOptions = __assign(__assign({}, requestOptions), requestArgs[1]);
      }
      // Figure out the protocol if it's currently missing
      if (requestOptions.protocol === undefined) {
          // Worst case we end up populating protocol with undefined, which it already is
          /* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any */
          requestOptions.protocol =
              ((_a = requestOptions.agent) === null || _a === void 0 ? void 0 : _a.protocol) || ((_b = requestOptions._defaultAgent) === null || _b === void 0 ? void 0 : _b.protocol) || ((_c = httpModule.globalAgent) === null || _c === void 0 ? void 0 : _c.protocol);
          /* eslint-enable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any */
      }
      // return args in standardized form
      if (callback) {
          return [requestOptions, callback];
      }
      else {
          return [requestOptions];
      }
  }
  //# sourceMappingURL=http.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/integrations/http.js
  
  
  
  
  var NODE_VERSION = Object(misc["h" /* parseSemver */])(process.versions.node);
  /** http module integration */
  var http_Http = /** @class */ (function () {
      /**
       * @inheritDoc
       */
      function Http(options) {
          if (options === void 0) { options = {}; }
          /**
           * @inheritDoc
           */
          this.name = Http.id;
          this._breadcrumbs = typeof options.breadcrumbs === 'undefined' ? true : options.breadcrumbs;
          this._tracing = typeof options.tracing === 'undefined' ? false : options.tracing;
      }
      /**
       * @inheritDoc
       */
      Http.prototype.setupOnce = function () {
          // No need to instrument if we don't want to track anything
          if (!this._breadcrumbs && !this._tracing) {
              return;
          }
          var wrappedHandlerMaker = _createWrappedRequestMethodFactory(this._breadcrumbs, this._tracing);
          var httpModule = __webpack_require__(44);
          Object(object["c" /* fill */])(httpModule, 'get', wrappedHandlerMaker);
          Object(object["c" /* fill */])(httpModule, 'request', wrappedHandlerMaker);
          // NOTE: Prior to Node 9, `https` used internals of `http` module, thus we don't patch it.
          // If we do, we'd get double breadcrumbs and double spans for `https` calls.
          // It has been changed in Node 9, so for all versions equal and above, we patch `https` separately.
          if (NODE_VERSION.major && NODE_VERSION.major > 8) {
              var httpsModule = __webpack_require__(57);
              Object(object["c" /* fill */])(httpsModule, 'get', wrappedHandlerMaker);
              Object(object["c" /* fill */])(httpsModule, 'request', wrappedHandlerMaker);
          }
      };
      /**
       * @inheritDoc
       */
      Http.id = 'Http';
      return Http;
  }());
  
  /**
   * Function which creates a function which creates wrapped versions of internal `request` and `get` calls within `http`
   * and `https` modules. (NB: Not a typo - this is a creator^2!)
   *
   * @param breadcrumbsEnabled Whether or not to record outgoing requests as breadcrumbs
   * @param tracingEnabled Whether or not to record outgoing requests as tracing spans
   *
   * @returns A function which accepts the exiting handler and returns a wrapped handler
   */
  function _createWrappedRequestMethodFactory(breadcrumbsEnabled, tracingEnabled) {
      return function wrappedRequestMethodFactory(originalRequestMethod) {
          return function wrappedMethod() {
              var args = [];
              for (var _i = 0; _i < arguments.length; _i++) {
                  args[_i] = arguments[_i];
              }
              // eslint-disable-next-line @typescript-eslint/no-this-alias
              var httpModule = this;
              var requestArgs = normalizeRequestArgs(this, args);
              var requestOptions = requestArgs[0];
              var requestUrl = extractUrl(requestOptions);
              // we don't want to record requests to Sentry as either breadcrumbs or spans, so just use the original method
              if (isSentryRequest(requestUrl)) {
                  return originalRequestMethod.apply(httpModule, requestArgs);
              }
              var span;
              var parentSpan;
              var scope = Object(esm_hub["b" /* getCurrentHub */])().getScope();
              if (scope && tracingEnabled) {
                  parentSpan = scope.getSpan();
                  if (parentSpan) {
                      span = parentSpan.startChild({
                          description: (requestOptions.method || 'GET') + " " + requestUrl,
                          op: 'request',
                      });
                      var sentryTraceHeader = span.toTraceparent();
                      logger["a" /* logger */].log("[Tracing] Adding sentry-trace header " + sentryTraceHeader + " to outgoing request to " + requestUrl + ": ");
                      requestOptions.headers = __assign(__assign({}, requestOptions.headers), { 'sentry-trace': sentryTraceHeader });
                  }
              }
              // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
              return originalRequestMethod
                  .apply(httpModule, requestArgs)
                  .once('response', function (res) {
                  // eslint-disable-next-line @typescript-eslint/no-this-alias
                  var req = this;
                  if (breadcrumbsEnabled) {
                      addRequestBreadcrumb('response', requestUrl, req, res);
                  }
                  if (tracingEnabled && span) {
                      if (res.statusCode) {
                          span.setHttpStatus(res.statusCode);
                      }
                      span.description = cleanSpanDescription(span.description, requestOptions, req);
                      span.finish();
                  }
              })
                  .once('error', function () {
                  // eslint-disable-next-line @typescript-eslint/no-this-alias
                  var req = this;
                  if (breadcrumbsEnabled) {
                      addRequestBreadcrumb('error', requestUrl, req);
                  }
                  if (tracingEnabled && span) {
                      span.setHttpStatus(500);
                      span.description = cleanSpanDescription(span.description, requestOptions, req);
                      span.finish();
                  }
              });
          };
      };
  }
  /**
   * Captures Breadcrumb based on provided request/response pair
   */
  function addRequestBreadcrumb(event, url, req, res) {
      if (!Object(esm_hub["b" /* getCurrentHub */])().getIntegration(http_Http)) {
          return;
      }
      Object(esm_hub["b" /* getCurrentHub */])().addBreadcrumb({
          category: 'http',
          data: {
              method: req.method,
              status_code: res && res.statusCode,
              url: url,
          },
          type: 'http',
      }, {
          event: event,
          request: req,
          response: res,
      });
  }
  //# sourceMappingURL=http.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/async.js
  /**
   * Consumes the promise and logs the error when it rejects.
   * @param promise A promise to forget.
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function forget(promise) {
      void promise.then(null, function (e) {
          // TODO: Use a better logging mechanism
          // eslint-disable-next-line no-console
          console.error(e);
      });
  }
  //# sourceMappingURL=async.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/integrations/utils/errorhandling.js
  
  
  var DEFAULT_SHUTDOWN_TIMEOUT = 2000;
  /**
   * @hidden
   */
  function logAndExitProcess(error) {
      // eslint-disable-next-line no-console
      console.error(error && error.stack ? error.stack : error);
      var client = Object(esm_hub["b" /* getCurrentHub */])().getClient();
      if (client === undefined) {
          logger["a" /* logger */].warn('No NodeClient was defined, we are exiting the process now.');
          global.process.exit(1);
          return;
      }
      var options = client.getOptions();
      var timeout = (options && options.shutdownTimeout && options.shutdownTimeout > 0 && options.shutdownTimeout) ||
          DEFAULT_SHUTDOWN_TIMEOUT;
      forget(client.close(timeout).then(function (result) {
          if (!result) {
              logger["a" /* logger */].warn('We reached the timeout for emptying the request buffer, still exiting now!');
          }
          global.process.exit(1);
      }));
  }
  //# sourceMappingURL=errorhandling.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/integrations/onuncaughtexception.js
  
  
  
  
  /** Global Promise Rejection handler */
  var onuncaughtexception_OnUncaughtException = /** @class */ (function () {
      /**
       * @inheritDoc
       */
      function OnUncaughtException(_options) {
          if (_options === void 0) { _options = {}; }
          this._options = _options;
          /**
           * @inheritDoc
           */
          this.name = OnUncaughtException.id;
          /**
           * @inheritDoc
           */
          this.handler = this._makeErrorHandler();
      }
      /**
       * @inheritDoc
       */
      OnUncaughtException.prototype.setupOnce = function () {
          global.process.on('uncaughtException', this.handler.bind(this));
      };
      /**
       * @hidden
       */
      OnUncaughtException.prototype._makeErrorHandler = function () {
          var _this = this;
          var timeout = 2000;
          var caughtFirstError = false;
          var caughtSecondError = false;
          var calledFatalError = false;
          var firstError;
          return function (error) {
              var onFatalError = logAndExitProcess;
              var client = Object(esm_hub["b" /* getCurrentHub */])().getClient();
              if (_this._options.onFatalError) {
                  // eslint-disable-next-line @typescript-eslint/unbound-method
                  onFatalError = _this._options.onFatalError;
              }
              else if (client && client.getOptions().onFatalError) {
                  // eslint-disable-next-line @typescript-eslint/unbound-method
                  onFatalError = client.getOptions().onFatalError;
              }
              if (!caughtFirstError) {
                  var hub_1 = Object(esm_hub["b" /* getCurrentHub */])();
                  // this is the first uncaught error and the ultimate reason for shutting down
                  // we want to do absolutely everything possible to ensure it gets captured
                  // also we want to make sure we don't go recursion crazy if more errors happen after this one
                  firstError = error;
                  caughtFirstError = true;
                  if (hub_1.getIntegration(OnUncaughtException)) {
                      hub_1.withScope(function (scope) {
                          scope.setLevel(Severity.Fatal);
                          hub_1.captureException(error, {
                              originalException: error,
                              data: { mechanism: { handled: false, type: 'onuncaughtexception' } },
                          });
                          if (!calledFatalError) {
                              calledFatalError = true;
                              onFatalError(error);
                          }
                      });
                  }
                  else {
                      if (!calledFatalError) {
                          calledFatalError = true;
                          onFatalError(error);
                      }
                  }
              }
              else if (calledFatalError) {
                  // we hit an error *after* calling onFatalError - pretty boned at this point, just shut it down
                  logger["a" /* logger */].warn('uncaught exception after calling fatal error shutdown callback - this is bad! forcing shutdown');
                  logAndExitProcess(error);
              }
              else if (!caughtSecondError) {
                  // two cases for how we can hit this branch:
                  //   - capturing of first error blew up and we just caught the exception from that
                  //     - quit trying to capture, proceed with shutdown
                  //   - a second independent error happened while waiting for first error to capture
                  //     - want to avoid causing premature shutdown before first error capture finishes
                  // it's hard to immediately tell case 1 from case 2 without doing some fancy/questionable domain stuff
                  // so let's instead just delay a bit before we proceed with our action here
                  // in case 1, we just wait a bit unnecessarily but ultimately do the same thing
                  // in case 2, the delay hopefully made us wait long enough for the capture to finish
                  // two potential nonideal outcomes:
                  //   nonideal case 1: capturing fails fast, we sit around for a few seconds unnecessarily before proceeding correctly by calling onFatalError
                  //   nonideal case 2: case 2 happens, 1st error is captured but slowly, timeout completes before capture and we treat second error as the sendErr of (nonexistent) failure from trying to capture first error
                  // note that after hitting this branch, we might catch more errors where (caughtSecondError && !calledFatalError)
                  //   we ignore them - they don't matter to us, we're just waiting for the second error timeout to finish
                  caughtSecondError = true;
                  setTimeout(function () {
                      if (!calledFatalError) {
                          // it was probably case 1, let's treat err as the sendErr and call onFatalError
                          calledFatalError = true;
                          onFatalError(firstError, error);
                      }
                      else {
                          // it was probably case 2, our first error finished capturing while we waited, cool, do nothing
                      }
                  }, timeout); // capturing could take at least sendTimeout to fail, plus an arbitrary second for how long it takes to collect surrounding source etc
              }
          };
      };
      /**
       * @inheritDoc
       */
      OnUncaughtException.id = 'OnUncaughtException';
      return OnUncaughtException;
  }());
  
  //# sourceMappingURL=onuncaughtexception.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/integrations/onunhandledrejection.js
  
  
  
  /** Global Promise Rejection handler */
  var onunhandledrejection_OnUnhandledRejection = /** @class */ (function () {
      /**
       * @inheritDoc
       */
      function OnUnhandledRejection(_options) {
          if (_options === void 0) { _options = { mode: 'warn' }; }
          this._options = _options;
          /**
           * @inheritDoc
           */
          this.name = OnUnhandledRejection.id;
      }
      /**
       * @inheritDoc
       */
      OnUnhandledRejection.prototype.setupOnce = function () {
          global.process.on('unhandledRejection', this.sendUnhandledPromise.bind(this));
      };
      /**
       * Send an exception with reason
       * @param reason string
       * @param promise promise
       */
      // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
      OnUnhandledRejection.prototype.sendUnhandledPromise = function (reason, promise) {
          var hub = Object(esm_hub["b" /* getCurrentHub */])();
          if (!hub.getIntegration(OnUnhandledRejection)) {
              this._handleRejection(reason);
              return;
          }
          /* eslint-disable @typescript-eslint/no-unsafe-member-access */
          var context = (promise.domain && promise.domain.sentryContext) || {};
          hub.withScope(function (scope) {
              scope.setExtra('unhandledPromiseRejection', true);
              // Preserve backwards compatibility with raven-node for now
              if (context.user) {
                  scope.setUser(context.user);
              }
              if (context.tags) {
                  scope.setTags(context.tags);
              }
              if (context.extra) {
                  scope.setExtras(context.extra);
              }
              hub.captureException(reason, {
                  originalException: promise,
                  data: { mechanism: { handled: false, type: 'onunhandledrejection' } },
              });
          });
          /* eslint-disable @typescript-eslint/no-unsafe-member-access */
          this._handleRejection(reason);
      };
      /**
       * Handler for `mode` option
       */
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      OnUnhandledRejection.prototype._handleRejection = function (reason) {
          // https://github.com/nodejs/node/blob/7cf6f9e964aa00772965391c23acda6d71972a9a/lib/internal/process/promises.js#L234-L240
          var rejectionWarning = 'This error originated either by ' +
              'throwing inside of an async function without a catch block, ' +
              'or by rejecting a promise which was not handled with .catch().' +
              ' The promise rejected with the reason:';
          /* eslint-disable no-console */
          if (this._options.mode === 'warn') {
              Object(misc["d" /* consoleSandbox */])(function () {
                  console.warn(rejectionWarning);
                  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                  console.error(reason && reason.stack ? reason.stack : reason);
              });
          }
          else if (this._options.mode === 'strict') {
              Object(misc["d" /* consoleSandbox */])(function () {
                  console.warn(rejectionWarning);
              });
              logAndExitProcess(reason);
          }
          /* eslint-enable no-console */
      };
      /**
       * @inheritDoc
       */
      OnUnhandledRejection.id = 'OnUnhandledRejection';
      return OnUnhandledRejection;
  }());
  
  //# sourceMappingURL=onunhandledrejection.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/integrations/linkederrors.js
  
  
  
  
  var DEFAULT_KEY = 'cause';
  var DEFAULT_LIMIT = 5;
  /** Adds SDK info to an event. */
  var linkederrors_LinkedErrors = /** @class */ (function () {
      /**
       * @inheritDoc
       */
      function LinkedErrors(options) {
          if (options === void 0) { options = {}; }
          /**
           * @inheritDoc
           */
          this.name = LinkedErrors.id;
          this._key = options.key || DEFAULT_KEY;
          this._limit = options.limit || DEFAULT_LIMIT;
      }
      /**
       * @inheritDoc
       */
      LinkedErrors.prototype.setupOnce = function () {
          Object(esm_scope["b" /* addGlobalEventProcessor */])(function (event, hint) {
              var self = Object(esm_hub["b" /* getCurrentHub */])().getIntegration(LinkedErrors);
              if (self) {
                  var handler = self._handler && self._handler.bind(self);
                  return typeof handler === 'function' ? handler(event, hint) : event;
              }
              return event;
          });
      };
      /**
       * @inheritDoc
       */
      LinkedErrors.prototype._handler = function (event, hint) {
          var _this = this;
          if (!event.exception || !event.exception.values || !hint || !Object(is["d" /* isInstanceOf */])(hint.originalException, Error)) {
              return syncpromise["a" /* SyncPromise */].resolve(event);
          }
          return new syncpromise["a" /* SyncPromise */](function (resolve) {
              void _this._walkErrorTree(hint.originalException, _this._key)
                  .then(function (linkedErrors) {
                  if (event && event.exception && event.exception.values) {
                      event.exception.values = __spread(linkedErrors, event.exception.values);
                  }
                  resolve(event);
              })
                  .then(null, function () {
                  resolve(event);
              });
          });
      };
      /**
       * @inheritDoc
       */
      LinkedErrors.prototype._walkErrorTree = function (error, key, stack) {
          var _this = this;
          if (stack === void 0) { stack = []; }
          if (!Object(is["d" /* isInstanceOf */])(error[key], Error) || stack.length + 1 >= this._limit) {
              return syncpromise["a" /* SyncPromise */].resolve(stack);
          }
          return new syncpromise["a" /* SyncPromise */](function (resolve, reject) {
              void getExceptionFromError(error[key])
                  .then(function (exception) {
                  void _this._walkErrorTree(error[key], key, __spread([exception], stack))
                      .then(resolve)
                      .then(null, function () {
                      reject();
                  });
              })
                  .then(null, function () {
                  reject();
              });
          });
      };
      /**
       * @inheritDoc
       */
      LinkedErrors.id = 'LinkedErrors';
      return LinkedErrors;
  }());
  
  //# sourceMappingURL=linkederrors.js.map
  // EXTERNAL MODULE: external "path"
  var external_path_ = __webpack_require__(21);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/integrations/modules.js
  
  
  
  var moduleCache;
  /** Extract information about paths */
  function getPaths() {
      try {
          return __webpack_require__.c ? Object.keys(__webpack_require__.c) : [];
      }
      catch (e) {
          return [];
      }
  }
  /** Extract information about package.json modules */
  function collectModules() {
      var mainPaths = (__webpack_require__.c[__webpack_require__.s] && __webpack_require__.c[__webpack_require__.s].paths) || [];
      var paths = getPaths();
      var infos = {};
      var seen = {};
      paths.forEach(function (path) {
          var dir = path;
          /** Traverse directories upward in the search of package.json file */
          var updir = function () {
              var orig = dir;
              dir = Object(external_path_["dirname"])(orig);
              if (!dir || orig === dir || seen[orig]) {
                  return undefined;
              }
              if (mainPaths.indexOf(dir) < 0) {
                  return updir();
              }
              var pkgfile = Object(external_path_["join"])(orig, 'package.json');
              seen[orig] = true;
              if (!Object(external_fs_["existsSync"])(pkgfile)) {
                  return updir();
              }
              try {
                  var info = JSON.parse(Object(external_fs_["readFileSync"])(pkgfile, 'utf8'));
                  infos[info.name] = info.version;
              }
              catch (_oO) {
                  // no-empty
              }
          };
          updir();
      });
      return infos;
  }
  /** Add node modules / packages to the event */
  var modules_Modules = /** @class */ (function () {
      function Modules() {
          /**
           * @inheritDoc
           */
          this.name = Modules.id;
      }
      /**
       * @inheritDoc
       */
      Modules.prototype.setupOnce = function (addGlobalEventProcessor, getCurrentHub) {
          var _this = this;
          addGlobalEventProcessor(function (event) {
              if (!getCurrentHub().getIntegration(Modules)) {
                  return event;
              }
              return __assign(__assign({}, event), { modules: _this._getModules() });
          });
      };
      /** Fetches the list of modules and the versions loaded by the entry file for your node.js app. */
      Modules.prototype._getModules = function () {
          if (!moduleCache) {
              moduleCache = collectModules();
          }
          return moduleCache;
      };
      /**
       * @inheritDoc
       */
      Modules.id = 'Modules';
      return Modules;
  }());
  
  //# sourceMappingURL=modules.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/integrations/index.js
  
  
  
  
  
  
  //# sourceMappingURL=index.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/sdk.js
  
  
  
  
  
  
  
  
  var sdk_defaultIntegrations = [
      // Common
      new integrations_namespaceObject.InboundFilters(),
      new integrations_namespaceObject.FunctionToString(),
      // Native Wrappers
      new console_Console(),
      new http_Http(),
      // Global Handlers
      new onuncaughtexception_OnUncaughtException(),
      new onunhandledrejection_OnUnhandledRejection(),
      // Misc
      new linkederrors_LinkedErrors(),
  ];
  /**
   * The Sentry Node SDK Client.
   *
   * To use this SDK, call the {@link init} function as early as possible in the
   * main entry module. To set context information or send manual events, use the
   * provided methods.
   *
   * @example
   * ```
   *
   * const { init } = require('@sentry/node');
   *
   * init({
   *   dsn: '__DSN__',
   *   // ...
   * });
   * ```
   *
   * @example
   * ```
   *
   * const { configureScope } = require('@sentry/node');
   * configureScope((scope: Scope) => {
   *   scope.setExtra({ battery: 0.7 });
   *   scope.setTag({ user_mode: 'admin' });
   *   scope.setUser({ id: '4711' });
   * });
   * ```
   *
   * @example
   * ```
   *
   * const { addBreadcrumb } = require('@sentry/node');
   * addBreadcrumb({
   *   message: 'My Breadcrumb',
   *   // ...
   * });
   * ```
   *
   * @example
   * ```
   *
   * const Sentry = require('@sentry/node');
   * Sentry.captureMessage('Hello, world!');
   * Sentry.captureException(new Error('Good bye'));
   * Sentry.captureEvent({
   *   message: 'Manual',
   *   stacktrace: [
   *     // ...
   *   ],
   * });
   * ```
   *
   * @see {@link NodeOptions} for documentation on configuration options.
   */
  function init(options) {
      if (options === void 0) { options = {}; }
      var _a;
      var carrier = Object(esm_hub["d" /* getMainCarrier */])();
      var autoloadedIntegrations = ((_a = carrier.__SENTRY__) === null || _a === void 0 ? void 0 : _a.integrations) || [];
      options.defaultIntegrations =
          options.defaultIntegrations === false
              ? []
              : __spread((Array.isArray(options.defaultIntegrations) ? options.defaultIntegrations : sdk_defaultIntegrations), autoloadedIntegrations);
      if (options.dsn === undefined && process.env.SENTRY_DSN) {
          options.dsn = process.env.SENTRY_DSN;
      }
      if (options.tracesSampleRate === undefined && process.env.SENTRY_TRACES_SAMPLE_RATE) {
          var tracesSampleRate = parseFloat(process.env.SENTRY_TRACES_SAMPLE_RATE);
          if (isFinite(tracesSampleRate)) {
              options.tracesSampleRate = tracesSampleRate;
          }
      }
      if (options.release === undefined) {
          var detectedRelease = getSentryRelease();
          if (detectedRelease !== undefined) {
              options.release = detectedRelease;
          }
          else {
              // If release is not provided, then we should disable autoSessionTracking
              options.autoSessionTracking = false;
          }
      }
      if (options.environment === undefined && process.env.SENTRY_ENVIRONMENT) {
          options.environment = process.env.SENTRY_ENVIRONMENT;
      }
      if (options.autoSessionTracking === undefined && options.dsn !== undefined) {
          options.autoSessionTracking = true;
      }
      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
      if (external_domain_["active"]) {
          Object(esm_hub["f" /* setHubOnCarrier */])(carrier, Object(esm_hub["b" /* getCurrentHub */])());
      }
      initAndBind(client_NodeClient, options);
      if (options.autoSessionTracking) {
          startSessionTracking();
      }
  }
  /**
   * This is the getter for lastEventId.
   *
   * @returns The last event id of a captured event.
   */
  function lastEventId() {
      return Object(esm_hub["b" /* getCurrentHub */])().lastEventId();
  }
  /**
   * Call `flush()` on the current client, if there is one. See {@link Client.flush}.
   *
   * @param timeout Maximum time in ms the client should wait to flush its event queue. Omitting this parameter will cause
   * the client to wait until all events are sent before resolving the promise.
   * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it
   * doesn't (or if there's no client defined).
   */
  function flush(timeout) {
      return __awaiter(this, void 0, void 0, function () {
          var client;
          return __generator(this, function (_a) {
              client = Object(esm_hub["b" /* getCurrentHub */])().getClient();
              if (client) {
                  return [2 /*return*/, client.flush(timeout)];
              }
              logger["a" /* logger */].warn('Cannot flush events. No client defined.');
              return [2 /*return*/, Promise.resolve(false)];
          });
      });
  }
  /**
   * Call `close()` on the current client, if there is one. See {@link Client.close}.
   *
   * @param timeout Maximum time in ms the client should wait to flush its event queue before shutting down. Omitting this
   * parameter will cause the client to wait until all events are sent before disabling itself.
   * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it
   * doesn't (or if there's no client defined).
   */
  function sdk_close(timeout) {
      return __awaiter(this, void 0, void 0, function () {
          var client;
          return __generator(this, function (_a) {
              client = Object(esm_hub["b" /* getCurrentHub */])().getClient();
              if (client) {
                  return [2 /*return*/, client.close(timeout)];
              }
              logger["a" /* logger */].warn('Cannot flush events and disable SDK. No client defined.');
              return [2 /*return*/, Promise.resolve(false)];
          });
      });
  }
  /**
   * Function that takes an instance of NodeClient and checks if autoSessionTracking option is enabled for that client
   */
  function isAutoSessionTrackingEnabled(client) {
      if (client === undefined) {
          return false;
      }
      var clientOptions = client && client.getOptions();
      if (clientOptions && clientOptions.autoSessionTracking !== undefined) {
          return clientOptions.autoSessionTracking;
      }
      return false;
  }
  /**
   * Returns a release dynamically from environment variables.
   */
  function getSentryRelease(fallback) {
      // Always read first as Sentry takes this as precedence
      if (process.env.SENTRY_RELEASE) {
          return process.env.SENTRY_RELEASE;
      }
      // This supports the variable that sentry-webpack-plugin injects
      var global = Object(misc["f" /* getGlobalObject */])();
      if (global.SENTRY_RELEASE && global.SENTRY_RELEASE.id) {
          return global.SENTRY_RELEASE.id;
      }
      return (
      // GitHub Actions - https://help.github.com/en/actions/configuring-and-managing-workflows/using-environment-variables#default-environment-variables
      process.env.GITHUB_SHA ||
          // Netlify - https://docs.netlify.com/configure-builds/environment-variables/#build-metadata
          process.env.COMMIT_REF ||
          // Vercel - https://vercel.com/docs/v2/build-step#system-environment-variables
          process.env.VERCEL_GIT_COMMIT_SHA ||
          process.env.VERCEL_GITHUB_COMMIT_SHA ||
          process.env.VERCEL_GITLAB_COMMIT_SHA ||
          process.env.VERCEL_BITBUCKET_COMMIT_SHA ||
          // Zeit (now known as Vercel)
          process.env.ZEIT_GITHUB_COMMIT_SHA ||
          process.env.ZEIT_GITLAB_COMMIT_SHA ||
          process.env.ZEIT_BITBUCKET_COMMIT_SHA ||
          fallback);
  }
  /**
   * Enable automatic Session Tracking for the node process.
   */
  function startSessionTracking() {
      var hub = Object(esm_hub["b" /* getCurrentHub */])();
      hub.startSession();
      // Emitted in the case of healthy sessions, error of `mechanism.handled: true` and unhandledrejections because
      // The 'beforeExit' event is not emitted for conditions causing explicit termination,
      // such as calling process.exit() or uncaught exceptions.
      // Ref: https://nodejs.org/api/process.html#process_event_beforeexit
      process.on('beforeExit', function () {
          var _a;
          var session = (_a = hub.getScope()) === null || _a === void 0 ? void 0 : _a.getSession();
          var terminalStates = [esm_session["b" /* SessionStatus */].Exited, esm_session["b" /* SessionStatus */].Crashed];
          // Only call endSession, if the Session exists on Scope and SessionStatus is not a
          // Terminal Status i.e. Exited or Crashed because
          // "When a session is moved away from ok it must not be updated anymore."
          // Ref: https://develop.sentry.dev/sdk/sessions/
          if (session && !terminalStates.includes(session.status))
              hub.endSession();
      });
  }
  //# sourceMappingURL=sdk.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/utils.js
  
  
  
  /**
   * Recursively read the contents of a directory.
   *
   * @param targetDir Absolute or relative path of the directory to scan. All returned paths will be relative to this
   * directory.
   * @returns Array holding all relative paths
   */
  function deepReadDirSync(targetDir) {
      var targetDirAbsPath = external_path_["resolve"](targetDir);
      if (!external_fs_["existsSync"](targetDirAbsPath)) {
          throw new Error("Cannot read contents of " + targetDirAbsPath + ". Directory does not exist.");
      }
      if (!external_fs_["statSync"](targetDirAbsPath).isDirectory()) {
          throw new Error("Cannot read contents of " + targetDirAbsPath + ", because it is not a directory.");
      }
      // This does the same thing as its containing function, `deepReadDirSync` (except that - purely for convenience - it
      // deals in absolute paths rather than relative ones). We need this to be separate from the outer function to preserve
      // the difference between `targetDirAbsPath` and `currentDirAbsPath`.
      var deepReadCurrentDir = function (currentDirAbsPath) {
          return external_fs_["readdirSync"](currentDirAbsPath).reduce(function (absPaths, itemName) {
              var itemAbsPath = external_path_["join"](currentDirAbsPath, itemName);
              if (external_fs_["statSync"](itemAbsPath).isDirectory()) {
                  return __spread(absPaths, deepReadCurrentDir(itemAbsPath));
              }
              return __spread(absPaths, [itemAbsPath]);
          }, []);
      };
      return deepReadCurrentDir(targetDirAbsPath).map(function (absPath) { return external_path_["relative"](targetDirAbsPath, absPath); });
  }
  //# sourceMappingURL=utils.js.map
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/node_modules/tslib/tslib.es6.js
  var tslib_tslib_es6 = __webpack_require__(1);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/hubextensions.js
  var hubextensions = __webpack_require__(28);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/idletransaction.js
  var idletransaction = __webpack_require__(34);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/spanstatus.js
  var spanstatus = __webpack_require__(10);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/utils.js
  var utils = __webpack_require__(5);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/browser/backgroundtab.js
  
  
  
  var backgroundtab_global = Object(misc["f" /* getGlobalObject */])();
  /**
   * Add a listener that cancels and finishes a transaction when the global
   * document is hidden.
   */
  function registerBackgroundTabDetection() {
      if (backgroundtab_global && backgroundtab_global.document) {
          backgroundtab_global.document.addEventListener('visibilitychange', function () {
              var activeTransaction = Object(utils["b" /* getActiveTransaction */])();
              if (backgroundtab_global.document.hidden && activeTransaction) {
                  logger["a" /* logger */].log("[Tracing] Transaction: " + spanstatus["a" /* SpanStatus */].Cancelled + " -> since tab moved to the background, op: " + activeTransaction.op);
                  // We should not set status if it is already set, this prevent important statuses like
                  // error or data loss from being overwritten on transaction.
                  if (!activeTransaction.status) {
                      activeTransaction.setStatus(spanstatus["a" /* SpanStatus */].Cancelled);
                  }
                  activeTransaction.setTag('visibilitychange', 'document.hidden');
                  activeTransaction.finish();
              }
          });
      }
      else {
          logger["a" /* logger */].warn('[Tracing] Could not set up background tab detection due to lack of global document');
      }
  }
  //# sourceMappingURL=backgroundtab.js.map
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/node.js
  var node = __webpack_require__(20);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/browser.js
  var browser = __webpack_require__(81);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/browser/web-vitals/lib/bindReporter.js
  /*
   * Copyright 2020 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     https://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var bindReporter = function (callback, metric, reportAllChanges) {
      var prevValue;
      return function (forceReport) {
          if (metric.value >= 0) {
              if (forceReport || reportAllChanges) {
                  metric.delta = metric.value - (prevValue || 0);
                  // Report the metric if there's a non-zero delta or if no previous
                  // value exists (which can happen in the case of the document becoming
                  // hidden when the metric value is 0).
                  // See: https://github.com/GoogleChrome/web-vitals/issues/14
                  if (metric.delta || prevValue === undefined) {
                      prevValue = metric.value;
                      callback(metric);
                  }
              }
          }
      };
  };
  //# sourceMappingURL=bindReporter.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/browser/web-vitals/lib/generateUniqueID.js
  /*
   * Copyright 2020 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     https://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * Performantly generate a unique, 30-char string by combining a version
   * number, the current timestamp with a 13-digit number integer.
   * @return {string}
   */
  var generateUniqueID = function () {
      return "v2-" + Date.now() + "-" + (Math.floor(Math.random() * (9e12 - 1)) + 1e12);
  };
  //# sourceMappingURL=generateUniqueID.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/browser/web-vitals/lib/initMetric.js
  /*
   * Copyright 2020 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     https://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  var initMetric = function (name, value) {
      return {
          name: name,
          value: (value !== null && value !== void 0 ? value : -1),
          delta: 0,
          entries: [],
          id: generateUniqueID(),
      };
  };
  //# sourceMappingURL=initMetric.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/browser/web-vitals/lib/observe.js
  /*
   * Copyright 2020 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     https://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * Takes a performance entry type and a callback function, and creates a
   * `PerformanceObserver` instance that will observe the specified entry type
   * with buffering enabled and call the callback _for each entry_.
   *
   * This function also feature-detects entry support and wraps the logic in a
   * try/catch to avoid errors in unsupporting browsers.
   */
  var observe = function (type, callback) {
      try {
          if (PerformanceObserver.supportedEntryTypes.includes(type)) {
              // More extensive feature detect needed for Firefox due to:
              // https://github.com/GoogleChrome/web-vitals/issues/142
              if (type === 'first-input' && !('PerformanceEventTiming' in self)) {
                  return;
              }
              var po = new PerformanceObserver(function (l) { return l.getEntries().map(callback); });
              po.observe({ type: type, buffered: true });
              return po;
          }
      }
      catch (e) {
          // Do nothing.
      }
      return;
  };
  //# sourceMappingURL=observe.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/browser/web-vitals/lib/onHidden.js
  /*
   * Copyright 2020 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     https://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  var onHidden = function (cb, once) {
      var onHiddenOrPageHide = function (event) {
          if (event.type === 'pagehide' || Object(misc["f" /* getGlobalObject */])().document.visibilityState === 'hidden') {
              cb(event);
              if (once) {
                  removeEventListener('visibilitychange', onHiddenOrPageHide, true);
                  removeEventListener('pagehide', onHiddenOrPageHide, true);
              }
          }
      };
      addEventListener('visibilitychange', onHiddenOrPageHide, true);
      // Some browsers have buggy implementations of visibilitychange,
      // so we use pagehide in addition, just to be safe.
      addEventListener('pagehide', onHiddenOrPageHide, true);
  };
  //# sourceMappingURL=onHidden.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/browser/web-vitals/getCLS.js
  /*
   * Copyright 2020 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     https://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  
  
  
  var getCLS = function (onReport, reportAllChanges) {
      var metric = initMetric('CLS', 0);
      var report;
      var sessionValue = 0;
      var sessionEntries = [];
      var entryHandler = function (entry) {
          // Only count layout shifts without recent user input.
          // TODO: Figure out why entry can be undefined
          if (entry && !entry.hadRecentInput) {
              var firstSessionEntry = sessionEntries[0];
              var lastSessionEntry = sessionEntries[sessionEntries.length - 1];
              // If the entry occurred less than 1 second after the previous entry and
              // less than 5 seconds after the first entry in the session, include the
              // entry in the current session. Otherwise, start a new session.
              if (sessionValue &&
                  sessionEntries.length !== 0 &&
                  entry.startTime - lastSessionEntry.startTime < 1000 &&
                  entry.startTime - firstSessionEntry.startTime < 5000) {
                  sessionValue += entry.value;
                  sessionEntries.push(entry);
              }
              else {
                  sessionValue = entry.value;
                  sessionEntries = [entry];
              }
              // If the current session value is larger than the current CLS value,
              // update CLS and the entries contributing to it.
              if (sessionValue > metric.value) {
                  metric.value = sessionValue;
                  metric.entries = sessionEntries;
                  if (report) {
                      report();
                  }
              }
          }
      };
      var po = observe('layout-shift', entryHandler);
      if (po) {
          report = bindReporter(onReport, metric, reportAllChanges);
          onHidden(function () {
              po.takeRecords().map(entryHandler);
              report(true);
          });
      }
  };
  //# sourceMappingURL=getCLS.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/browser/web-vitals/lib/getVisibilityWatcher.js
  /*
   * Copyright 2020 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     https://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  
  var firstHiddenTime = -1;
  var initHiddenTime = function () {
      return Object(misc["f" /* getGlobalObject */])().document.visibilityState === 'hidden' ? 0 : Infinity;
  };
  var trackChanges = function () {
      // Update the time if/when the document becomes hidden.
      onHidden(function (_a) {
          var timeStamp = _a.timeStamp;
          firstHiddenTime = timeStamp;
      }, true);
  };
  var getVisibilityWatcher = function () {
      if (firstHiddenTime < 0) {
          // If the document is hidden when this code runs, assume it was hidden
          // since navigation start. This isn't a perfect heuristic, but it's the
          // best we can do until an API is available to support querying past
          // visibilityState.
          firstHiddenTime = initHiddenTime();
          trackChanges();
      }
      return {
          get firstHiddenTime() {
              return firstHiddenTime;
          },
      };
  };
  //# sourceMappingURL=getVisibilityWatcher.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/browser/web-vitals/getFID.js
  /*
   * Copyright 2020 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     https://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  
  
  
  
  var getFID = function (onReport, reportAllChanges) {
      var visibilityWatcher = getVisibilityWatcher();
      var metric = initMetric('FID');
      var report;
      var entryHandler = function (entry) {
          // Only report if the page wasn't hidden prior to the first input.
          if (report && entry.startTime < visibilityWatcher.firstHiddenTime) {
              metric.value = entry.processingStart - entry.startTime;
              metric.entries.push(entry);
              report(true);
          }
      };
      var po = observe('first-input', entryHandler);
      if (po) {
          report = bindReporter(onReport, metric, reportAllChanges);
          onHidden(function () {
              po.takeRecords().map(entryHandler);
              po.disconnect();
          }, true);
      }
  };
  //# sourceMappingURL=getFID.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/browser/web-vitals/getLCP.js
  /*
   * Copyright 2020 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     https://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  
  
  
  
  var reportedMetricIDs = {};
  var getLCP = function (onReport, reportAllChanges) {
      var visibilityWatcher = getVisibilityWatcher();
      var metric = initMetric('LCP');
      var report;
      var entryHandler = function (entry) {
          // The startTime attribute returns the value of the renderTime if it is not 0,
          // and the value of the loadTime otherwise.
          var value = entry.startTime;
          // If the page was hidden prior to paint time of the entry,
          // ignore it and mark the metric as final, otherwise add the entry.
          if (value < visibilityWatcher.firstHiddenTime) {
              metric.value = value;
              metric.entries.push(entry);
          }
          if (report) {
              report();
          }
      };
      var po = observe('largest-contentful-paint', entryHandler);
      if (po) {
          report = bindReporter(onReport, metric, reportAllChanges);
          var stopListening_1 = function () {
              if (!reportedMetricIDs[metric.id]) {
                  po.takeRecords().map(entryHandler);
                  po.disconnect();
                  reportedMetricIDs[metric.id] = true;
                  report(true);
              }
          };
          // Stop listening after input. Note: while scrolling is an input that
          // stop LCP observation, it's unreliable since it can be programmatically
          // generated. See: https://github.com/GoogleChrome/web-vitals/issues/75
          ['keydown', 'click'].forEach(function (type) {
              addEventListener(type, stopListening_1, { once: true, capture: true });
          });
          onHidden(stopListening_1, true);
      }
  };
  //# sourceMappingURL=getLCP.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/browser/metrics.js
  
  
  
  
  
  
  
  var metrics_global = Object(misc["f" /* getGlobalObject */])();
  var DEFAULT_METRICS_INSTR_OPTIONS = {
      _reportAllChanges: false,
  };
  /** Class tracking metrics  */
  var metrics_MetricsInstrumentation = /** @class */ (function () {
      function MetricsInstrumentation(_options) {
          var _a, _b;
          this._measurements = {};
          this._performanceCursor = 0;
          if (!Object(node["b" /* isNodeEnv */])() && ((_a = metrics_global) === null || _a === void 0 ? void 0 : _a.performance) && ((_b = metrics_global) === null || _b === void 0 ? void 0 : _b.document)) {
              if (metrics_global.performance.mark) {
                  metrics_global.performance.mark('sentry-tracing-init');
              }
              this._trackCLS();
              this._trackLCP(_options._reportAllChanges);
              this._trackFID();
          }
      }
      /** Add performance related spans to a transaction */
      MetricsInstrumentation.prototype.addPerformanceEntries = function (transaction) {
          var _this = this;
          if (!metrics_global || !metrics_global.performance || !metrics_global.performance.getEntries || !time["a" /* browserPerformanceTimeOrigin */]) {
              // Gatekeeper if performance API not available
              return;
          }
          logger["a" /* logger */].log('[Tracing] Adding & adjusting spans using Performance API');
          var timeOrigin = Object(utils["d" /* msToSec */])(time["a" /* browserPerformanceTimeOrigin */]);
          var entryScriptSrc;
          if (metrics_global.document && metrics_global.document.scripts) {
              // eslint-disable-next-line @typescript-eslint/prefer-for-of
              for (var i = 0; i < metrics_global.document.scripts.length; i++) {
                  // We go through all scripts on the page and look for 'data-entry'
                  // We remember the name and measure the time between this script finished loading and
                  // our mark 'sentry-tracing-init'
                  if (metrics_global.document.scripts[i].dataset.entry === 'true') {
                      entryScriptSrc = metrics_global.document.scripts[i].src;
                      break;
                  }
              }
          }
          var entryScriptStartTimestamp;
          var tracingInitMarkStartTime;
          var responseStartTimestamp;
          var requestStartTimestamp;
          metrics_global.performance
              .getEntries()
              .slice(this._performanceCursor)
              .forEach(function (entry) {
              var startTime = Object(utils["d" /* msToSec */])(entry.startTime);
              var duration = Object(utils["d" /* msToSec */])(entry.duration);
              if (transaction.op === 'navigation' && timeOrigin + startTime < transaction.startTimestamp) {
                  return;
              }
              switch (entry.entryType) {
                  case 'navigation': {
                      addNavigationSpans(transaction, entry, timeOrigin);
                      responseStartTimestamp = timeOrigin + Object(utils["d" /* msToSec */])(entry.responseStart);
                      requestStartTimestamp = timeOrigin + Object(utils["d" /* msToSec */])(entry.requestStart);
                      break;
                  }
                  case 'mark':
                  case 'paint':
                  case 'measure': {
                      var startTimestamp = addMeasureSpans(transaction, entry, startTime, duration, timeOrigin);
                      if (tracingInitMarkStartTime === undefined && entry.name === 'sentry-tracing-init') {
                          tracingInitMarkStartTime = startTimestamp;
                      }
                      // capture web vitals
                      var firstHidden = getVisibilityWatcher();
                      // Only report if the page wasn't hidden prior to the web vital.
                      var shouldRecord = entry.startTime < firstHidden.firstHiddenTime;
                      if (entry.name === 'first-paint' && shouldRecord) {
                          logger["a" /* logger */].log('[Measurements] Adding FP');
                          _this._measurements['fp'] = { value: entry.startTime };
                          _this._measurements['mark.fp'] = { value: startTimestamp };
                      }
                      if (entry.name === 'first-contentful-paint' && shouldRecord) {
                          logger["a" /* logger */].log('[Measurements] Adding FCP');
                          _this._measurements['fcp'] = { value: entry.startTime };
                          _this._measurements['mark.fcp'] = { value: startTimestamp };
                      }
                      break;
                  }
                  case 'resource': {
                      var resourceName = entry.name.replace(metrics_global.location.origin, '');
                      var endTimestamp = addResourceSpans(transaction, entry, resourceName, startTime, duration, timeOrigin);
                      // We remember the entry script end time to calculate the difference to the first init mark
                      if (entryScriptStartTimestamp === undefined && (entryScriptSrc || '').indexOf(resourceName) > -1) {
                          entryScriptStartTimestamp = endTimestamp;
                      }
                      break;
                  }
                  default:
                  // Ignore other entry types.
              }
          });
          if (entryScriptStartTimestamp !== undefined && tracingInitMarkStartTime !== undefined) {
              _startChild(transaction, {
                  description: 'evaluation',
                  endTimestamp: tracingInitMarkStartTime,
                  op: 'script',
                  startTimestamp: entryScriptStartTimestamp,
              });
          }
          this._performanceCursor = Math.max(performance.getEntries().length - 1, 0);
          this._trackNavigator(transaction);
          // Measurements are only available for pageload transactions
          if (transaction.op === 'pageload') {
              // normalize applicable web vital values to be relative to transaction.startTimestamp
              var timeOrigin_1 = Object(utils["d" /* msToSec */])(time["a" /* browserPerformanceTimeOrigin */]);
              // Generate TTFB (Time to First Byte), which measured as the time between the beginning of the transaction and the
              // start of the response in milliseconds
              if (typeof responseStartTimestamp === 'number') {
                  logger["a" /* logger */].log('[Measurements] Adding TTFB');
                  this._measurements['ttfb'] = { value: (responseStartTimestamp - transaction.startTimestamp) * 1000 };
                  if (typeof requestStartTimestamp === 'number' && requestStartTimestamp <= responseStartTimestamp) {
                      // Capture the time spent making the request and receiving the first byte of the response.
                      // This is the time between the start of the request and the start of the response in milliseconds.
                      this._measurements['ttfb.requestTime'] = { value: (responseStartTimestamp - requestStartTimestamp) * 1000 };
                  }
              }
              ['fcp', 'fp', 'lcp'].forEach(function (name) {
                  if (!_this._measurements[name] || timeOrigin_1 >= transaction.startTimestamp) {
                      return;
                  }
                  // The web vitals, fcp, fp, lcp, and ttfb, all measure relative to timeOrigin.
                  // Unfortunately, timeOrigin is not captured within the transaction span data, so these web vitals will need
                  // to be adjusted to be relative to transaction.startTimestamp.
                  var oldValue = _this._measurements[name].value;
                  var measurementTimestamp = timeOrigin_1 + Object(utils["d" /* msToSec */])(oldValue);
                  // normalizedValue should be in milliseconds
                  var normalizedValue = Math.abs((measurementTimestamp - transaction.startTimestamp) * 1000);
                  var delta = normalizedValue - oldValue;
                  logger["a" /* logger */].log("[Measurements] Normalized " + name + " from " + oldValue + " to " + normalizedValue + " (" + delta + ")");
                  _this._measurements[name].value = normalizedValue;
              });
              if (this._measurements['mark.fid'] && this._measurements['fid']) {
                  // create span for FID
                  _startChild(transaction, {
                      description: 'first input delay',
                      endTimestamp: this._measurements['mark.fid'].value + Object(utils["d" /* msToSec */])(this._measurements['fid'].value),
                      op: 'web.vitals',
                      startTimestamp: this._measurements['mark.fid'].value,
                  });
              }
              // If FCP is not recorded we should not record the cls value
              // according to the new definition of CLS.
              if (!('fcp' in this._measurements)) {
                  delete this._measurements.cls;
              }
              transaction.setMeasurements(this._measurements);
              this._tagMetricInfo(transaction);
          }
      };
      /** Add LCP / CLS data to transaction to allow debugging */
      MetricsInstrumentation.prototype._tagMetricInfo = function (transaction) {
          if (this._lcpEntry) {
              logger["a" /* logger */].log('[Measurements] Adding LCP Data');
              // Capture Properties of the LCP element that contributes to the LCP.
              if (this._lcpEntry.element) {
                  transaction.setTag('lcp.element', Object(browser["a" /* htmlTreeAsString */])(this._lcpEntry.element));
              }
              if (this._lcpEntry.id) {
                  transaction.setTag('lcp.id', this._lcpEntry.id);
              }
              if (this._lcpEntry.url) {
                  // Trim URL to the first 200 characters.
                  transaction.setTag('lcp.url', this._lcpEntry.url.trim().slice(0, 200));
              }
              transaction.setTag('lcp.size', this._lcpEntry.size);
          }
          // See: https://developer.mozilla.org/en-US/docs/Web/API/LayoutShift
          if (this._clsEntry && this._clsEntry.sources) {
              logger["a" /* logger */].log('[Measurements] Adding CLS Data');
              this._clsEntry.sources.forEach(function (source, index) {
                  return transaction.setTag("cls.source." + (index + 1), Object(browser["a" /* htmlTreeAsString */])(source.node));
              });
          }
      };
      /** Starts tracking the Cumulative Layout Shift on the current page. */
      MetricsInstrumentation.prototype._trackCLS = function () {
          var _this = this;
          // See:
          // https://web.dev/evolving-cls/
          // https://web.dev/cls-web-tooling/
          getCLS(function (metric) {
              var entry = metric.entries.pop();
              if (!entry) {
                  return;
              }
              logger["a" /* logger */].log('[Measurements] Adding CLS');
              _this._measurements['cls'] = { value: metric.value };
              _this._clsEntry = entry;
          });
      };
      /**
       * Capture the information of the user agent.
       */
      MetricsInstrumentation.prototype._trackNavigator = function (transaction) {
          var navigator = metrics_global.navigator;
          if (!navigator) {
              return;
          }
          // track network connectivity
          var connection = navigator.connection;
          if (connection) {
              if (connection.effectiveType) {
                  transaction.setTag('effectiveConnectionType', connection.effectiveType);
              }
              if (connection.type) {
                  transaction.setTag('connectionType', connection.type);
              }
              if (isMeasurementValue(connection.rtt)) {
                  this._measurements['connection.rtt'] = { value: connection.rtt };
              }
              if (isMeasurementValue(connection.downlink)) {
                  this._measurements['connection.downlink'] = { value: connection.downlink };
              }
          }
          if (isMeasurementValue(navigator.deviceMemory)) {
              transaction.setTag('deviceMemory', String(navigator.deviceMemory));
          }
          if (isMeasurementValue(navigator.hardwareConcurrency)) {
              transaction.setTag('hardwareConcurrency', String(navigator.hardwareConcurrency));
          }
      };
      /** Starts tracking the Largest Contentful Paint on the current page. */
      MetricsInstrumentation.prototype._trackLCP = function (reportAllChanges) {
          var _this = this;
          getLCP(function (metric) {
              var entry = metric.entries.pop();
              if (!entry) {
                  return;
              }
              var timeOrigin = Object(utils["d" /* msToSec */])(time["a" /* browserPerformanceTimeOrigin */]);
              var startTime = Object(utils["d" /* msToSec */])(entry.startTime);
              logger["a" /* logger */].log('[Measurements] Adding LCP');
              _this._measurements['lcp'] = { value: metric.value };
              _this._measurements['mark.lcp'] = { value: timeOrigin + startTime };
              _this._lcpEntry = entry;
          }, reportAllChanges);
      };
      /** Starts tracking the First Input Delay on the current page. */
      MetricsInstrumentation.prototype._trackFID = function () {
          var _this = this;
          getFID(function (metric) {
              var entry = metric.entries.pop();
              if (!entry) {
                  return;
              }
              var timeOrigin = Object(utils["d" /* msToSec */])(time["a" /* browserPerformanceTimeOrigin */]);
              var startTime = Object(utils["d" /* msToSec */])(entry.startTime);
              logger["a" /* logger */].log('[Measurements] Adding FID');
              _this._measurements['fid'] = { value: metric.value };
              _this._measurements['mark.fid'] = { value: timeOrigin + startTime };
          });
      };
      return MetricsInstrumentation;
  }());
  
  /** Instrument navigation entries */
  function addNavigationSpans(transaction, entry, timeOrigin) {
      addPerformanceNavigationTiming({ transaction: transaction, entry: entry, event: 'unloadEvent', timeOrigin: timeOrigin });
      addPerformanceNavigationTiming({ transaction: transaction, entry: entry, event: 'redirect', timeOrigin: timeOrigin });
      addPerformanceNavigationTiming({ transaction: transaction, entry: entry, event: 'domContentLoadedEvent', timeOrigin: timeOrigin });
      addPerformanceNavigationTiming({ transaction: transaction, entry: entry, event: 'loadEvent', timeOrigin: timeOrigin });
      addPerformanceNavigationTiming({ transaction: transaction, entry: entry, event: 'connect', timeOrigin: timeOrigin });
      addPerformanceNavigationTiming({
          transaction: transaction,
          entry: entry,
          event: 'secureConnection',
          timeOrigin: timeOrigin,
          eventEnd: 'connectEnd',
          description: 'TLS/SSL',
      });
      addPerformanceNavigationTiming({
          transaction: transaction,
          entry: entry,
          event: 'fetch',
          timeOrigin: timeOrigin,
          eventEnd: 'domainLookupStart',
          description: 'cache',
      });
      addPerformanceNavigationTiming({ transaction: transaction, entry: entry, event: 'domainLookup', timeOrigin: timeOrigin, description: 'DNS' });
      addRequest(transaction, entry, timeOrigin);
  }
  /** Create measure related spans */
  function addMeasureSpans(transaction, entry, startTime, duration, timeOrigin) {
      var measureStartTimestamp = timeOrigin + startTime;
      var measureEndTimestamp = measureStartTimestamp + duration;
      _startChild(transaction, {
          description: entry.name,
          endTimestamp: measureEndTimestamp,
          op: entry.entryType,
          startTimestamp: measureStartTimestamp,
      });
      return measureStartTimestamp;
  }
  /** Create resource-related spans */
  function addResourceSpans(transaction, entry, resourceName, startTime, duration, timeOrigin) {
      // we already instrument based on fetch and xhr, so we don't need to
      // duplicate spans here.
      if (entry.initiatorType === 'xmlhttprequest' || entry.initiatorType === 'fetch') {
          return undefined;
      }
      var data = {};
      if ('transferSize' in entry) {
          data['Transfer Size'] = entry.transferSize;
      }
      if ('encodedBodySize' in entry) {
          data['Encoded Body Size'] = entry.encodedBodySize;
      }
      if ('decodedBodySize' in entry) {
          data['Decoded Body Size'] = entry.decodedBodySize;
      }
      var startTimestamp = timeOrigin + startTime;
      var endTimestamp = startTimestamp + duration;
      _startChild(transaction, {
          description: resourceName,
          endTimestamp: endTimestamp,
          op: entry.initiatorType ? "resource." + entry.initiatorType : 'resource',
          startTimestamp: startTimestamp,
          data: data,
      });
      return endTimestamp;
  }
  /** Create performance navigation related spans */
  function addPerformanceNavigationTiming(props) {
      var transaction = props.transaction, entry = props.entry, event = props.event, timeOrigin = props.timeOrigin, eventEnd = props.eventEnd, description = props.description;
      var end = eventEnd ? entry[eventEnd] : entry[event + "End"];
      var start = entry[event + "Start"];
      if (!start || !end) {
          return;
      }
      _startChild(transaction, {
          op: 'browser',
          description: (description !== null && description !== void 0 ? description : event),
          startTimestamp: timeOrigin + Object(utils["d" /* msToSec */])(start),
          endTimestamp: timeOrigin + Object(utils["d" /* msToSec */])(end),
      });
  }
  /** Create request and response related spans */
  function addRequest(transaction, entry, timeOrigin) {
      _startChild(transaction, {
          op: 'browser',
          description: 'request',
          startTimestamp: timeOrigin + Object(utils["d" /* msToSec */])(entry.requestStart),
          endTimestamp: timeOrigin + Object(utils["d" /* msToSec */])(entry.responseEnd),
      });
      _startChild(transaction, {
          op: 'browser',
          description: 'response',
          startTimestamp: timeOrigin + Object(utils["d" /* msToSec */])(entry.responseStart),
          endTimestamp: timeOrigin + Object(utils["d" /* msToSec */])(entry.responseEnd),
      });
  }
  /**
   * Helper function to start child on transactions. This function will make sure that the transaction will
   * use the start timestamp of the created child span if it is earlier than the transactions actual
   * start timestamp.
   */
  function _startChild(transaction, _a) {
      var startTimestamp = _a.startTimestamp, ctx = Object(tslib_tslib_es6["d" /* __rest */])(_a, ["startTimestamp"]);
      if (startTimestamp && transaction.startTimestamp > startTimestamp) {
          transaction.startTimestamp = startTimestamp;
      }
      return transaction.startChild(Object(tslib_tslib_es6["a" /* __assign */])({ startTimestamp: startTimestamp }, ctx));
  }
  /**
   * Checks if a given value is a valid measurement value.
   */
  function isMeasurementValue(value) {
      return typeof value === 'number' && isFinite(value);
  }
  //# sourceMappingURL=metrics.js.map
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/instrument.js + 1 modules
  var instrument = __webpack_require__(123);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/browser/request.js
  
  
  
  
  var DEFAULT_TRACING_ORIGINS = ['localhost', /^\//];
  var defaultRequestInstrumentationOptions = {
      traceFetch: true,
      traceXHR: true,
      tracingOrigins: DEFAULT_TRACING_ORIGINS,
  };
  /** Registers span creators for xhr and fetch requests  */
  function instrumentOutgoingRequests(_options) {
      // eslint-disable-next-line @typescript-eslint/unbound-method
      var _a = Object(tslib_tslib_es6["a" /* __assign */])(Object(tslib_tslib_es6["a" /* __assign */])({}, defaultRequestInstrumentationOptions), _options), traceFetch = _a.traceFetch, traceXHR = _a.traceXHR, tracingOrigins = _a.tracingOrigins, shouldCreateSpanForRequest = _a.shouldCreateSpanForRequest;
      // We should cache url -> decision so that we don't have to compute
      // regexp everytime we create a request.
      var urlMap = {};
      var defaultShouldCreateSpan = function (url) {
          if (urlMap[url]) {
              return urlMap[url];
          }
          var origins = tracingOrigins;
          urlMap[url] =
              origins.some(function (origin) { return Object(string["a" /* isMatchingPattern */])(url, origin); }) &&
                  !Object(string["a" /* isMatchingPattern */])(url, 'sentry_key');
          return urlMap[url];
      };
      // We want that our users don't have to re-implement shouldCreateSpanForRequest themselves
      // That's why we filter out already unwanted Spans from tracingOrigins
      var shouldCreateSpan = defaultShouldCreateSpan;
      if (typeof shouldCreateSpanForRequest === 'function') {
          shouldCreateSpan = function (url) {
              return defaultShouldCreateSpan(url) && shouldCreateSpanForRequest(url);
          };
      }
      var spans = {};
      if (traceFetch) {
          Object(instrument["a" /* addInstrumentationHandler */])({
              callback: function (handlerData) {
                  fetchCallback(handlerData, shouldCreateSpan, spans);
              },
              type: 'fetch',
          });
      }
      if (traceXHR) {
          Object(instrument["a" /* addInstrumentationHandler */])({
              callback: function (handlerData) {
                  xhrCallback(handlerData, shouldCreateSpan, spans);
              },
              type: 'xhr',
          });
      }
  }
  /**
   * Create and track fetch request spans
   */
  function fetchCallback(handlerData, shouldCreateSpan, spans) {
      if (!Object(utils["c" /* hasTracingEnabled */])() || !(handlerData.fetchData && shouldCreateSpan(handlerData.fetchData.url))) {
          return;
      }
      if (handlerData.endTimestamp && handlerData.fetchData.__span) {
          var span = spans[handlerData.fetchData.__span];
          if (span) {
              if (handlerData.response) {
                  // TODO (kmclb) remove this once types PR goes through
                  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                  span.setHttpStatus(handlerData.response.status);
              }
              else if (handlerData.error) {
                  span.setStatus(spanstatus["a" /* SpanStatus */].InternalError);
              }
              span.finish();
              // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
              delete spans[handlerData.fetchData.__span];
          }
          return;
      }
      var activeTransaction = Object(utils["b" /* getActiveTransaction */])();
      if (activeTransaction) {
          var span = activeTransaction.startChild({
              data: Object(tslib_tslib_es6["a" /* __assign */])(Object(tslib_tslib_es6["a" /* __assign */])({}, handlerData.fetchData), { type: 'fetch' }),
              description: handlerData.fetchData.method + " " + handlerData.fetchData.url,
              op: 'http.client',
          });
          handlerData.fetchData.__span = span.spanId;
          spans[span.spanId] = span;
          var request = (handlerData.args[0] = handlerData.args[0]);
          // eslint-disable-next-line @typescript-eslint/no-explicit-any
          var options = (handlerData.args[1] = handlerData.args[1] || {});
          var headers = options.headers;
          if (Object(is["d" /* isInstanceOf */])(request, Request)) {
              headers = request.headers;
          }
          if (headers) {
              // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
              if (typeof headers.append === 'function') {
                  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                  headers.append('sentry-trace', span.toTraceparent());
              }
              else if (Array.isArray(headers)) {
                  headers = Object(tslib_tslib_es6["e" /* __spread */])(headers, [['sentry-trace', span.toTraceparent()]]);
              }
              else {
                  headers = Object(tslib_tslib_es6["a" /* __assign */])(Object(tslib_tslib_es6["a" /* __assign */])({}, headers), { 'sentry-trace': span.toTraceparent() });
              }
          }
          else {
              headers = { 'sentry-trace': span.toTraceparent() };
          }
          options.headers = headers;
      }
  }
  /**
   * Create and track xhr request spans
   */
  function xhrCallback(handlerData, shouldCreateSpan, spans) {
      var _a, _b;
      if (!Object(utils["c" /* hasTracingEnabled */])() || ((_a = handlerData.xhr) === null || _a === void 0 ? void 0 : _a.__sentry_own_request__) ||
          !(((_b = handlerData.xhr) === null || _b === void 0 ? void 0 : _b.__sentry_xhr__) && shouldCreateSpan(handlerData.xhr.__sentry_xhr__.url))) {
          return;
      }
      var xhr = handlerData.xhr.__sentry_xhr__;
      // check first if the request has finished and is tracked by an existing span which should now end
      if (handlerData.endTimestamp && handlerData.xhr.__sentry_xhr_span_id__) {
          var span = spans[handlerData.xhr.__sentry_xhr_span_id__];
          if (span) {
              span.setHttpStatus(xhr.status_code);
              span.finish();
              // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
              delete spans[handlerData.xhr.__sentry_xhr_span_id__];
          }
          return;
      }
      // if not, create a new span to track it
      var activeTransaction = Object(utils["b" /* getActiveTransaction */])();
      if (activeTransaction) {
          var span = activeTransaction.startChild({
              data: Object(tslib_tslib_es6["a" /* __assign */])(Object(tslib_tslib_es6["a" /* __assign */])({}, xhr.data), { type: 'xhr', method: xhr.method, url: xhr.url }),
              description: xhr.method + " " + xhr.url,
              op: 'http.client',
          });
          handlerData.xhr.__sentry_xhr_span_id__ = span.spanId;
          spans[handlerData.xhr.__sentry_xhr_span_id__] = span;
          if (handlerData.xhr.setRequestHeader) {
              try {
                  handlerData.xhr.setRequestHeader('sentry-trace', span.toTraceparent());
              }
              catch (_) {
                  // Error: InvalidStateError: Failed to execute 'setRequestHeader' on 'XMLHttpRequest': The object's state must be OPENED.
              }
          }
      }
  }
  //# sourceMappingURL=request.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/browser/router.js
  
  var router_global = Object(misc["f" /* getGlobalObject */])();
  /**
   * Default function implementing pageload and navigation transactions
   */
  function instrumentRoutingWithDefaults(customStartTransaction, startTransactionOnPageLoad, startTransactionOnLocationChange) {
      if (startTransactionOnPageLoad === void 0) { startTransactionOnPageLoad = true; }
      if (startTransactionOnLocationChange === void 0) { startTransactionOnLocationChange = true; }
      if (!router_global || !router_global.location) {
          logger["a" /* logger */].warn('Could not initialize routing instrumentation due to invalid location');
          return;
      }
      var startingUrl = router_global.location.href;
      var activeTransaction;
      if (startTransactionOnPageLoad) {
          activeTransaction = customStartTransaction({ name: router_global.location.pathname, op: 'pageload' });
      }
      if (startTransactionOnLocationChange) {
          Object(instrument["a" /* addInstrumentationHandler */])({
              callback: function (_a) {
                  var to = _a.to, from = _a.from;
                  /**
                   * This early return is there to account for some cases where a navigation transaction starts right after
                   * long-running pageload. We make sure that if `from` is undefined and a valid `startingURL` exists, we don't
                   * create an uneccessary navigation transaction.
                   *
                   * This was hard to duplicate, but this behavior stopped as soon as this fix was applied. This issue might also
                   * only be caused in certain development environments where the usage of a hot module reloader is causing
                   * errors.
                   */
                  if (from === undefined && startingUrl && startingUrl.indexOf(to) !== -1) {
                      startingUrl = undefined;
                      return;
                  }
                  if (from !== to) {
                      startingUrl = undefined;
                      if (activeTransaction) {
                          logger["a" /* logger */].log("[Tracing] Finishing current transaction with op: " + activeTransaction.op);
                          // If there's an open transaction on the scope, we need to finish it before creating an new one.
                          activeTransaction.finish();
                      }
                      activeTransaction = customStartTransaction({ name: router_global.location.pathname, op: 'navigation' });
                  }
              },
              type: 'history',
          });
      }
  }
  //# sourceMappingURL=router.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/browser/browsertracing.js
  
  
  
  
  
  
  
  
  
  
  var DEFAULT_MAX_TRANSACTION_DURATION_SECONDS = 600;
  var DEFAULT_BROWSER_TRACING_OPTIONS = Object(tslib_tslib_es6["a" /* __assign */])({ idleTimeout: idletransaction["a" /* DEFAULT_IDLE_TIMEOUT */], markBackgroundTransactions: true, maxTransactionDuration: DEFAULT_MAX_TRANSACTION_DURATION_SECONDS, routingInstrumentation: instrumentRoutingWithDefaults, startTransactionOnLocationChange: true, startTransactionOnPageLoad: true }, defaultRequestInstrumentationOptions);
  /**
   * The Browser Tracing integration automatically instruments browser pageload/navigation
   * actions as transactions, and captures requests, metrics and errors as spans.
   *
   * The integration can be configured with a variety of options, and can be extended to use
   * any routing library. This integration uses {@see IdleTransaction} to create transactions.
   */
  var browsertracing_BrowserTracing = /** @class */ (function () {
      function BrowserTracing(_options) {
          /**
           * @inheritDoc
           */
          this.name = BrowserTracing.id;
          this._emitOptionsWarning = false;
          var tracingOrigins = defaultRequestInstrumentationOptions.tracingOrigins;
          // NOTE: Logger doesn't work in constructors, as it's initialized after integrations instances
          if (_options &&
              _options.tracingOrigins &&
              Array.isArray(_options.tracingOrigins) &&
              _options.tracingOrigins.length !== 0) {
              tracingOrigins = _options.tracingOrigins;
          }
          else {
              this._emitOptionsWarning = true;
          }
          this.options = Object(tslib_tslib_es6["a" /* __assign */])(Object(tslib_tslib_es6["a" /* __assign */])(Object(tslib_tslib_es6["a" /* __assign */])({}, DEFAULT_BROWSER_TRACING_OPTIONS), _options), { tracingOrigins: tracingOrigins });
          this._metrics = new metrics_MetricsInstrumentation(Object(tslib_tslib_es6["a" /* __assign */])(Object(tslib_tslib_es6["a" /* __assign */])({}, DEFAULT_METRICS_INSTR_OPTIONS), this.options._metricOptions));
      }
      /**
       * @inheritDoc
       */
      BrowserTracing.prototype.setupOnce = function (_, getCurrentHub) {
          var _this = this;
          this._getCurrentHub = getCurrentHub;
          if (this._emitOptionsWarning) {
              logger["a" /* logger */].warn('[Tracing] You need to define `tracingOrigins` in the options. Set an array of urls or patterns to trace.');
              logger["a" /* logger */].warn("[Tracing] We added a reasonable default for you: " + defaultRequestInstrumentationOptions.tracingOrigins);
          }
          // eslint-disable-next-line @typescript-eslint/unbound-method
          var _a = this.options, instrumentRouting = _a.routingInstrumentation, startTransactionOnLocationChange = _a.startTransactionOnLocationChange, startTransactionOnPageLoad = _a.startTransactionOnPageLoad, markBackgroundTransactions = _a.markBackgroundTransactions, traceFetch = _a.traceFetch, traceXHR = _a.traceXHR, tracingOrigins = _a.tracingOrigins, shouldCreateSpanForRequest = _a.shouldCreateSpanForRequest;
          instrumentRouting(function (context) { return _this._createRouteTransaction(context); }, startTransactionOnPageLoad, startTransactionOnLocationChange);
          if (markBackgroundTransactions) {
              registerBackgroundTabDetection();
          }
          instrumentOutgoingRequests({ traceFetch: traceFetch, traceXHR: traceXHR, tracingOrigins: tracingOrigins, shouldCreateSpanForRequest: shouldCreateSpanForRequest });
      };
      /** Create routing idle transaction. */
      BrowserTracing.prototype._createRouteTransaction = function (context) {
          var _this = this;
          if (!this._getCurrentHub) {
              logger["a" /* logger */].warn("[Tracing] Did not create " + context.op + " transaction because _getCurrentHub is invalid.");
              return undefined;
          }
          // eslint-disable-next-line @typescript-eslint/unbound-method
          var _a = this.options, beforeNavigate = _a.beforeNavigate, idleTimeout = _a.idleTimeout, maxTransactionDuration = _a.maxTransactionDuration;
          var parentContextFromHeader = context.op === 'pageload' ? getHeaderContext() : undefined;
          var expandedContext = Object(tslib_tslib_es6["a" /* __assign */])(Object(tslib_tslib_es6["a" /* __assign */])(Object(tslib_tslib_es6["a" /* __assign */])({}, context), parentContextFromHeader), { trimEnd: true });
          var modifiedContext = typeof beforeNavigate === 'function' ? beforeNavigate(expandedContext) : expandedContext;
          // For backwards compatibility reasons, beforeNavigate can return undefined to "drop" the transaction (prevent it
          // from being sent to Sentry).
          var finalContext = modifiedContext === undefined ? Object(tslib_tslib_es6["a" /* __assign */])(Object(tslib_tslib_es6["a" /* __assign */])({}, expandedContext), { sampled: false }) : modifiedContext;
          if (finalContext.sampled === false) {
              logger["a" /* logger */].log("[Tracing] Will not send " + finalContext.op + " transaction because of beforeNavigate.");
          }
          logger["a" /* logger */].log("[Tracing] Starting " + finalContext.op + " transaction on scope");
          var hub = this._getCurrentHub();
          var location = Object(misc["f" /* getGlobalObject */])().location;
          var idleTransaction = Object(hubextensions["b" /* startIdleTransaction */])(hub, finalContext, idleTimeout, true, { location: location });
          idleTransaction.registerBeforeFinishCallback(function (transaction, endTimestamp) {
              _this._metrics.addPerformanceEntries(transaction);
              adjustTransactionDuration(Object(utils["e" /* secToMs */])(maxTransactionDuration), transaction, endTimestamp);
          });
          return idleTransaction;
      };
      /**
       * @inheritDoc
       */
      BrowserTracing.id = 'BrowserTracing';
      return BrowserTracing;
  }());
  
  /**
   * Gets transaction context from a sentry-trace meta.
   *
   * @returns Transaction context data from the header or undefined if there's no header or the header is malformed
   */
  function getHeaderContext() {
      var header = getMetaContent('sentry-trace');
      if (header) {
          return Object(utils["a" /* extractTraceparentData */])(header);
      }
      return undefined;
  }
  /** Returns the value of a meta tag */
  function getMetaContent(metaName) {
      var el = Object(misc["f" /* getGlobalObject */])().document.querySelector("meta[name=" + metaName + "]");
      return el ? el.getAttribute('content') : null;
  }
  /** Adjusts transaction value based on max transaction duration */
  function adjustTransactionDuration(maxDuration, transaction, endTimestamp) {
      var diff = endTimestamp - transaction.startTimestamp;
      var isOutdatedTransaction = endTimestamp && (diff > maxDuration || diff < 0);
      if (isOutdatedTransaction) {
          transaction.setStatus(spanstatus["a" /* SpanStatus */].DeadlineExceeded);
          transaction.setTag('maxTransactionDurationExceeded', 'true');
      }
  }
  //# sourceMappingURL=browsertracing.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/integrations/node/express.js
  
  
  /**
   * Express integration
   *
   * Provides an request and error handler for Express framework as well as tracing capabilities
   */
  var express_Express = /** @class */ (function () {
      /**
       * @inheritDoc
       */
      function Express(options) {
          if (options === void 0) { options = {}; }
          /**
           * @inheritDoc
           */
          this.name = Express.id;
          this._router = options.router || options.app;
          this._methods = (Array.isArray(options.methods) ? options.methods : []).concat('use');
      }
      /**
       * @inheritDoc
       */
      Express.prototype.setupOnce = function () {
          if (!this._router) {
              logger["a" /* logger */].error('ExpressIntegration is missing an Express instance');
              return;
          }
          instrumentMiddlewares(this._router, this._methods);
      };
      /**
       * @inheritDoc
       */
      Express.id = 'Express';
      return Express;
  }());
  
  /**
   * Wraps original middleware function in a tracing call, which stores the info about the call as a span,
   * and finishes it once the middleware is done invoking.
   *
   * Express middlewares have 3 various forms, thus we have to take care of all of them:
   * // sync
   * app.use(function (req, res) { ... })
   * // async
   * app.use(function (req, res, next) { ... })
   * // error handler
   * app.use(function (err, req, res, next) { ... })
   *
   * They all internally delegate to the `router[method]` of the given application instance.
   */
  // eslint-disable-next-line @typescript-eslint/ban-types, @typescript-eslint/no-explicit-any
  function wrap(fn, method) {
      var arity = fn.length;
      switch (arity) {
          case 2: {
              return function (req, res) {
                  var transaction = res.__sentry_transaction;
                  if (transaction) {
                      var span_1 = transaction.startChild({
                          description: fn.name,
                          op: "middleware." + method,
                      });
                      res.once('finish', function () {
                          span_1.finish();
                      });
                  }
                  return fn.call(this, req, res);
              };
          }
          case 3: {
              return function (req, res, next) {
                  var _a;
                  var transaction = res.__sentry_transaction;
                  var span = (_a = transaction) === null || _a === void 0 ? void 0 : _a.startChild({
                      description: fn.name,
                      op: "middleware." + method,
                  });
                  fn.call(this, req, res, function () {
                      var args = [];
                      for (var _i = 0; _i < arguments.length; _i++) {
                          args[_i] = arguments[_i];
                      }
                      var _a;
                      (_a = span) === null || _a === void 0 ? void 0 : _a.finish();
                      next.call.apply(next, Object(tslib_tslib_es6["e" /* __spread */])([this], args));
                  });
              };
          }
          case 4: {
              return function (err, req, res, next) {
                  var _a;
                  var transaction = res.__sentry_transaction;
                  var span = (_a = transaction) === null || _a === void 0 ? void 0 : _a.startChild({
                      description: fn.name,
                      op: "middleware." + method,
                  });
                  fn.call(this, err, req, res, function () {
                      var args = [];
                      for (var _i = 0; _i < arguments.length; _i++) {
                          args[_i] = arguments[_i];
                      }
                      var _a;
                      (_a = span) === null || _a === void 0 ? void 0 : _a.finish();
                      next.call.apply(next, Object(tslib_tslib_es6["e" /* __spread */])([this], args));
                  });
              };
          }
          default: {
              throw new Error("Express middleware takes 2-4 arguments. Got: " + arity);
          }
      }
  }
  /**
   * Takes all the function arguments passed to the original `app` or `router` method, eg. `app.use` or `router.use`
   * and wraps every function, as well as array of functions with a call to our `wrap` method.
   * We have to take care of the arrays as well as iterate over all of the arguments,
   * as `app.use` can accept middlewares in few various forms.
   *
   * app.use([<path>], <fn>)
   * app.use([<path>], <fn>, ...<fn>)
   * app.use([<path>], ...<fn>[])
   */
  function wrapMiddlewareArgs(args, method) {
      return args.map(function (arg) {
          if (typeof arg === 'function') {
              return wrap(arg, method);
          }
          if (Array.isArray(arg)) {
              return arg.map(function (a) {
                  if (typeof a === 'function') {
                      return wrap(a, method);
                  }
                  return a;
              });
          }
          return arg;
      });
  }
  /**
   * Patches original router to utilize our tracing functionality
   */
  function patchMiddleware(router, method) {
      var originalCallback = router[method];
      router[method] = function () {
          var args = [];
          for (var _i = 0; _i < arguments.length; _i++) {
              args[_i] = arguments[_i];
          }
          return originalCallback.call.apply(originalCallback, Object(tslib_tslib_es6["e" /* __spread */])([this], wrapMiddlewareArgs(args, method)));
      };
      return router;
  }
  /**
   * Patches original router methods
   */
  function instrumentMiddlewares(router, methods) {
      if (methods === void 0) { methods = []; }
      methods.forEach(function (method) { return patchMiddleware(router, method); });
  }
  //# sourceMappingURL=express.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/integrations/node/postgres.js
  
  /** Tracing integration for node-postgres package */
  var postgres_Postgres = /** @class */ (function () {
      function Postgres(options) {
          if (options === void 0) { options = {}; }
          /**
           * @inheritDoc
           */
          this.name = Postgres.id;
          this._usePgNative = !!options.usePgNative;
      }
      /**
       * @inheritDoc
       */
      Postgres.prototype.setupOnce = function (_, getCurrentHub) {
          var _a;
          var pkg = Object(node["c" /* loadModule */])('pg');
          if (!pkg) {
              logger["a" /* logger */].error('Postgres Integration was unable to require `pg` package.');
              return;
          }
          if (this._usePgNative && !((_a = pkg.native) === null || _a === void 0 ? void 0 : _a.Client)) {
              logger["a" /* logger */].error("Postgres Integration was unable to access 'pg-native' bindings.");
              return;
          }
          var Client = (this._usePgNative ? pkg.native : pkg).Client;
          /**
           * function (query, callback) => void
           * function (query, params, callback) => void
           * function (query) => Promise
           * function (query, params) => Promise
           * function (pg.Cursor) => pg.Cursor
           */
          Object(object["c" /* fill */])(Client.prototype, 'query', function (orig) {
              return function (config, values, callback) {
                  var _a, _b, _c;
                  var scope = getCurrentHub().getScope();
                  var parentSpan = (_a = scope) === null || _a === void 0 ? void 0 : _a.getSpan();
                  var span = (_b = parentSpan) === null || _b === void 0 ? void 0 : _b.startChild({
                      description: typeof config === 'string' ? config : config.text,
                      op: "db",
                  });
                  if (typeof callback === 'function') {
                      return orig.call(this, config, values, function (err, result) {
                          var _a;
                          (_a = span) === null || _a === void 0 ? void 0 : _a.finish();
                          callback(err, result);
                      });
                  }
                  if (typeof values === 'function') {
                      return orig.call(this, config, function (err, result) {
                          var _a;
                          (_a = span) === null || _a === void 0 ? void 0 : _a.finish();
                          values(err, result);
                      });
                  }
                  var rv = typeof values !== 'undefined' ? orig.call(this, config, values) : orig.call(this, config);
                  if (Object(is["j" /* isThenable */])(rv)) {
                      return rv.then(function (res) {
                          var _a;
                          (_a = span) === null || _a === void 0 ? void 0 : _a.finish();
                          return res;
                      });
                  }
                  (_c = span) === null || _c === void 0 ? void 0 : _c.finish();
                  return rv;
              };
          });
      };
      /**
       * @inheritDoc
       */
      Postgres.id = 'Postgres';
      return Postgres;
  }());
  
  //# sourceMappingURL=postgres.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/integrations/node/mysql.js
  
  /** Tracing integration for node-mysql package */
  var mysql_Mysql = /** @class */ (function () {
      function Mysql() {
          /**
           * @inheritDoc
           */
          this.name = Mysql.id;
      }
      /**
       * @inheritDoc
       */
      Mysql.prototype.setupOnce = function (_, getCurrentHub) {
          var pkg = Object(node["c" /* loadModule */])('mysql/lib/Connection.js');
          if (!pkg) {
              logger["a" /* logger */].error('Mysql Integration was unable to require `mysql` package.');
              return;
          }
          // The original function will have one of these signatures:
          //    function (callback) => void
          //    function (options, callback) => void
          //    function (options, values, callback) => void
          Object(object["c" /* fill */])(pkg, 'createQuery', function (orig) {
              return function (options, values, callback) {
                  var _a, _b;
                  var scope = getCurrentHub().getScope();
                  var parentSpan = (_a = scope) === null || _a === void 0 ? void 0 : _a.getSpan();
                  var span = (_b = parentSpan) === null || _b === void 0 ? void 0 : _b.startChild({
                      description: typeof options === 'string' ? options : options.sql,
                      op: "db",
                  });
                  if (typeof callback === 'function') {
                      return orig.call(this, options, values, function (err, result, fields) {
                          var _a;
                          (_a = span) === null || _a === void 0 ? void 0 : _a.finish();
                          callback(err, result, fields);
                      });
                  }
                  if (typeof values === 'function') {
                      return orig.call(this, options, function (err, result, fields) {
                          var _a;
                          (_a = span) === null || _a === void 0 ? void 0 : _a.finish();
                          values(err, result, fields);
                      });
                  }
                  return orig.call(this, options, values, callback);
              };
          });
      };
      /**
       * @inheritDoc
       */
      Mysql.id = 'Mysql';
      return Mysql;
  }());
  
  //# sourceMappingURL=mysql.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/integrations/node/mongo.js
  
  
  var OPERATIONS = [
      'aggregate',
      'bulkWrite',
      'countDocuments',
      'createIndex',
      'createIndexes',
      'deleteMany',
      'deleteOne',
      'distinct',
      'drop',
      'dropIndex',
      'dropIndexes',
      'estimatedDocumentCount',
      'find',
      'findOne',
      'findOneAndDelete',
      'findOneAndReplace',
      'findOneAndUpdate',
      'indexes',
      'indexExists',
      'indexInformation',
      'initializeOrderedBulkOp',
      'insertMany',
      'insertOne',
      'isCapped',
      'mapReduce',
      'options',
      'parallelCollectionScan',
      'rename',
      'replaceOne',
      'stats',
      'updateMany',
      'updateOne',
  ];
  // All of the operations above take `options` and `callback` as their final parameters, but some of them
  // take additional parameters as well. For those operations, this is a map of
  // { <operation name>:  [<names of additional parameters>] }, as a way to know what to call the operation's
  // positional arguments when we add them to the span's `data` object later
  var OPERATION_SIGNATURES = {
      // aggregate intentionally not included because `pipeline` arguments are too complex to serialize well
      // see https://github.com/getsentry/sentry-javascript/pull/3102
      bulkWrite: ['operations'],
      countDocuments: ['query'],
      createIndex: ['fieldOrSpec'],
      createIndexes: ['indexSpecs'],
      deleteMany: ['filter'],
      deleteOne: ['filter'],
      distinct: ['key', 'query'],
      dropIndex: ['indexName'],
      find: ['query'],
      findOne: ['query'],
      findOneAndDelete: ['filter'],
      findOneAndReplace: ['filter', 'replacement'],
      findOneAndUpdate: ['filter', 'update'],
      indexExists: ['indexes'],
      insertMany: ['docs'],
      insertOne: ['doc'],
      mapReduce: ['map', 'reduce'],
      rename: ['newName'],
      replaceOne: ['filter', 'doc'],
      updateMany: ['filter', 'update'],
      updateOne: ['filter', 'update'],
  };
  /** Tracing integration for mongo package */
  var mongo_Mongo = /** @class */ (function () {
      /**
       * @inheritDoc
       */
      function Mongo(options) {
          if (options === void 0) { options = {}; }
          /**
           * @inheritDoc
           */
          this.name = Mongo.id;
          this._operations = Array.isArray(options.operations)
              ? options.operations
              : OPERATIONS;
          this._describeOperations = 'describeOperations' in options ? options.describeOperations : true;
          this._useMongoose = !!options.useMongoose;
      }
      /**
       * @inheritDoc
       */
      Mongo.prototype.setupOnce = function (_, getCurrentHub) {
          var moduleName = this._useMongoose ? 'mongoose' : 'mongodb';
          var pkg = Object(node["c" /* loadModule */])(moduleName);
          if (!pkg) {
              logger["a" /* logger */].error("Mongo Integration was unable to require `" + moduleName + "` package.");
              return;
          }
          this._instrumentOperations(pkg.Collection, this._operations, getCurrentHub);
      };
      /**
       * Patches original collection methods
       */
      Mongo.prototype._instrumentOperations = function (collection, operations, getCurrentHub) {
          var _this = this;
          operations.forEach(function (operation) { return _this._patchOperation(collection, operation, getCurrentHub); });
      };
      /**
       * Patches original collection to utilize our tracing functionality
       */
      Mongo.prototype._patchOperation = function (collection, operation, getCurrentHub) {
          if (!(operation in collection.prototype))
              return;
          var getSpanContext = this._getSpanContextFromOperationArguments.bind(this);
          Object(object["c" /* fill */])(collection.prototype, operation, function (orig) {
              return function () {
                  var args = [];
                  for (var _i = 0; _i < arguments.length; _i++) {
                      args[_i] = arguments[_i];
                  }
                  var _a, _b, _c, _d;
                  var lastArg = args[args.length - 1];
                  var scope = getCurrentHub().getScope();
                  var parentSpan = (_a = scope) === null || _a === void 0 ? void 0 : _a.getSpan();
                  // Check if the operation was passed a callback. (mapReduce requires a different check, as
                  // its (non-callback) arguments can also be functions.)
                  if (typeof lastArg !== 'function' || (operation === 'mapReduce' && args.length === 2)) {
                      var span_1 = (_b = parentSpan) === null || _b === void 0 ? void 0 : _b.startChild(getSpanContext(this, operation, args));
                      var maybePromise = orig.call.apply(orig, Object(tslib_tslib_es6["e" /* __spread */])([this], args));
                      if (Object(is["j" /* isThenable */])(maybePromise)) {
                          return maybePromise.then(function (res) {
                              var _a;
                              (_a = span_1) === null || _a === void 0 ? void 0 : _a.finish();
                              return res;
                          });
                      }
                      else {
                          (_c = span_1) === null || _c === void 0 ? void 0 : _c.finish();
                          return maybePromise;
                      }
                  }
                  var span = (_d = parentSpan) === null || _d === void 0 ? void 0 : _d.startChild(getSpanContext(this, operation, args.slice(0, -1)));
                  return orig.call.apply(orig, Object(tslib_tslib_es6["e" /* __spread */])([this], args.slice(0, -1), [function (err, result) {
                          var _a;
                          (_a = span) === null || _a === void 0 ? void 0 : _a.finish();
                          lastArg(err, result);
                      }]));
              };
          });
      };
      /**
       * Form a SpanContext based on the user input to a given operation.
       */
      Mongo.prototype._getSpanContextFromOperationArguments = function (collection, operation, args) {
          var data = {
              collectionName: collection.collectionName,
              dbName: collection.dbName,
              namespace: collection.namespace,
          };
          var spanContext = {
              op: "db",
              description: operation,
              data: data,
          };
          // If the operation takes no arguments besides `options` and `callback`, or if argument
          // collection is disabled for this operation, just return early.
          var signature = OPERATION_SIGNATURES[operation];
          var shouldDescribe = Array.isArray(this._describeOperations)
              ? this._describeOperations.includes(operation)
              : this._describeOperations;
          if (!signature || !shouldDescribe) {
              return spanContext;
          }
          try {
              // Special case for `mapReduce`, as the only one accepting functions as arguments.
              if (operation === 'mapReduce') {
                  var _a = Object(tslib_tslib_es6["c" /* __read */])(args, 2), map = _a[0], reduce = _a[1];
                  data[signature[0]] = typeof map === 'string' ? map : map.name || '<anonymous>';
                  data[signature[1]] = typeof reduce === 'string' ? reduce : reduce.name || '<anonymous>';
              }
              else {
                  for (var i = 0; i < signature.length; i++) {
                      data[signature[i]] = JSON.stringify(args[i]);
                  }
              }
          }
          catch (_oO) {
              // no-empty
          }
          return spanContext;
      };
      /**
       * @inheritDoc
       */
      Mongo.id = 'Mongo';
      return Mongo;
  }());
  
  //# sourceMappingURL=mongo.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/integrations/index.js
  
  
  
  
  //# sourceMappingURL=index.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/tracing/esm/index.js
  
  
  
  
  var Integrations = Object(tslib_tslib_es6["a" /* __assign */])(Object(tslib_tslib_es6["a" /* __assign */])({}, tracing_esm_integrations_namespaceObject), { BrowserTracing: browsertracing_BrowserTracing });
  
  
  
  
  
  
  
  // We are patching the global object with our hub extension methods
  Object(hubextensions["a" /* addExtensionMethods */])();
  
  
  //# sourceMappingURL=index.js.map
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/node_modules/cookie/index.js
  var cookie = __webpack_require__(122);
  
  // EXTERNAL MODULE: external "os"
  var external_os_ = __webpack_require__(32);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/handlers.js
  
  /* eslint-disable max-lines */
  /* eslint-disable @typescript-eslint/no-explicit-any */
  
  
  
  
  
  
  
  
  
  /**
   * Express-compatible tracing handler.
   * @see Exposed as `Handlers.tracingHandler`
   */
  function tracingHandler() {
      return function sentryTracingMiddleware(req, res, next) {
          // If there is a trace header set, we extract the data from it (parentSpanId, traceId, and sampling decision)
          var traceparentData;
          if (req.headers && Object(is["h" /* isString */])(req.headers['sentry-trace'])) {
              traceparentData = Object(utils["a" /* extractTraceparentData */])(req.headers['sentry-trace']);
          }
          var transaction = startTransaction(__assign({ name: extractExpressTransactionName(req, { path: true, method: true }), op: 'http.server' }, traceparentData), 
          // extra context passed to the tracesSampler
          { request: extractRequestData(req) });
          // We put the transaction on the scope so users can attach children to it
          Object(esm_hub["b" /* getCurrentHub */])().configureScope(function (scope) {
              scope.setSpan(transaction);
          });
          // We also set __sentry_transaction on the response so people can grab the transaction there to add
          // spans to it later.
          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
          res.__sentry_transaction = transaction;
          res.once('finish', function () {
              // Push `transaction.finish` to the next event loop so open spans have a chance to finish before the transaction
              // closes
              setImmediate(function () {
                  addExpressReqToTransaction(transaction, req);
                  transaction.setHttpStatus(res.statusCode);
                  transaction.finish();
              });
          });
          next();
      };
  }
  /**
   * Set parameterized as transaction name e.g.: `GET /users/:id`
   * Also adds more context data on the transaction from the request
   */
  function addExpressReqToTransaction(transaction, req) {
      if (!transaction)
          return;
      transaction.name = extractExpressTransactionName(req, { path: true, method: true });
      transaction.setData('url', req.originalUrl);
      transaction.setData('baseUrl', req.baseUrl);
      transaction.setData('query', req.query);
  }
  /**
   * Extracts complete generalized path from the request object and uses it to construct transaction name.
   *
   * eg. GET /mountpoint/user/:id
   *
   * @param req The ExpressRequest object
   * @param options What to include in the transaction name (method, path, or both)
   *
   * @returns The fully constructed transaction name
   */
  function extractExpressTransactionName(req, options) {
      if (options === void 0) { options = {}; }
      var _a;
      var method = (_a = req.method) === null || _a === void 0 ? void 0 : _a.toUpperCase();
      var path = '';
      if (req.route) {
          path = "" + (req.baseUrl || '') + req.route.path;
      }
      else if (req.originalUrl || req.url) {
          path = Object(misc["i" /* stripUrlQueryAndFragment */])(req.originalUrl || req.url || '');
      }
      var info = '';
      if (options.method && method) {
          info += method;
      }
      if (options.method && options.path) {
          info += " ";
      }
      if (options.path && path) {
          info += path;
      }
      return info;
  }
  /** JSDoc */
  function extractTransaction(req, type) {
      var _a;
      switch (type) {
          case 'path': {
              return extractExpressTransactionName(req, { path: true });
          }
          case 'handler': {
              return ((_a = req.route) === null || _a === void 0 ? void 0 : _a.stack[0].name) || '<anonymous>';
          }
          case 'methodPath':
          default: {
              return extractExpressTransactionName(req, { path: true, method: true });
          }
      }
  }
  /** Default user keys that'll be used to extract data from the request */
  var DEFAULT_USER_KEYS = ['id', 'username', 'email'];
  /** JSDoc */
  function extractUserData(user, keys) {
      var extractedUser = {};
      var attributes = Array.isArray(keys) ? keys : DEFAULT_USER_KEYS;
      attributes.forEach(function (key) {
          if (user && key in user) {
              extractedUser[key] = user[key];
          }
      });
      return extractedUser;
  }
  /** Default request keys that'll be used to extract data from the request */
  var DEFAULT_REQUEST_KEYS = ['cookies', 'data', 'headers', 'method', 'query_string', 'url'];
  /**
   * Normalizes data from the request object, accounting for framework differences.
   *
   * @param req The request object from which to extract data
   * @param keys An optional array of keys to include in the normalized data. Defaults to DEFAULT_REQUEST_KEYS if not
   * provided.
   * @returns An object containing normalized request data
   */
  function extractRequestData(req, keys) {
      if (keys === void 0) { keys = DEFAULT_REQUEST_KEYS; }
      var requestData = {};
      // headers:
      //   node, express, nextjs: req.headers
      //   koa: req.header
      var headers = (req.headers || req.header || {});
      // method:
      //   node, express, koa, nextjs: req.method
      var method = req.method;
      // host:
      //   express: req.hostname in > 4 and req.host in < 4
      //   koa: req.host
      //   node, nextjs: req.headers.host
      var host = req.hostname || req.host || headers.host || '<no host>';
      // protocol:
      //   node, nextjs: <n/a>
      //   express, koa: req.protocol
      var protocol = req.protocol === 'https' || req.secure || (req.socket || {}).encrypted
          ? 'https'
          : 'http';
      // url (including path and query string):
      //   node, express: req.originalUrl
      //   koa, nextjs: req.url
      var originalUrl = (req.originalUrl || req.url || '');
      // absolute url
      var absoluteUrl = protocol + "://" + host + originalUrl;
      keys.forEach(function (key) {
          switch (key) {
              case 'headers':
                  requestData.headers = headers;
                  break;
              case 'method':
                  requestData.method = method;
                  break;
              case 'url':
                  requestData.url = absoluteUrl;
                  break;
              case 'cookies':
                  // cookies:
                  //   node, express, koa: req.headers.cookie
                  //   vercel, sails.js, express (w/ cookie middleware), nextjs: req.cookies
                  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                  requestData.cookies = req.cookies || cookie["parse"](headers.cookie || '');
                  break;
              case 'query_string':
                  // query string:
                  //   node: req.url (raw)
                  //   express, koa, nextjs: req.query
                  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                  requestData.query_string = req.query || external_url_["parse"](originalUrl || '', false).query;
                  break;
              case 'data':
                  if (method === 'GET' || method === 'HEAD') {
                      break;
                  }
                  // body data:
                  //   express, koa, nextjs: req.body
                  //
                  //   when using node by itself, you have to read the incoming stream(see
                  //   https://nodejs.dev/learn/get-http-request-body-data-using-nodejs); if a user is doing that, we can't know
                  //   where they're going to store the final result, so they'll have to capture this data themselves
                  if (req.body !== undefined) {
                      requestData.data = Object(is["h" /* isString */])(req.body) ? req.body : JSON.stringify(Object(object["d" /* normalize */])(req.body));
                  }
                  break;
              default:
                  if ({}.hasOwnProperty.call(req, key)) {
                      requestData[key] = req[key];
                  }
          }
      });
      return requestData;
  }
  /**
   * Enriches passed event with request data.
   *
   * @param event Will be mutated and enriched with req data
   * @param req Request object
   * @param options object containing flags to enable functionality
   * @hidden
   */
  function parseRequest(event, req, options) {
      // eslint-disable-next-line no-param-reassign
      options = __assign({ ip: false, request: true, serverName: true, transaction: true, user: true, version: true }, options);
      if (options.version) {
          event.contexts = __assign(__assign({}, event.contexts), { runtime: {
                  name: 'node',
                  version: global.process.version,
              } });
      }
      if (options.request) {
          // if the option value is `true`, use the default set of keys by not passing anything to `extractRequestData()`
          var extractedRequestData = Array.isArray(options.request)
              ? extractRequestData(req, options.request)
              : extractRequestData(req);
          event.request = __assign(__assign({}, event.request), extractedRequestData);
      }
      if (options.serverName && !event.server_name) {
          event.server_name = global.process.env.SENTRY_NAME || external_os_["hostname"]();
      }
      if (options.user) {
          var extractedUser = req.user && Object(is["e" /* isPlainObject */])(req.user) ? extractUserData(req.user, options.user) : {};
          if (Object.keys(extractedUser)) {
              event.user = __assign(__assign({}, event.user), extractedUser);
          }
      }
      // client ip:
      //   node, nextjs: req.connection.remoteAddress
      //   express, koa: req.ip
      if (options.ip) {
          var ip = req.ip || (req.connection && req.connection.remoteAddress);
          if (ip) {
              event.user = __assign(__assign({}, event.user), { ip_address: ip });
          }
      }
      if (options.transaction && !event.transaction) {
          // TODO do we even need this anymore?
          // TODO make this work for nextjs
          event.transaction = extractTransaction(req, options.transaction);
      }
      return event;
  }
  /**
   * Express compatible request handler.
   * @see Exposed as `Handlers.requestHandler`
   */
  function requestHandler(options) {
      var currentHub = Object(esm_hub["b" /* getCurrentHub */])();
      var client = currentHub.getClient();
      // Initialise an instance of SessionFlusher on the client when `autoSessionTracking` is enabled and the
      // `requestHandler` middleware is used indicating that we are running in SessionAggregates mode
      if (client && isAutoSessionTrackingEnabled(client)) {
          client.initSessionFlusher();
          // If Scope contains a Single mode Session, it is removed in favor of using Session Aggregates mode
          var scope = currentHub.getScope();
          if (scope && scope.getSession()) {
              scope.setSession();
          }
      }
      return function sentryRequestMiddleware(req, res, next) {
          if (options && options.flushTimeout && options.flushTimeout > 0) {
              // eslint-disable-next-line @typescript-eslint/unbound-method
              var _end_1 = res.end;
              res.end = function (chunk, encoding, cb) {
                  var _this = this;
                  void flush(options.flushTimeout)
                      .then(function () {
                      _end_1.call(_this, chunk, encoding, cb);
                  })
                      .then(null, function (e) {
                      logger["a" /* logger */].error(e);
                  });
              };
          }
          var local = external_domain_["create"]();
          local.add(req);
          local.add(res);
          local.on('error', next);
          local.run(function () {
              var currentHub = Object(esm_hub["b" /* getCurrentHub */])();
              currentHub.configureScope(function (scope) {
                  scope.addEventProcessor(function (event) { return parseRequest(event, req, options); });
                  var client = currentHub.getClient();
                  if (isAutoSessionTrackingEnabled(client)) {
                      var scope_1 = currentHub.getScope();
                      if (scope_1) {
                          // Set `status` of `RequestSession` to Ok, at the beginning of the request
                          scope_1.setRequestSession({ status: esm_session["a" /* RequestSessionStatus */].Ok });
                      }
                  }
              });
              res.once('finish', function () {
                  var client = currentHub.getClient();
                  if (isAutoSessionTrackingEnabled(client)) {
                      setImmediate(function () {
                          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                          if (client && client._captureRequestSession) {
                              // Calling _captureRequestSession to capture request session at the end of the request by incrementing
                              // the correct SessionAggregates bucket i.e. crashed, errored or exited
                              // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                              client._captureRequestSession();
                          }
                      });
                  }
              });
              next();
          });
      };
  }
  /** JSDoc */
  function getStatusCodeFromResponse(error) {
      var statusCode = error.status || error.statusCode || error.status_code || (error.output && error.output.statusCode);
      return statusCode ? parseInt(statusCode, 10) : 500;
  }
  /** Returns true if response code is internal server error */
  function defaultShouldHandleError(error) {
      var status = getStatusCodeFromResponse(error);
      return status >= 500;
  }
  /**
   * Express compatible error handler.
   * @see Exposed as `Handlers.errorHandler`
   */
  function errorHandler(options) {
      return function sentryErrorMiddleware(error, _req, res, next) {
          // eslint-disable-next-line @typescript-eslint/unbound-method
          var shouldHandleError = (options && options.shouldHandleError) || defaultShouldHandleError;
          if (shouldHandleError(error)) {
              withScope(function (_scope) {
                  // For some reason we need to set the transaction on the scope again
                  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                  var transaction = res.__sentry_transaction;
                  if (transaction && _scope.getSpan() === undefined) {
                      _scope.setSpan(transaction);
                  }
                  var client = Object(esm_hub["b" /* getCurrentHub */])().getClient();
                  if (client && isAutoSessionTrackingEnabled(client)) {
                      // Check if the `SessionFlusher` is instantiated on the client to go into this branch that marks the
                      // `requestSession.status` as `Crashed`, and this check is necessary because the `SessionFlusher` is only
                      // instantiated when the the`requestHandler` middleware is initialised, which indicates that we should be
                      // running in SessionAggregates mode
                      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                      var isSessionAggregatesMode = client._sessionFlusher !== undefined;
                      if (isSessionAggregatesMode) {
                          var requestSession = _scope.getRequestSession();
                          // If an error bubbles to the `errorHandler`, then this is an unhandled error, and should be reported as a
                          // Crashed session. The `_requestSession.status` is checked to ensure that this error is happening within
                          // the bounds of a request, and if so the status is updated
                          if (requestSession && requestSession.status !== undefined)
                              requestSession.status = esm_session["a" /* RequestSessionStatus */].Crashed;
                      }
                  }
                  var eventId = captureException(error);
                  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                  res.sentry = eventId;
                  next(error);
              });
              return;
          }
          next(error);
      };
  }
  //# sourceMappingURL=handlers.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/node/esm/index.js
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  var INTEGRATIONS = __assign(__assign({}, integrations_namespaceObject), esm_integrations_namespaceObject);
  
  // We need to patch domain on the global __SENTRY__ object to make it work for node in cross-platform packages like
  // @sentry/hub. If we don't do this, browser bundlers will have troubles resolving `require('domain')`.
  var esm_carrier = Object(esm_hub["d" /* getMainCarrier */])();
  if (esm_carrier.__SENTRY__) {
      esm_carrier.__SENTRY__.extensions = esm_carrier.__SENTRY__.extensions || {};
      esm_carrier.__SENTRY__.extensions.domain = esm_carrier.__SENTRY__.extensions.domain || external_domain_;
  }
  //# sourceMappingURL=index.js.map
  
  /***/ }),
  
  /***/ 196:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Outcome; });
  var Outcome;
  (function (Outcome) {
      Outcome["BeforeSend"] = "before_send";
      Outcome["EventProcessor"] = "event_processor";
      Outcome["NetworkError"] = "network_error";
      Outcome["QueueOverflow"] = "queue_overflow";
      Outcome["RateLimitBackoff"] = "ratelimit_backoff";
      Outcome["SampleRate"] = "sample_rate";
  })(Outcome || (Outcome = {}));
  //# sourceMappingURL=transport.js.map
  
  /***/ }),
  
  /***/ 2:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* unused harmony export __extends */
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return __assign; });
  /* unused harmony export __rest */
  /* unused harmony export __decorate */
  /* unused harmony export __param */
  /* unused harmony export __metadata */
  /* unused harmony export __awaiter */
  /* unused harmony export __generator */
  /* unused harmony export __createBinding */
  /* unused harmony export __exportStar */
  /* unused harmony export __values */
  /* unused harmony export __read */
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return __spread; });
  /* unused harmony export __spreadArrays */
  /* unused harmony export __await */
  /* unused harmony export __asyncGenerator */
  /* unused harmony export __asyncDelegator */
  /* unused harmony export __asyncValues */
  /* unused harmony export __makeTemplateObject */
  /* unused harmony export __importStar */
  /* unused harmony export __importDefault */
  /* unused harmony export __classPrivateFieldGet */
  /* unused harmony export __classPrivateFieldSet */
  /*! *****************************************************************************
  Copyright (c) Microsoft Corporation.
  
  Permission to use, copy, modify, and/or distribute this software for any
  purpose with or without fee is hereby granted.
  
  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  PERFORMANCE OF THIS SOFTWARE.
  ***************************************************************************** */
  /* global Reflect, Promise */
  
  var extendStatics = function(d, b) {
      extendStatics = Object.setPrototypeOf ||
          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
          function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
      return extendStatics(d, b);
  };
  
  function __extends(d, b) {
      extendStatics(d, b);
      function __() { this.constructor = d; }
      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  }
  
  var __assign = function() {
      __assign = Object.assign || function __assign(t) {
          for (var s, i = 1, n = arguments.length; i < n; i++) {
              s = arguments[i];
              for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
          }
          return t;
      }
      return __assign.apply(this, arguments);
  }
  
  function __rest(s, e) {
      var t = {};
      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
          t[p] = s[p];
      if (s != null && typeof Object.getOwnPropertySymbols === "function")
          for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
              if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                  t[p[i]] = s[p[i]];
          }
      return t;
  }
  
  function __decorate(decorators, target, key, desc) {
      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
      else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
      return c > 3 && r && Object.defineProperty(target, key, r), r;
  }
  
  function __param(paramIndex, decorator) {
      return function (target, key) { decorator(target, key, paramIndex); }
  }
  
  function __metadata(metadataKey, metadataValue) {
      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
  }
  
  function __awaiter(thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  }
  
  function __generator(thisArg, body) {
      var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
      function verb(n) { return function (v) { return step([n, v]); }; }
      function step(op) {
          if (f) throw new TypeError("Generator is already executing.");
          while (_) try {
              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
              if (y = 0, t) op = [op[0] & 2, t.value];
              switch (op[0]) {
                  case 0: case 1: t = op; break;
                  case 4: _.label++; return { value: op[1], done: false };
                  case 5: _.label++; y = op[1]; op = [0]; continue;
                  case 7: op = _.ops.pop(); _.trys.pop(); continue;
                  default:
                      if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                      if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                      if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                      if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                      if (t[2]) _.ops.pop();
                      _.trys.pop(); continue;
              }
              op = body.call(thisArg, _);
          } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
          if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
      }
  }
  
  function __createBinding(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }
  
  function __exportStar(m, exports) {
      for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];
  }
  
  function __values(o) {
      var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
      if (m) return m.call(o);
      if (o && typeof o.length === "number") return {
          next: function () {
              if (o && i >= o.length) o = void 0;
              return { value: o && o[i++], done: !o };
          }
      };
      throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
  }
  
  function __read(o, n) {
      var m = typeof Symbol === "function" && o[Symbol.iterator];
      if (!m) return o;
      var i = m.call(o), r, ar = [], e;
      try {
          while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
      }
      catch (error) { e = { error: error }; }
      finally {
          try {
              if (r && !r.done && (m = i["return"])) m.call(i);
          }
          finally { if (e) throw e.error; }
      }
      return ar;
  }
  
  function __spread() {
      for (var ar = [], i = 0; i < arguments.length; i++)
          ar = ar.concat(__read(arguments[i]));
      return ar;
  }
  
  function __spreadArrays() {
      for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
      for (var r = Array(s), k = 0, i = 0; i < il; i++)
          for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
              r[k] = a[j];
      return r;
  };
  
  function __await(v) {
      return this instanceof __await ? (this.v = v, this) : new __await(v);
  }
  
  function __asyncGenerator(thisArg, _arguments, generator) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var g = generator.apply(thisArg, _arguments || []), i, q = [];
      return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
      function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
      function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
      function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
      function fulfill(value) { resume("next", value); }
      function reject(value) { resume("throw", value); }
      function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
  }
  
  function __asyncDelegator(o) {
      var i, p;
      return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
      function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
  }
  
  function __asyncValues(o) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var m = o[Symbol.asyncIterator], i;
      return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
      function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
      function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
  }
  
  function __makeTemplateObject(cooked, raw) {
      if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
      return cooked;
  };
  
  function __importStar(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result.default = mod;
      return result;
  }
  
  function __importDefault(mod) {
      return (mod && mod.__esModule) ? mod : { default: mod };
  }
  
  function __classPrivateFieldGet(receiver, privateMap) {
      if (!privateMap.has(receiver)) {
          throw new TypeError("attempted to get private field on non-instance");
      }
      return privateMap.get(receiver);
  }
  
  function __classPrivateFieldSet(receiver, privateMap, value) {
      if (!privateMap.has(receiver)) {
          throw new TypeError("attempted to set private field on non-instance");
      }
      privateMap.set(receiver, value);
      return value;
  }
  
  
  /***/ }),
  
  /***/ 20:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(module) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return isNodeEnv; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return dynamicRequire; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return loadModule; });
  /**
   * Checks whether we're in the Node.js or Browser environment
   *
   * @returns Answer to given question
   */
  function isNodeEnv() {
      return Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';
  }
  /**
   * Requires a module which is protected against bundler minification.
   *
   * @param request The module path to resolve
   */
  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
  function dynamicRequire(mod, request) {
      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
      return mod.require(request);
  }
  /**
   * Helper for dynamically loading module that should work with linked dependencies.
   * The problem is that we _should_ be using `require(require.resolve(moduleName, { paths: [cwd()] }))`
   * However it's _not possible_ to do that with Webpack, as it has to know all the dependencies during
   * build time. `require.resolve` is also not available in any other way, so we cannot create,
   * a fake helper like we do with `dynamicRequire`.
   *
   * We always prefer to use local package, thus the value is not returned early from each `try/catch` block.
   * That is to mimic the behavior of `require.resolve` exactly.
   *
   * @param moduleName module name to require
   * @returns possibly required module
   */
  function loadModule(moduleName) {
      var mod;
      try {
          mod = dynamicRequire(module, moduleName);
      }
      catch (e) {
          // no-empty
      }
      try {
          var cwd = dynamicRequire(module, 'process').cwd;
          mod = dynamicRequire(module, cwd() + "/node_modules/" + moduleName);
      }
      catch (e) {
          // no-empty
      }
      return mod;
  }
  //# sourceMappingURL=node.js.map
  /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(74)(module)))
  
  /***/ }),
  
  /***/ 21:
  /***/ (function(module, exports) {
  
  module.exports = require("path");
  
  /***/ }),
  
  /***/ 23:
  /***/ (function(module, exports) {
  
  module.exports = require("url");
  
  /***/ }),
  
  /***/ 24:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return STRICT_STANDARD_ERROR_FIELDS; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return QUASI_STANDARD_ERROR_FIELDS; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return COMMON_ERROR_FIELDS; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return COMMON_ERROR_FIELDS_EXTENDED; });
  const STRICT_STANDARD_ERROR_FIELDS = new Set([// standard fields
  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/prototype
  'name', 'message']);
  const QUASI_STANDARD_ERROR_FIELDS = new Set([// first inherit from previous
  // conv to array needed due to a babel bug 😢
  ...Array.from(STRICT_STANDARD_ERROR_FIELDS), // quasi-standard: followed by all browsers + node
  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/prototype
  'stack']);
  const COMMON_ERROR_FIELDS = new Set([// first inherit from previous
  // conv to array needed due to a babel bug 😢
  ...Array.from(QUASI_STANDARD_ERROR_FIELDS), // standard in node only:
  'code', // https://nodejs.org/dist/latest/docs/api/errors.html#errors_node_js_error_codes
  // non standard but widely used:
  'statusCode', 'shouldRedirect', 'framesToPop' // see facebook https://github.com/facebook/flux/blob/2.0.2/src/invariant.js
  ]);
  const COMMON_ERROR_FIELDS_EXTENDED = new Set([// first inherit from previous
  // conv to array needed due to a babel bug 😢
  ...Array.from(COMMON_ERROR_FIELDS), // My (Offirmo) extensions:
  '_temp', 'details' // hash to store any other property not defined in this set
  // To evaluate if need arises:
  // TODO triage field?
  // TODO timestamp?
  ]);
  
  /***/ }),
  
  /***/ 25:
  /***/ (function(module, exports) {
  
  module.exports = require("events");
  
  /***/ }),
  
  /***/ 26:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  
  // EXPORTS
  __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ hub_Hub; });
  __webpack_require__.d(__webpack_exports__, "d", function() { return /* binding */ getMainCarrier; });
  __webpack_require__.d(__webpack_exports__, "e", function() { return /* binding */ makeMain; });
  __webpack_require__.d(__webpack_exports__, "b", function() { return /* binding */ getCurrentHub; });
  __webpack_require__.d(__webpack_exports__, "c", function() { return /* binding */ getHubFromCarrier; });
  __webpack_require__.d(__webpack_exports__, "f", function() { return /* binding */ setHubOnCarrier; });
  
  // UNUSED EXPORTS: API_VERSION, getActiveDomain
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/hub/node_modules/tslib/tslib.es6.js
  var tslib_es6 = __webpack_require__(2);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/types/esm/session.js
  var esm_session = __webpack_require__(316);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/misc.js
  var misc = __webpack_require__(11);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/time.js
  var time = __webpack_require__(37);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/logger.js
  var logger = __webpack_require__(8);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/node.js
  var node = __webpack_require__(20);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/hub/esm/scope.js
  var esm_scope = __webpack_require__(58);
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/utils/esm/object.js + 1 modules
  var object = __webpack_require__(14);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/hub/esm/session.js
  
  
  /**
   * @inheritdoc
   */
  var session_Session = /** @class */ (function () {
      function Session(context) {
          this.errors = 0;
          this.sid = Object(misc["j" /* uuid4 */])();
          this.duration = 0;
          this.status = esm_session["b" /* SessionStatus */].Ok;
          this.init = true;
          this.ignoreDuration = false;
          // Both timestamp and started are in seconds since the UNIX epoch.
          var startingTime = Object(time["c" /* timestampInSeconds */])();
          this.timestamp = startingTime;
          this.started = startingTime;
          if (context) {
              this.update(context);
          }
      }
      /** JSDoc */
      // eslint-disable-next-line complexity
      Session.prototype.update = function (context) {
          if (context === void 0) { context = {}; }
          if (context.user) {
              if (!this.ipAddress && context.user.ip_address) {
                  this.ipAddress = context.user.ip_address;
              }
              if (!this.did && !context.did) {
                  this.did = context.user.id || context.user.email || context.user.username;
              }
          }
          this.timestamp = context.timestamp || Object(time["c" /* timestampInSeconds */])();
          if (context.ignoreDuration) {
              this.ignoreDuration = context.ignoreDuration;
          }
          if (context.sid) {
              // Good enough uuid validation. — Kamil
              this.sid = context.sid.length === 32 ? context.sid : Object(misc["j" /* uuid4 */])();
          }
          if (context.init !== undefined) {
              this.init = context.init;
          }
          if (!this.did && context.did) {
              this.did = "" + context.did;
          }
          if (typeof context.started === 'number') {
              this.started = context.started;
          }
          if (this.ignoreDuration) {
              this.duration = undefined;
          }
          else if (typeof context.duration === 'number') {
              this.duration = context.duration;
          }
          else {
              var duration = this.timestamp - this.started;
              this.duration = duration >= 0 ? duration : 0;
          }
          if (context.release) {
              this.release = context.release;
          }
          if (context.environment) {
              this.environment = context.environment;
          }
          if (!this.ipAddress && context.ipAddress) {
              this.ipAddress = context.ipAddress;
          }
          if (!this.userAgent && context.userAgent) {
              this.userAgent = context.userAgent;
          }
          if (typeof context.errors === 'number') {
              this.errors = context.errors;
          }
          if (context.status) {
              this.status = context.status;
          }
      };
      /** JSDoc */
      Session.prototype.close = function (status) {
          if (status) {
              this.update({ status: status });
          }
          else if (this.status === esm_session["b" /* SessionStatus */].Ok) {
              this.update({ status: esm_session["b" /* SessionStatus */].Exited });
          }
          else {
              this.update();
          }
      };
      /** JSDoc */
      Session.prototype.toJSON = function () {
          return Object(object["a" /* dropUndefinedKeys */])({
              sid: "" + this.sid,
              init: this.init,
              // Make sure that sec is converted to ms for date constructor
              started: new Date(this.started * 1000).toISOString(),
              timestamp: new Date(this.timestamp * 1000).toISOString(),
              status: this.status,
              errors: this.errors,
              did: typeof this.did === 'number' || typeof this.did === 'string' ? "" + this.did : undefined,
              duration: this.duration,
              attrs: Object(object["a" /* dropUndefinedKeys */])({
                  release: this.release,
                  environment: this.environment,
                  ip_address: this.ipAddress,
                  user_agent: this.userAgent,
              }),
          });
      };
      return Session;
  }());
  
  //# sourceMappingURL=session.js.map
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/@sentry/hub/esm/hub.js
  
  /* eslint-disable max-lines */
  
  
  
  
  /**
   * API compatibility version of this hub.
   *
   * WARNING: This number should only be increased when the global interface
   * changes and new methods are introduced.
   *
   * @hidden
   */
  var API_VERSION = 4;
  /**
   * Default maximum number of breadcrumbs added to an event. Can be overwritten
   * with {@link Options.maxBreadcrumbs}.
   */
  var DEFAULT_BREADCRUMBS = 100;
  /**
   * @inheritDoc
   */
  var hub_Hub = /** @class */ (function () {
      /**
       * Creates a new instance of the hub, will push one {@link Layer} into the
       * internal stack on creation.
       *
       * @param client bound to the hub.
       * @param scope bound to the hub.
       * @param version number, higher number means higher priority.
       */
      function Hub(client, scope, _version) {
          if (scope === void 0) { scope = new esm_scope["a" /* Scope */](); }
          if (_version === void 0) { _version = API_VERSION; }
          this._version = _version;
          /** Is a {@link Layer}[] containing the client and scope */
          this._stack = [{}];
          this.getStackTop().scope = scope;
          if (client) {
              this.bindClient(client);
          }
      }
      /**
       * @inheritDoc
       */
      Hub.prototype.isOlderThan = function (version) {
          return this._version < version;
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.bindClient = function (client) {
          var top = this.getStackTop();
          top.client = client;
          if (client && client.setupIntegrations) {
              client.setupIntegrations();
          }
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.pushScope = function () {
          // We want to clone the content of prev scope
          var scope = esm_scope["a" /* Scope */].clone(this.getScope());
          this.getStack().push({
              client: this.getClient(),
              scope: scope,
          });
          return scope;
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.popScope = function () {
          if (this.getStack().length <= 1)
              return false;
          return !!this.getStack().pop();
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.withScope = function (callback) {
          var scope = this.pushScope();
          try {
              callback(scope);
          }
          finally {
              this.popScope();
          }
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.getClient = function () {
          return this.getStackTop().client;
      };
      /** Returns the scope of the top stack. */
      Hub.prototype.getScope = function () {
          return this.getStackTop().scope;
      };
      /** Returns the scope stack for domains or the process. */
      Hub.prototype.getStack = function () {
          return this._stack;
      };
      /** Returns the topmost scope layer in the order domain > local > process. */
      Hub.prototype.getStackTop = function () {
          return this._stack[this._stack.length - 1];
      };
      /**
       * @inheritDoc
       */
      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
      Hub.prototype.captureException = function (exception, hint) {
          var eventId = (this._lastEventId = Object(misc["j" /* uuid4 */])());
          var finalHint = hint;
          // If there's no explicit hint provided, mimic the same thing that would happen
          // in the minimal itself to create a consistent behavior.
          // We don't do this in the client, as it's the lowest level API, and doing this,
          // would prevent user from having full control over direct calls.
          if (!hint) {
              var syntheticException = void 0;
              try {
                  throw new Error('Sentry syntheticException');
              }
              catch (exception) {
                  syntheticException = exception;
              }
              finalHint = {
                  originalException: exception,
                  syntheticException: syntheticException,
              };
          }
          this._invokeClient('captureException', exception, Object(tslib_es6["a" /* __assign */])(Object(tslib_es6["a" /* __assign */])({}, finalHint), { event_id: eventId }));
          return eventId;
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.captureMessage = function (message, level, hint) {
          var eventId = (this._lastEventId = Object(misc["j" /* uuid4 */])());
          var finalHint = hint;
          // If there's no explicit hint provided, mimic the same thing that would happen
          // in the minimal itself to create a consistent behavior.
          // We don't do this in the client, as it's the lowest level API, and doing this,
          // would prevent user from having full control over direct calls.
          if (!hint) {
              var syntheticException = void 0;
              try {
                  throw new Error(message);
              }
              catch (exception) {
                  syntheticException = exception;
              }
              finalHint = {
                  originalException: message,
                  syntheticException: syntheticException,
              };
          }
          this._invokeClient('captureMessage', message, level, Object(tslib_es6["a" /* __assign */])(Object(tslib_es6["a" /* __assign */])({}, finalHint), { event_id: eventId }));
          return eventId;
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.captureEvent = function (event, hint) {
          var eventId = Object(misc["j" /* uuid4 */])();
          if (event.type !== 'transaction') {
              this._lastEventId = eventId;
          }
          this._invokeClient('captureEvent', event, Object(tslib_es6["a" /* __assign */])(Object(tslib_es6["a" /* __assign */])({}, hint), { event_id: eventId }));
          return eventId;
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.lastEventId = function () {
          return this._lastEventId;
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.addBreadcrumb = function (breadcrumb, hint) {
          var _a = this.getStackTop(), scope = _a.scope, client = _a.client;
          if (!scope || !client)
              return;
          // eslint-disable-next-line @typescript-eslint/unbound-method
          var _b = (client.getOptions && client.getOptions()) || {}, _c = _b.beforeBreadcrumb, beforeBreadcrumb = _c === void 0 ? null : _c, _d = _b.maxBreadcrumbs, maxBreadcrumbs = _d === void 0 ? DEFAULT_BREADCRUMBS : _d;
          if (maxBreadcrumbs <= 0)
              return;
          var timestamp = Object(time["b" /* dateTimestampInSeconds */])();
          var mergedBreadcrumb = Object(tslib_es6["a" /* __assign */])({ timestamp: timestamp }, breadcrumb);
          var finalBreadcrumb = beforeBreadcrumb
              ? Object(misc["d" /* consoleSandbox */])(function () { return beforeBreadcrumb(mergedBreadcrumb, hint); })
              : mergedBreadcrumb;
          if (finalBreadcrumb === null)
              return;
          scope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.setUser = function (user) {
          var scope = this.getScope();
          if (scope)
              scope.setUser(user);
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.setTags = function (tags) {
          var scope = this.getScope();
          if (scope)
              scope.setTags(tags);
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.setExtras = function (extras) {
          var scope = this.getScope();
          if (scope)
              scope.setExtras(extras);
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.setTag = function (key, value) {
          var scope = this.getScope();
          if (scope)
              scope.setTag(key, value);
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.setExtra = function (key, extra) {
          var scope = this.getScope();
          if (scope)
              scope.setExtra(key, extra);
      };
      /**
       * @inheritDoc
       */
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      Hub.prototype.setContext = function (name, context) {
          var scope = this.getScope();
          if (scope)
              scope.setContext(name, context);
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.configureScope = function (callback) {
          var _a = this.getStackTop(), scope = _a.scope, client = _a.client;
          if (scope && client) {
              callback(scope);
          }
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.run = function (callback) {
          var oldHub = makeMain(this);
          try {
              callback(this);
          }
          finally {
              makeMain(oldHub);
          }
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.getIntegration = function (integration) {
          var client = this.getClient();
          if (!client)
              return null;
          try {
              return client.getIntegration(integration);
          }
          catch (_oO) {
              logger["a" /* logger */].warn("Cannot retrieve integration " + integration.id + " from the current Hub");
              return null;
          }
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.startSpan = function (context) {
          return this._callExtensionMethod('startSpan', context);
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.startTransaction = function (context, customSamplingContext) {
          return this._callExtensionMethod('startTransaction', context, customSamplingContext);
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.traceHeaders = function () {
          return this._callExtensionMethod('traceHeaders');
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.captureSession = function (endSession) {
          if (endSession === void 0) { endSession = false; }
          // both send the update and pull the session from the scope
          if (endSession) {
              return this.endSession();
          }
          // only send the update
          this._sendSessionUpdate();
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.endSession = function () {
          var _a, _b, _c, _d, _e;
          (_c = (_b = (_a = this.getStackTop()) === null || _a === void 0 ? void 0 : _a.scope) === null || _b === void 0 ? void 0 : _b.getSession()) === null || _c === void 0 ? void 0 : _c.close();
          this._sendSessionUpdate();
          // the session is over; take it off of the scope
          (_e = (_d = this.getStackTop()) === null || _d === void 0 ? void 0 : _d.scope) === null || _e === void 0 ? void 0 : _e.setSession();
      };
      /**
       * @inheritDoc
       */
      Hub.prototype.startSession = function (context) {
          var _a = this.getStackTop(), scope = _a.scope, client = _a.client;
          var _b = (client && client.getOptions()) || {}, release = _b.release, environment = _b.environment;
          // Will fetch userAgent if called from browser sdk
          var global = Object(misc["f" /* getGlobalObject */])();
          var userAgent = (global.navigator || {}).userAgent;
          var session = new session_Session(Object(tslib_es6["a" /* __assign */])(Object(tslib_es6["a" /* __assign */])(Object(tslib_es6["a" /* __assign */])({ release: release,
              environment: environment }, (scope && { user: scope.getUser() })), (userAgent && { userAgent: userAgent })), context));
          if (scope) {
              // End existing session if there's one
              var currentSession = scope.getSession && scope.getSession();
              if (currentSession && currentSession.status === esm_session["b" /* SessionStatus */].Ok) {
                  currentSession.update({ status: esm_session["b" /* SessionStatus */].Exited });
              }
              this.endSession();
              // Afterwards we set the new session on the scope
              scope.setSession(session);
          }
          return session;
      };
      /**
       * Sends the current Session on the scope
       */
      Hub.prototype._sendSessionUpdate = function () {
          var _a = this.getStackTop(), scope = _a.scope, client = _a.client;
          if (!scope)
              return;
          var session = scope.getSession && scope.getSession();
          if (session) {
              if (client && client.captureSession) {
                  client.captureSession(session);
              }
          }
      };
      /**
       * Internal helper function to call a method on the top client if it exists.
       *
       * @param method The method to call on the client.
       * @param args Arguments to pass to the client function.
       */
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      Hub.prototype._invokeClient = function (method) {
          var _a;
          var args = [];
          for (var _i = 1; _i < arguments.length; _i++) {
              args[_i - 1] = arguments[_i];
          }
          var _b = this.getStackTop(), scope = _b.scope, client = _b.client;
          if (client && client[method]) {
              // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
              (_a = client)[method].apply(_a, Object(tslib_es6["b" /* __spread */])(args, [scope]));
          }
      };
      /**
       * Calls global extension method and binding current instance to the function call
       */
      // @ts-ignore Function lacks ending return statement and return type does not include 'undefined'. ts(2366)
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      Hub.prototype._callExtensionMethod = function (method) {
          var args = [];
          for (var _i = 1; _i < arguments.length; _i++) {
              args[_i - 1] = arguments[_i];
          }
          var carrier = getMainCarrier();
          var sentry = carrier.__SENTRY__;
          if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {
              return sentry.extensions[method].apply(this, args);
          }
          logger["a" /* logger */].warn("Extension method " + method + " couldn't be found, doing nothing.");
      };
      return Hub;
  }());
  
  /**
   * Returns the global shim registry.
   *
   * FIXME: This function is problematic, because despite always returning a valid Carrier,
   * it has an optional `__SENTRY__` property, which then in turn requires us to always perform an unnecessary check
   * at the call-site. We always access the carrier through this function, so we can guarantee that `__SENTRY__` is there.
   **/
  function getMainCarrier() {
      var carrier = Object(misc["f" /* getGlobalObject */])();
      carrier.__SENTRY__ = carrier.__SENTRY__ || {
          extensions: {},
          hub: undefined,
      };
      return carrier;
  }
  /**
   * Replaces the current main hub with the passed one on the global object
   *
   * @returns The old replaced hub
   */
  function makeMain(hub) {
      var registry = getMainCarrier();
      var oldHub = getHubFromCarrier(registry);
      setHubOnCarrier(registry, hub);
      return oldHub;
  }
  /**
   * Returns the default hub instance.
   *
   * If a hub is already registered in the global carrier but this module
   * contains a more recent version, it replaces the registered version.
   * Otherwise, the currently registered hub will be returned.
   */
  function getCurrentHub() {
      // Get main carrier (global for every environment)
      var registry = getMainCarrier();
      // If there's no hub, or its an old API, assign a new one
      if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {
          setHubOnCarrier(registry, new hub_Hub());
      }
      // Prefer domains over global if they are there (applicable only to Node environment)
      if (Object(node["b" /* isNodeEnv */])()) {
          return getHubFromActiveDomain(registry);
      }
      // Return hub that lives on a global object
      return getHubFromCarrier(registry);
  }
  /**
   * Returns the active domain, if one exists
   * @deprecated No longer used; remove in v7
   * @returns The domain, or undefined if there is no active domain
   */
  // eslint-disable-next-line deprecation/deprecation
  function getActiveDomain() {
      logger["a" /* logger */].warn('Function `getActiveDomain` is deprecated and will be removed in a future version.');
      var sentry = getMainCarrier().__SENTRY__;
      return sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active;
  }
  /**
   * Try to read the hub from an active domain, and fallback to the registry if one doesn't exist
   * @returns discovered hub
   */
  function getHubFromActiveDomain(registry) {
      var _a, _b, _c;
      try {
          var activeDomain = (_c = (_b = (_a = getMainCarrier().__SENTRY__) === null || _a === void 0 ? void 0 : _a.extensions) === null || _b === void 0 ? void 0 : _b.domain) === null || _c === void 0 ? void 0 : _c.active;
          // If there's no active domain, just return global hub
          if (!activeDomain) {
              return getHubFromCarrier(registry);
          }
          // If there's no hub on current domain, or it's an old API, assign a new one
          if (!hasHubOnCarrier(activeDomain) || getHubFromCarrier(activeDomain).isOlderThan(API_VERSION)) {
              var registryHubTopStack = getHubFromCarrier(registry).getStackTop();
              setHubOnCarrier(activeDomain, new hub_Hub(registryHubTopStack.client, esm_scope["a" /* Scope */].clone(registryHubTopStack.scope)));
          }
          // Return hub that lives on a domain
          return getHubFromCarrier(activeDomain);
      }
      catch (_Oo) {
          // Return hub that lives on a global object
          return getHubFromCarrier(registry);
      }
  }
  /**
   * This will tell whether a carrier has a hub on it or not
   * @param carrier object
   */
  function hasHubOnCarrier(carrier) {
      return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);
  }
  /**
   * This will create a new {@link Hub} and add to the passed object on
   * __SENTRY__.hub.
   * @param carrier object
   * @hidden
   */
  function getHubFromCarrier(carrier) {
      if (carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub)
          return carrier.__SENTRY__.hub;
      carrier.__SENTRY__ = carrier.__SENTRY__ || {};
      carrier.__SENTRY__.hub = new hub_Hub();
      return carrier.__SENTRY__.hub;
  }
  /**
   * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute
   * @param carrier object
   * @param hub Hub
   * @returns A boolean indicating success or failure
   */
  function setHubOnCarrier(carrier, hub) {
      if (!carrier)
          return false;
      carrier.__SENTRY__ = carrier.__SENTRY__ || {};
      carrier.__SENTRY__.hub = hub;
      return true;
  }
  //# sourceMappingURL=hub.js.map
  
  /***/ }),
  
  /***/ 28:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(module) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return startIdleTransaction; });
  /* unused harmony export _addTracingExtensions */
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return addExtensionMethods; });
  /* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1);
  /* harmony import */ var _sentry_hub__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(26);
  /* harmony import */ var _sentry_types__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(59);
  /* harmony import */ var _sentry_utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(8);
  /* harmony import */ var _sentry_utils__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(20);
  /* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(121);
  /* harmony import */ var _idletransaction__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(34);
  /* harmony import */ var _transaction__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(35);
  /* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(5);
  
  
  
  
  
  
  
  
  /** Returns all trace headers that are currently on the top scope. */
  function traceHeaders() {
      var scope = this.getScope();
      if (scope) {
          var span = scope.getSpan();
          if (span) {
              return {
                  'sentry-trace': span.toTraceparent(),
              };
          }
      }
      return {};
  }
  /**
   * Makes a sampling decision for the given transaction and stores it on the transaction.
   *
   * Called every time a transaction is created. Only transactions which emerge with a `sampled` value of `true` will be
   * sent to Sentry.
   *
   * @param hub: The hub off of which to read config options
   * @param transaction: The transaction needing a sampling decision
   * @param samplingContext: Default and user-provided data which may be used to help make the decision
   *
   * @returns The given transaction with its `sampled` value set
   */
  function sample(transaction, options, samplingContext) {
      // nothing to do if tracing is not enabled
      if (!Object(_utils__WEBPACK_IMPORTED_MODULE_8__[/* hasTracingEnabled */ "c"])(options)) {
          transaction.sampled = false;
          return transaction;
      }
      // if the user has forced a sampling decision by passing a `sampled` value in their transaction context, go with that
      if (transaction.sampled !== undefined) {
          transaction.setMetadata({
              transactionSampling: { method: _sentry_types__WEBPACK_IMPORTED_MODULE_2__[/* TransactionSamplingMethod */ "a"].Explicit },
          });
          return transaction;
      }
      // we would have bailed already if neither `tracesSampler` nor `tracesSampleRate` were defined, so one of these should
      // work; prefer the hook if so
      var sampleRate;
      if (typeof options.tracesSampler === 'function') {
          sampleRate = options.tracesSampler(samplingContext);
          transaction.setMetadata({
              transactionSampling: {
                  method: _sentry_types__WEBPACK_IMPORTED_MODULE_2__[/* TransactionSamplingMethod */ "a"].Sampler,
                  // cast to number in case it's a boolean
                  rate: Number(sampleRate),
              },
          });
      }
      else if (samplingContext.parentSampled !== undefined) {
          sampleRate = samplingContext.parentSampled;
          transaction.setMetadata({
              transactionSampling: { method: _sentry_types__WEBPACK_IMPORTED_MODULE_2__[/* TransactionSamplingMethod */ "a"].Inheritance },
          });
      }
      else {
          sampleRate = options.tracesSampleRate;
          transaction.setMetadata({
              transactionSampling: {
                  method: _sentry_types__WEBPACK_IMPORTED_MODULE_2__[/* TransactionSamplingMethod */ "a"].Rate,
                  // cast to number in case it's a boolean
                  rate: Number(sampleRate),
              },
          });
      }
      // Since this is coming from the user (or from a function provided by the user), who knows what we might get. (The
      // only valid values are booleans or numbers between 0 and 1.)
      if (!isValidSampleRate(sampleRate)) {
          _sentry_utils__WEBPACK_IMPORTED_MODULE_3__[/* logger */ "a"].warn("[Tracing] Discarding transaction because of invalid sample rate.");
          transaction.sampled = false;
          return transaction;
      }
      // if the function returned 0 (or false), or if `tracesSampleRate` is 0, it's a sign the transaction should be dropped
      if (!sampleRate) {
          _sentry_utils__WEBPACK_IMPORTED_MODULE_3__[/* logger */ "a"].log("[Tracing] Discarding transaction because " + (typeof options.tracesSampler === 'function'
              ? 'tracesSampler returned 0 or false'
              : 'a negative sampling decision was inherited or tracesSampleRate is set to 0'));
          transaction.sampled = false;
          return transaction;
      }
      // Now we roll the dice. Math.random is inclusive of 0, but not of 1, so strict < is safe here. In case sampleRate is
      // a boolean, the < comparison will cause it to be automatically cast to 1 if it's true and 0 if it's false.
      transaction.sampled = Math.random() < sampleRate;
      // if we're not going to keep it, we're done
      if (!transaction.sampled) {
          _sentry_utils__WEBPACK_IMPORTED_MODULE_3__[/* logger */ "a"].log("[Tracing] Discarding transaction because it's not included in the random sample (sampling rate = " + Number(sampleRate) + ")");
          return transaction;
      }
      _sentry_utils__WEBPACK_IMPORTED_MODULE_3__[/* logger */ "a"].log("[Tracing] starting " + transaction.op + " transaction - " + transaction.name);
      return transaction;
  }
  /**
   * Checks the given sample rate to make sure it is valid type and value (a boolean, or a number between 0 and 1).
   */
  function isValidSampleRate(rate) {
      // we need to check NaN explicitly because it's of type 'number' and therefore wouldn't get caught by this typecheck
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      if (isNaN(rate) || !(typeof rate === 'number' || typeof rate === 'boolean')) {
          _sentry_utils__WEBPACK_IMPORTED_MODULE_3__[/* logger */ "a"].warn("[Tracing] Given sample rate is invalid. Sample rate must be a boolean or a number between 0 and 1. Got " + JSON.stringify(rate) + " of type " + JSON.stringify(typeof rate) + ".");
          return false;
      }
      // in case sampleRate is a boolean, it will get automatically cast to 1 if it's true and 0 if it's false
      if (rate < 0 || rate > 1) {
          _sentry_utils__WEBPACK_IMPORTED_MODULE_3__[/* logger */ "a"].warn("[Tracing] Given sample rate is invalid. Sample rate must be between 0 and 1. Got " + rate + ".");
          return false;
      }
      return true;
  }
  /**
   * Creates a new transaction and adds a sampling decision if it doesn't yet have one.
   *
   * The Hub.startTransaction method delegates to this method to do its work, passing the Hub instance in as `this`, as if
   * it had been called on the hub directly. Exists as a separate function so that it can be injected into the class as an
   * "extension method."
   *
   * @param this: The Hub starting the transaction
   * @param transactionContext: Data used to configure the transaction
   * @param CustomSamplingContext: Optional data to be provided to the `tracesSampler` function (if any)
   *
   * @returns The new transaction
   *
   * @see {@link Hub.startTransaction}
   */
  function _startTransaction(transactionContext, customSamplingContext) {
      var _a, _b;
      var options = ((_a = this.getClient()) === null || _a === void 0 ? void 0 : _a.getOptions()) || {};
      var transaction = new _transaction__WEBPACK_IMPORTED_MODULE_7__[/* Transaction */ "a"](transactionContext, this);
      transaction = sample(transaction, options, Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({ parentSampled: transactionContext.parentSampled, transactionContext: transactionContext }, customSamplingContext));
      if (transaction.sampled) {
          transaction.initSpanRecorder((_b = options._experiments) === null || _b === void 0 ? void 0 : _b.maxSpans);
      }
      return transaction;
  }
  /**
   * Create new idle transaction.
   */
  function startIdleTransaction(hub, transactionContext, idleTimeout, onScope, customSamplingContext) {
      var _a, _b;
      var options = ((_a = hub.getClient()) === null || _a === void 0 ? void 0 : _a.getOptions()) || {};
      var transaction = new _idletransaction__WEBPACK_IMPORTED_MODULE_6__[/* IdleTransaction */ "b"](transactionContext, hub, idleTimeout, onScope);
      transaction = sample(transaction, options, Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({ parentSampled: transactionContext.parentSampled, transactionContext: transactionContext }, customSamplingContext));
      if (transaction.sampled) {
          transaction.initSpanRecorder((_b = options._experiments) === null || _b === void 0 ? void 0 : _b.maxSpans);
      }
      return transaction;
  }
  /**
   * @private
   */
  function _addTracingExtensions() {
      var carrier = Object(_sentry_hub__WEBPACK_IMPORTED_MODULE_1__[/* getMainCarrier */ "d"])();
      if (!carrier.__SENTRY__) {
          return;
      }
      carrier.__SENTRY__.extensions = carrier.__SENTRY__.extensions || {};
      if (!carrier.__SENTRY__.extensions.startTransaction) {
          carrier.__SENTRY__.extensions.startTransaction = _startTransaction;
      }
      if (!carrier.__SENTRY__.extensions.traceHeaders) {
          carrier.__SENTRY__.extensions.traceHeaders = traceHeaders;
      }
  }
  /**
   * @private
   */
  function _autoloadDatabaseIntegrations() {
      var carrier = Object(_sentry_hub__WEBPACK_IMPORTED_MODULE_1__[/* getMainCarrier */ "d"])();
      if (!carrier.__SENTRY__) {
          return;
      }
      var packageToIntegrationMapping = {
          mongodb: function () {
              var integration = Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_4__[/* dynamicRequire */ "a"])(module, './integrations/mongo');
              return new integration.Mongo();
          },
          mongoose: function () {
              var integration = Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_4__[/* dynamicRequire */ "a"])(module, './integrations/mongo');
              return new integration.Mongo({ mongoose: true });
          },
          mysql: function () {
              var integration = Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_4__[/* dynamicRequire */ "a"])(module, './integrations/mysql');
              return new integration.Mysql();
          },
          pg: function () {
              var integration = Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_4__[/* dynamicRequire */ "a"])(module, './integrations/postgres');
              return new integration.Postgres();
          },
      };
      var mappedPackages = Object.keys(packageToIntegrationMapping)
          .filter(function (moduleName) { return !!Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_4__[/* loadModule */ "c"])(moduleName); })
          .map(function (pkg) {
          try {
              return packageToIntegrationMapping[pkg]();
          }
          catch (e) {
              return undefined;
          }
      })
          .filter(function (p) { return p; });
      if (mappedPackages.length > 0) {
          carrier.__SENTRY__.integrations = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __spread */ "e"])((carrier.__SENTRY__.integrations || []), mappedPackages);
      }
  }
  /**
   * This patches the global object and injects the Tracing extensions methods
   */
  function addExtensionMethods() {
      _addTracingExtensions();
      // Detect and automatically load specified integrations.
      if (Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_4__[/* isNodeEnv */ "b"])()) {
          _autoloadDatabaseIntegrations();
      }
      // If an error happens globally, we should make sure transaction status is set to error.
      Object(_errors__WEBPACK_IMPORTED_MODULE_5__[/* registerErrorInstrumentation */ "a"])();
  }
  //# sourceMappingURL=hubextensions.js.map
  /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(74)(module)))
  
  /***/ }),
  
  /***/ 29:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return SpanRecorder; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Span; });
  /* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1);
  /* harmony import */ var _sentry_utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(11);
  /* harmony import */ var _sentry_utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(37);
  /* harmony import */ var _sentry_utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(14);
  /* harmony import */ var _spanstatus__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(10);
  
  
  
  /**
   * Keeps track of finished spans for a given transaction
   * @internal
   * @hideconstructor
   * @hidden
   */
  var SpanRecorder = /** @class */ (function () {
      function SpanRecorder(maxlen) {
          if (maxlen === void 0) { maxlen = 1000; }
          this.spans = [];
          this._maxlen = maxlen;
      }
      /**
       * This is just so that we don't run out of memory while recording a lot
       * of spans. At some point we just stop and flush out the start of the
       * trace tree (i.e.the first n spans with the smallest
       * start_timestamp).
       */
      SpanRecorder.prototype.add = function (span) {
          if (this.spans.length > this._maxlen) {
              span.spanRecorder = undefined;
          }
          else {
              this.spans.push(span);
          }
      };
      return SpanRecorder;
  }());
  
  /**
   * Span contains all data about a span
   */
  var Span = /** @class */ (function () {
      /**
       * You should never call the constructor manually, always use `Sentry.startTransaction()`
       * or call `startChild()` on an existing span.
       * @internal
       * @hideconstructor
       * @hidden
       */
      function Span(spanContext) {
          /**
           * @inheritDoc
           */
          this.traceId = Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_1__[/* uuid4 */ "j"])();
          /**
           * @inheritDoc
           */
          this.spanId = Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_1__[/* uuid4 */ "j"])().substring(16);
          /**
           * Timestamp in seconds when the span was created.
           */
          this.startTimestamp = Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_2__[/* timestampWithMs */ "d"])();
          /**
           * @inheritDoc
           */
          this.tags = {};
          /**
           * @inheritDoc
           */
          // eslint-disable-next-line @typescript-eslint/no-explicit-any
          this.data = {};
          if (!spanContext) {
              return this;
          }
          if (spanContext.traceId) {
              this.traceId = spanContext.traceId;
          }
          if (spanContext.spanId) {
              this.spanId = spanContext.spanId;
          }
          if (spanContext.parentSpanId) {
              this.parentSpanId = spanContext.parentSpanId;
          }
          // We want to include booleans as well here
          if ('sampled' in spanContext) {
              this.sampled = spanContext.sampled;
          }
          if (spanContext.op) {
              this.op = spanContext.op;
          }
          if (spanContext.description) {
              this.description = spanContext.description;
          }
          if (spanContext.data) {
              this.data = spanContext.data;
          }
          if (spanContext.tags) {
              this.tags = spanContext.tags;
          }
          if (spanContext.status) {
              this.status = spanContext.status;
          }
          if (spanContext.startTimestamp) {
              this.startTimestamp = spanContext.startTimestamp;
          }
          if (spanContext.endTimestamp) {
              this.endTimestamp = spanContext.endTimestamp;
          }
      }
      /**
       * @inheritDoc
       * @deprecated
       */
      Span.prototype.child = function (spanContext) {
          return this.startChild(spanContext);
      };
      /**
       * @inheritDoc
       */
      Span.prototype.startChild = function (spanContext) {
          var childSpan = new Span(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, spanContext), { parentSpanId: this.spanId, sampled: this.sampled, traceId: this.traceId }));
          childSpan.spanRecorder = this.spanRecorder;
          if (childSpan.spanRecorder) {
              childSpan.spanRecorder.add(childSpan);
          }
          childSpan.transaction = this.transaction;
          return childSpan;
      };
      /**
       * @inheritDoc
       */
      Span.prototype.setTag = function (key, value) {
          var _a;
          this.tags = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, this.tags), (_a = {}, _a[key] = value, _a));
          return this;
      };
      /**
       * @inheritDoc
       */
      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
      Span.prototype.setData = function (key, value) {
          var _a;
          this.data = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, this.data), (_a = {}, _a[key] = value, _a));
          return this;
      };
      /**
       * @inheritDoc
       */
      Span.prototype.setStatus = function (value) {
          this.status = value;
          return this;
      };
      /**
       * @inheritDoc
       */
      Span.prototype.setHttpStatus = function (httpStatus) {
          this.setTag('http.status_code', String(httpStatus));
          var spanStatus = _spanstatus__WEBPACK_IMPORTED_MODULE_4__[/* SpanStatus */ "a"].fromHttpCode(httpStatus);
          if (spanStatus !== _spanstatus__WEBPACK_IMPORTED_MODULE_4__[/* SpanStatus */ "a"].UnknownError) {
              this.setStatus(spanStatus);
          }
          return this;
      };
      /**
       * @inheritDoc
       */
      Span.prototype.isSuccess = function () {
          return this.status === _spanstatus__WEBPACK_IMPORTED_MODULE_4__[/* SpanStatus */ "a"].Ok;
      };
      /**
       * @inheritDoc
       */
      Span.prototype.finish = function (endTimestamp) {
          this.endTimestamp = typeof endTimestamp === 'number' ? endTimestamp : Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_2__[/* timestampWithMs */ "d"])();
      };
      /**
       * @inheritDoc
       */
      Span.prototype.toTraceparent = function () {
          var sampledString = '';
          if (this.sampled !== undefined) {
              sampledString = this.sampled ? '-1' : '-0';
          }
          return this.traceId + "-" + this.spanId + sampledString;
      };
      /**
       * @inheritDoc
       */
      Span.prototype.toContext = function () {
          return Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_3__[/* dropUndefinedKeys */ "a"])({
              data: this.data,
              description: this.description,
              endTimestamp: this.endTimestamp,
              op: this.op,
              parentSpanId: this.parentSpanId,
              sampled: this.sampled,
              spanId: this.spanId,
              startTimestamp: this.startTimestamp,
              status: this.status,
              tags: this.tags,
              traceId: this.traceId,
          });
      };
      /**
       * @inheritDoc
       */
      Span.prototype.updateWithContext = function (spanContext) {
          var _a, _b, _c, _d, _e;
          this.data = (_a = spanContext.data, (_a !== null && _a !== void 0 ? _a : {}));
          this.description = spanContext.description;
          this.endTimestamp = spanContext.endTimestamp;
          this.op = spanContext.op;
          this.parentSpanId = spanContext.parentSpanId;
          this.sampled = spanContext.sampled;
          this.spanId = (_b = spanContext.spanId, (_b !== null && _b !== void 0 ? _b : this.spanId));
          this.startTimestamp = (_c = spanContext.startTimestamp, (_c !== null && _c !== void 0 ? _c : this.startTimestamp));
          this.status = spanContext.status;
          this.tags = (_d = spanContext.tags, (_d !== null && _d !== void 0 ? _d : {}));
          this.traceId = (_e = spanContext.traceId, (_e !== null && _e !== void 0 ? _e : this.traceId));
          return this;
      };
      /**
       * @inheritDoc
       */
      Span.prototype.getTraceContext = function () {
          return Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_3__[/* dropUndefinedKeys */ "a"])({
              data: Object.keys(this.data).length > 0 ? this.data : undefined,
              description: this.description,
              op: this.op,
              parent_span_id: this.parentSpanId,
              span_id: this.spanId,
              status: this.status,
              tags: Object.keys(this.tags).length > 0 ? this.tags : undefined,
              trace_id: this.traceId,
          });
      };
      /**
       * @inheritDoc
       */
      Span.prototype.toJSON = function () {
          return Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_3__[/* dropUndefinedKeys */ "a"])({
              data: Object.keys(this.data).length > 0 ? this.data : undefined,
              description: this.description,
              op: this.op,
              parent_span_id: this.parentSpanId,
              span_id: this.spanId,
              start_timestamp: this.startTimestamp,
              status: this.status,
              tags: Object.keys(this.tags).length > 0 ? this.tags : undefined,
              timestamp: this.endTimestamp,
              trace_id: this.traceId,
          });
      };
      return Span;
  }());
  
  //# sourceMappingURL=span.js.map
  
  /***/ }),
  
  /***/ 30:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return truncate; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return snipLine; });
  /* unused harmony export safeJoin */
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return isMatchingPattern; });
  /* harmony import */ var _is__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9);
  
  /**
   * Truncates given string to the maximum characters count
   *
   * @param str An object that contains serializable values
   * @param max Maximum number of characters in truncated string (0 = unlimited)
   * @returns string Encoded
   */
  function truncate(str, max) {
      if (max === void 0) { max = 0; }
      if (typeof str !== 'string' || max === 0) {
          return str;
      }
      return str.length <= max ? str : str.substr(0, max) + "...";
  }
  /**
   * This is basically just `trim_line` from
   * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67
   *
   * @param str An object that contains serializable values
   * @param max Maximum number of characters in truncated string
   * @returns string Encoded
   */
  function snipLine(line, colno) {
      var newLine = line;
      var ll = newLine.length;
      if (ll <= 150) {
          return newLine;
      }
      if (colno > ll) {
          // eslint-disable-next-line no-param-reassign
          colno = ll;
      }
      var start = Math.max(colno - 60, 0);
      if (start < 5) {
          start = 0;
      }
      var end = Math.min(start + 140, ll);
      if (end > ll - 5) {
          end = ll;
      }
      if (end === ll) {
          start = Math.max(end - 140, 0);
      }
      newLine = newLine.slice(start, end);
      if (start > 0) {
          newLine = "'{snip} " + newLine;
      }
      if (end < ll) {
          newLine += ' {snip}';
      }
      return newLine;
  }
  /**
   * Join values in array
   * @param input array of values to be joined together
   * @param delimiter string to be placed in-between values
   * @returns Joined values
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function safeJoin(input, delimiter) {
      if (!Array.isArray(input)) {
          return '';
      }
      var output = [];
      // eslint-disable-next-line @typescript-eslint/prefer-for-of
      for (var i = 0; i < input.length; i++) {
          var value = input[i];
          try {
              output.push(String(value));
          }
          catch (e) {
              output.push('[value cannot be serialized]');
          }
      }
      return output.join(delimiter);
  }
  /**
   * Checks if the value matches a regex or includes the string
   * @param value The string value to be checked against
   * @param pattern Either a regex or a string that must be contained in value
   */
  function isMatchingPattern(value, pattern) {
      if (!Object(_is__WEBPACK_IMPORTED_MODULE_0__[/* isString */ "h"])(value)) {
          return false;
      }
      if (Object(_is__WEBPACK_IMPORTED_MODULE_0__[/* isRegExp */ "g"])(pattern)) {
          return pattern.test(value);
      }
      if (typeof pattern === 'string') {
          return value.indexOf(pattern) !== -1;
      }
      return false;
  }
  //# sourceMappingURL=string.js.map
  
  /***/ }),
  
  /***/ 316:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return SessionStatus; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return RequestSessionStatus; });
  /**
   * Session Status
   */
  var SessionStatus;
  (function (SessionStatus) {
      /** JSDoc */
      SessionStatus["Ok"] = "ok";
      /** JSDoc */
      SessionStatus["Exited"] = "exited";
      /** JSDoc */
      SessionStatus["Crashed"] = "crashed";
      /** JSDoc */
      SessionStatus["Abnormal"] = "abnormal";
  })(SessionStatus || (SessionStatus = {}));
  var RequestSessionStatus;
  (function (RequestSessionStatus) {
      /** JSDoc */
      RequestSessionStatus["Ok"] = "ok";
      /** JSDoc */
      RequestSessionStatus["Errored"] = "errored";
      /** JSDoc */
      RequestSessionStatus["Crashed"] = "crashed";
  })(RequestSessionStatus || (RequestSessionStatus = {}));
  //# sourceMappingURL=session.js.map
  
  /***/ }),
  
  /***/ 32:
  /***/ (function(module, exports) {
  
  module.exports = require("os");
  
  /***/ }),
  
  /***/ 33:
  /***/ (function(module, exports, __webpack_require__) {
  
  /**
   * Detect Electron renderer / nwjs process, which is node, but we should
   * treat as a browser.
   */
  
  if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
  	module.exports = __webpack_require__(159);
  } else {
  	module.exports = __webpack_require__(161);
  }
  
  
  /***/ }),
  
  /***/ 34:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return DEFAULT_IDLE_TIMEOUT; });
  /* unused harmony export HEARTBEAT_INTERVAL */
  /* unused harmony export IdleTransactionSpanRecorder */
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return IdleTransaction; });
  /* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1);
  /* harmony import */ var _sentry_utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(37);
  /* harmony import */ var _sentry_utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(8);
  /* harmony import */ var _span__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(29);
  /* harmony import */ var _spanstatus__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(10);
  /* harmony import */ var _transaction__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(35);
  
  
  
  
  
  var DEFAULT_IDLE_TIMEOUT = 1000;
  var HEARTBEAT_INTERVAL = 5000;
  /**
   * @inheritDoc
   */
  var IdleTransactionSpanRecorder = /** @class */ (function (_super) {
      Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __extends */ "b"])(IdleTransactionSpanRecorder, _super);
      function IdleTransactionSpanRecorder(_pushActivity, _popActivity, transactionSpanId, maxlen) {
          if (transactionSpanId === void 0) { transactionSpanId = ''; }
          var _this = _super.call(this, maxlen) || this;
          _this._pushActivity = _pushActivity;
          _this._popActivity = _popActivity;
          _this.transactionSpanId = transactionSpanId;
          return _this;
      }
      /**
       * @inheritDoc
       */
      IdleTransactionSpanRecorder.prototype.add = function (span) {
          var _this = this;
          // We should make sure we do not push and pop activities for
          // the transaction that this span recorder belongs to.
          if (span.spanId !== this.transactionSpanId) {
              // We patch span.finish() to pop an activity after setting an endTimestamp.
              span.finish = function (endTimestamp) {
                  span.endTimestamp = typeof endTimestamp === 'number' ? endTimestamp : Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_1__[/* timestampWithMs */ "d"])();
                  _this._popActivity(span.spanId);
              };
              // We should only push new activities if the span does not have an end timestamp.
              if (span.endTimestamp === undefined) {
                  this._pushActivity(span.spanId);
              }
          }
          _super.prototype.add.call(this, span);
      };
      return IdleTransactionSpanRecorder;
  }(_span__WEBPACK_IMPORTED_MODULE_3__[/* SpanRecorder */ "b"]));
  
  /**
   * An IdleTransaction is a transaction that automatically finishes. It does this by tracking child spans as activities.
   * You can have multiple IdleTransactions active, but if the `onScope` option is specified, the idle transaction will
   * put itself on the scope on creation.
   */
  var IdleTransaction = /** @class */ (function (_super) {
      Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __extends */ "b"])(IdleTransaction, _super);
      function IdleTransaction(transactionContext, _idleHub, 
      /**
       * The time to wait in ms until the idle transaction will be finished.
       * @default 1000
       */
      _idleTimeout, 
      // If an idle transaction should be put itself on and off the scope automatically.
      _onScope) {
          if (_idleTimeout === void 0) { _idleTimeout = DEFAULT_IDLE_TIMEOUT; }
          if (_onScope === void 0) { _onScope = false; }
          var _this = _super.call(this, transactionContext, _idleHub) || this;
          _this._idleHub = _idleHub;
          _this._idleTimeout = _idleTimeout;
          _this._onScope = _onScope;
          // Activities store a list of active spans
          _this.activities = {};
          // Amount of times heartbeat has counted. Will cause transaction to finish after 3 beats.
          _this._heartbeatCounter = 0;
          // We should not use heartbeat if we finished a transaction
          _this._finished = false;
          _this._beforeFinishCallbacks = [];
          if (_idleHub && _onScope) {
              // There should only be one active transaction on the scope
              clearActiveTransaction(_idleHub);
              // We set the transaction here on the scope so error events pick up the trace
              // context and attach it to the error.
              _sentry_utils__WEBPACK_IMPORTED_MODULE_2__[/* logger */ "a"].log("Setting idle transaction on scope. Span ID: " + _this.spanId);
              _idleHub.configureScope(function (scope) { return scope.setSpan(_this); });
          }
          _this._initTimeout = setTimeout(function () {
              if (!_this._finished) {
                  _this.finish();
              }
          }, _this._idleTimeout);
          return _this;
      }
      /** {@inheritDoc} */
      IdleTransaction.prototype.finish = function (endTimestamp) {
          var e_1, _a;
          var _this = this;
          if (endTimestamp === void 0) { endTimestamp = Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_1__[/* timestampWithMs */ "d"])(); }
          this._finished = true;
          this.activities = {};
          if (this.spanRecorder) {
              _sentry_utils__WEBPACK_IMPORTED_MODULE_2__[/* logger */ "a"].log('[Tracing] finishing IdleTransaction', new Date(endTimestamp * 1000).toISOString(), this.op);
              try {
                  for (var _b = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __values */ "f"])(this._beforeFinishCallbacks), _c = _b.next(); !_c.done; _c = _b.next()) {
                      var callback = _c.value;
                      callback(this, endTimestamp);
                  }
              }
              catch (e_1_1) { e_1 = { error: e_1_1 }; }
              finally {
                  try {
                      if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                  }
                  finally { if (e_1) throw e_1.error; }
              }
              this.spanRecorder.spans = this.spanRecorder.spans.filter(function (span) {
                  // If we are dealing with the transaction itself, we just return it
                  if (span.spanId === _this.spanId) {
                      return true;
                  }
                  // We cancel all pending spans with status "cancelled" to indicate the idle transaction was finished early
                  if (!span.endTimestamp) {
                      span.endTimestamp = endTimestamp;
                      span.setStatus(_spanstatus__WEBPACK_IMPORTED_MODULE_4__[/* SpanStatus */ "a"].Cancelled);
                      _sentry_utils__WEBPACK_IMPORTED_MODULE_2__[/* logger */ "a"].log('[Tracing] cancelling span since transaction ended early', JSON.stringify(span, undefined, 2));
                  }
                  var keepSpan = span.startTimestamp < endTimestamp;
                  if (!keepSpan) {
                      _sentry_utils__WEBPACK_IMPORTED_MODULE_2__[/* logger */ "a"].log('[Tracing] discarding Span since it happened after Transaction was finished', JSON.stringify(span, undefined, 2));
                  }
                  return keepSpan;
              });
              _sentry_utils__WEBPACK_IMPORTED_MODULE_2__[/* logger */ "a"].log('[Tracing] flushing IdleTransaction');
          }
          else {
              _sentry_utils__WEBPACK_IMPORTED_MODULE_2__[/* logger */ "a"].log('[Tracing] No active IdleTransaction');
          }
          // this._onScope is true if the transaction was previously on the scope.
          if (this._onScope) {
              clearActiveTransaction(this._idleHub);
          }
          return _super.prototype.finish.call(this, endTimestamp);
      };
      /**
       * Register a callback function that gets excecuted before the transaction finishes.
       * Useful for cleanup or if you want to add any additional spans based on current context.
       *
       * This is exposed because users have no other way of running something before an idle transaction
       * finishes.
       */
      IdleTransaction.prototype.registerBeforeFinishCallback = function (callback) {
          this._beforeFinishCallbacks.push(callback);
      };
      /**
       * @inheritDoc
       */
      IdleTransaction.prototype.initSpanRecorder = function (maxlen) {
          var _this = this;
          if (!this.spanRecorder) {
              var pushActivity = function (id) {
                  if (_this._finished) {
                      return;
                  }
                  _this._pushActivity(id);
              };
              var popActivity = function (id) {
                  if (_this._finished) {
                      return;
                  }
                  _this._popActivity(id);
              };
              this.spanRecorder = new IdleTransactionSpanRecorder(pushActivity, popActivity, this.spanId, maxlen);
              // Start heartbeat so that transactions do not run forever.
              _sentry_utils__WEBPACK_IMPORTED_MODULE_2__[/* logger */ "a"].log('Starting heartbeat');
              this._pingHeartbeat();
          }
          this.spanRecorder.add(this);
      };
      /**
       * Start tracking a specific activity.
       * @param spanId The span id that represents the activity
       */
      IdleTransaction.prototype._pushActivity = function (spanId) {
          if (this._initTimeout) {
              clearTimeout(this._initTimeout);
              this._initTimeout = undefined;
          }
          _sentry_utils__WEBPACK_IMPORTED_MODULE_2__[/* logger */ "a"].log("[Tracing] pushActivity: " + spanId);
          this.activities[spanId] = true;
          _sentry_utils__WEBPACK_IMPORTED_MODULE_2__[/* logger */ "a"].log('[Tracing] new activities count', Object.keys(this.activities).length);
      };
      /**
       * Remove an activity from usage
       * @param spanId The span id that represents the activity
       */
      IdleTransaction.prototype._popActivity = function (spanId) {
          var _this = this;
          if (this.activities[spanId]) {
              _sentry_utils__WEBPACK_IMPORTED_MODULE_2__[/* logger */ "a"].log("[Tracing] popActivity " + spanId);
              // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
              delete this.activities[spanId];
              _sentry_utils__WEBPACK_IMPORTED_MODULE_2__[/* logger */ "a"].log('[Tracing] new activities count', Object.keys(this.activities).length);
          }
          if (Object.keys(this.activities).length === 0) {
              var timeout = this._idleTimeout;
              // We need to add the timeout here to have the real endtimestamp of the transaction
              // Remember timestampWithMs is in seconds, timeout is in ms
              var end_1 = Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_1__[/* timestampWithMs */ "d"])() + timeout / 1000;
              setTimeout(function () {
                  if (!_this._finished) {
                      _this.finish(end_1);
                  }
              }, timeout);
          }
      };
      /**
       * Checks when entries of this.activities are not changing for 3 beats.
       * If this occurs we finish the transaction.
       */
      IdleTransaction.prototype._beat = function () {
          // We should not be running heartbeat if the idle transaction is finished.
          if (this._finished) {
              return;
          }
          var heartbeatString = Object.keys(this.activities).join('');
          if (heartbeatString === this._prevHeartbeatString) {
              this._heartbeatCounter += 1;
          }
          else {
              this._heartbeatCounter = 1;
          }
          this._prevHeartbeatString = heartbeatString;
          if (this._heartbeatCounter >= 3) {
              _sentry_utils__WEBPACK_IMPORTED_MODULE_2__[/* logger */ "a"].log("[Tracing] Transaction finished because of no change for 3 heart beats");
              this.setStatus(_spanstatus__WEBPACK_IMPORTED_MODULE_4__[/* SpanStatus */ "a"].DeadlineExceeded);
              this.setTag('heartbeat', 'failed');
              this.finish();
          }
          else {
              this._pingHeartbeat();
          }
      };
      /**
       * Pings the heartbeat
       */
      IdleTransaction.prototype._pingHeartbeat = function () {
          var _this = this;
          _sentry_utils__WEBPACK_IMPORTED_MODULE_2__[/* logger */ "a"].log("pinging Heartbeat -> current counter: " + this._heartbeatCounter);
          setTimeout(function () {
              _this._beat();
          }, HEARTBEAT_INTERVAL);
      };
      return IdleTransaction;
  }(_transaction__WEBPACK_IMPORTED_MODULE_5__[/* Transaction */ "a"]));
  
  /**
   * Reset active transaction on scope
   */
  function clearActiveTransaction(hub) {
      if (hub) {
          var scope = hub.getScope();
          if (scope) {
              var transaction = scope.getTransaction();
              if (transaction) {
                  scope.setSpan(undefined);
              }
          }
      }
  }
  //# sourceMappingURL=idletransaction.js.map
  
  /***/ }),
  
  /***/ 35:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Transaction; });
  /* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1);
  /* harmony import */ var _sentry_hub__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(26);
  /* harmony import */ var _sentry_types__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(196);
  /* harmony import */ var _sentry_utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(9);
  /* harmony import */ var _sentry_utils__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(8);
  /* harmony import */ var _sentry_utils__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(14);
  /* harmony import */ var _span__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(29);
  
  
  
  
  
  /** JSDoc */
  var Transaction = /** @class */ (function (_super) {
      Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __extends */ "b"])(Transaction, _super);
      /**
       * This constructor should never be called manually. Those instrumenting tracing should use
       * `Sentry.startTransaction()`, and internal methods should use `hub.startTransaction()`.
       * @internal
       * @hideconstructor
       * @hidden
       */
      function Transaction(transactionContext, hub) {
          var _this = _super.call(this, transactionContext) || this;
          _this._measurements = {};
          /**
           * The reference to the current hub.
           */
          _this._hub = Object(_sentry_hub__WEBPACK_IMPORTED_MODULE_1__[/* getCurrentHub */ "b"])();
          if (Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_3__[/* isInstanceOf */ "d"])(hub, _sentry_hub__WEBPACK_IMPORTED_MODULE_1__[/* Hub */ "a"])) {
              _this._hub = hub;
          }
          _this.name = transactionContext.name || '';
          _this.metadata = transactionContext.metadata || {};
          _this._trimEnd = transactionContext.trimEnd;
          // this is because transactions are also spans, and spans have a transaction pointer
          _this.transaction = _this;
          return _this;
      }
      /**
       * JSDoc
       */
      Transaction.prototype.setName = function (name) {
          this.name = name;
      };
      /**
       * Attaches SpanRecorder to the span itself
       * @param maxlen maximum number of spans that can be recorded
       */
      Transaction.prototype.initSpanRecorder = function (maxlen) {
          if (maxlen === void 0) { maxlen = 1000; }
          if (!this.spanRecorder) {
              this.spanRecorder = new _span__WEBPACK_IMPORTED_MODULE_6__[/* SpanRecorder */ "b"](maxlen);
          }
          this.spanRecorder.add(this);
      };
      /**
       * Set observed measurements for this transaction.
       * @hidden
       */
      Transaction.prototype.setMeasurements = function (measurements) {
          this._measurements = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, measurements);
      };
      /**
       * Set metadata for this transaction.
       * @hidden
       */
      Transaction.prototype.setMetadata = function (newMetadata) {
          this.metadata = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, this.metadata), newMetadata);
      };
      /**
       * @inheritDoc
       */
      Transaction.prototype.finish = function (endTimestamp) {
          var _this = this;
          var _a, _b, _c, _d, _e;
          // This transaction is already finished, so we should not flush it again.
          if (this.endTimestamp !== undefined) {
              return undefined;
          }
          if (!this.name) {
              _sentry_utils__WEBPACK_IMPORTED_MODULE_4__[/* logger */ "a"].warn('Transaction has no name, falling back to `<unlabeled transaction>`.');
              this.name = '<unlabeled transaction>';
          }
          // just sets the end timestamp
          _super.prototype.finish.call(this, endTimestamp);
          if (this.sampled !== true) {
              // At this point if `sampled !== true` we want to discard the transaction.
              _sentry_utils__WEBPACK_IMPORTED_MODULE_4__[/* logger */ "a"].log('[Tracing] Discarding transaction because its trace was not chosen to be sampled.');
              (_e = (_c = (_a = this._hub
                  .getClient()) === null || _a === void 0 ? void 0 : (_b = _a).getTransport) === null || _c === void 0 ? void 0 : (_d = _c.call(_b)).recordLostEvent) === null || _e === void 0 ? void 0 : _e.call(_d, _sentry_types__WEBPACK_IMPORTED_MODULE_2__[/* Outcome */ "a"].SampleRate, 'transaction');
              return undefined;
          }
          var finishedSpans = this.spanRecorder ? this.spanRecorder.spans.filter(function (s) { return s !== _this && s.endTimestamp; }) : [];
          if (this._trimEnd && finishedSpans.length > 0) {
              this.endTimestamp = finishedSpans.reduce(function (prev, current) {
                  if (prev.endTimestamp && current.endTimestamp) {
                      return prev.endTimestamp > current.endTimestamp ? prev : current;
                  }
                  return prev;
              }).endTimestamp;
          }
          var transaction = {
              contexts: {
                  trace: this.getTraceContext(),
              },
              spans: finishedSpans,
              start_timestamp: this.startTimestamp,
              tags: this.tags,
              timestamp: this.endTimestamp,
              transaction: this.name,
              type: 'transaction',
              debug_meta: this.metadata,
          };
          var hasMeasurements = Object.keys(this._measurements).length > 0;
          if (hasMeasurements) {
              _sentry_utils__WEBPACK_IMPORTED_MODULE_4__[/* logger */ "a"].log('[Measurements] Adding measurements to transaction', JSON.stringify(this._measurements, undefined, 2));
              transaction.measurements = this._measurements;
          }
          _sentry_utils__WEBPACK_IMPORTED_MODULE_4__[/* logger */ "a"].log("[Tracing] Finishing " + this.op + " transaction: " + this.name + ".");
          return this._hub.captureEvent(transaction);
      };
      /**
       * @inheritDoc
       */
      Transaction.prototype.toContext = function () {
          var spanContext = _super.prototype.toContext.call(this);
          return Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_5__[/* dropUndefinedKeys */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, spanContext), { name: this.name, trimEnd: this._trimEnd }));
      };
      /**
       * @inheritDoc
       */
      Transaction.prototype.updateWithContext = function (transactionContext) {
          var _a;
          _super.prototype.updateWithContext.call(this, transactionContext);
          this.name = (_a = transactionContext.name, (_a !== null && _a !== void 0 ? _a : ''));
          this._trimEnd = transactionContext.trimEnd;
          return this;
      };
      return Transaction;
  }(_span__WEBPACK_IMPORTED_MODULE_6__[/* Span */ "a"]));
  
  //# sourceMappingURL=transaction.js.map
  
  /***/ }),
  
  /***/ 36:
  /***/ (function(module, exports) {
  
  module.exports = require("domain");
  
  /***/ }),
  
  /***/ 37:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(module) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return dateTimestampInSeconds; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return timestampInSeconds; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return timestampWithMs; });
  /* unused harmony export usingPerformanceAPI */
  /* unused harmony export _browserPerformanceTimeOriginMode */
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return browserPerformanceTimeOrigin; });
  /* harmony import */ var _misc__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(11);
  /* harmony import */ var _node__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(20);
  
  
  /**
   * A TimestampSource implementation for environments that do not support the Performance Web API natively.
   *
   * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier
   * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It
   * is more obvious to explain "why does my span have negative duration" than "why my spans have zero duration".
   */
  var dateTimestampSource = {
      nowSeconds: function () { return Date.now() / 1000; },
  };
  /**
   * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not
   * support the API.
   *
   * Wrapping the native API works around differences in behavior from different browsers.
   */
  function getBrowserPerformance() {
      var performance = Object(_misc__WEBPACK_IMPORTED_MODULE_0__[/* getGlobalObject */ "f"])().performance;
      if (!performance || !performance.now) {
          return undefined;
      }
      // Replace performance.timeOrigin with our own timeOrigin based on Date.now().
      //
      // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +
      // performance.now() gives a date arbitrarily in the past.
      //
      // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is
      // undefined.
      //
      // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to
      // interact with data coming out of performance entries.
      //
      // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that
      // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes
      // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have
      // observed skews that can be as long as days, weeks or months.
      //
      // See https://github.com/getsentry/sentry-javascript/issues/2590.
      //
      // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload
      // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation
      // transactions of long-lived web pages.
      var timeOrigin = Date.now() - performance.now();
      return {
          now: function () { return performance.now(); },
          timeOrigin: timeOrigin,
      };
  }
  /**
   * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't
   * implement the API.
   */
  function getNodePerformance() {
      try {
          var perfHooks = Object(_node__WEBPACK_IMPORTED_MODULE_1__[/* dynamicRequire */ "a"])(module, 'perf_hooks');
          return perfHooks.performance;
      }
      catch (_) {
          return undefined;
      }
  }
  /**
   * The Performance API implementation for the current platform, if available.
   */
  var platformPerformance = Object(_node__WEBPACK_IMPORTED_MODULE_1__[/* isNodeEnv */ "b"])() ? getNodePerformance() : getBrowserPerformance();
  var timestampSource = platformPerformance === undefined
      ? dateTimestampSource
      : {
          nowSeconds: function () { return (platformPerformance.timeOrigin + platformPerformance.now()) / 1000; },
      };
  /**
   * Returns a timestamp in seconds since the UNIX epoch using the Date API.
   */
  var dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);
  /**
   * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the
   * availability of the Performance API.
   *
   * See `usingPerformanceAPI` to test whether the Performance API is used.
   *
   * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is
   * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The
   * skew can grow to arbitrary amounts like days, weeks or months.
   * See https://github.com/getsentry/sentry-javascript/issues/2590.
   */
  var timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);
  // Re-exported with an old name for backwards-compatibility.
  var timestampWithMs = timestampInSeconds;
  /**
   * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.
   */
  var usingPerformanceAPI = platformPerformance !== undefined;
  /**
   * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.
   */
  var _browserPerformanceTimeOriginMode;
  /**
   * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the
   * performance API is available.
   */
  var browserPerformanceTimeOrigin = (function () {
      // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or
      // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin
      // data as reliable if they are within a reasonable threshold of the current time.
      var performance = Object(_misc__WEBPACK_IMPORTED_MODULE_0__[/* getGlobalObject */ "f"])().performance;
      if (!performance || !performance.now) {
          _browserPerformanceTimeOriginMode = 'none';
          return undefined;
      }
      var threshold = 3600 * 1000;
      var performanceNow = performance.now();
      var dateNow = Date.now();
      // if timeOrigin isn't available set delta to threshold so it isn't used
      var timeOriginDelta = performance.timeOrigin
          ? Math.abs(performance.timeOrigin + performanceNow - dateNow)
          : threshold;
      var timeOriginIsReliable = timeOriginDelta < threshold;
      // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin
      // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.
      // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always
      // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the
      // Date API.
      // eslint-disable-next-line deprecation/deprecation
      var navigationStart = performance.timing && performance.timing.navigationStart;
      var hasNavigationStart = typeof navigationStart === 'number';
      // if navigationStart isn't available set delta to threshold so it isn't used
      var navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;
      var navigationStartIsReliable = navigationStartDelta < threshold;
      if (timeOriginIsReliable || navigationStartIsReliable) {
          // Use the more reliable time origin
          if (timeOriginDelta <= navigationStartDelta) {
              _browserPerformanceTimeOriginMode = 'timeOrigin';
              return performance.timeOrigin;
          }
          else {
              _browserPerformanceTimeOriginMode = 'navigationStart';
              return navigationStart;
          }
      }
      // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.
      _browserPerformanceTimeOriginMode = 'dateNow';
      return dateNow;
  })();
  //# sourceMappingURL=time.js.map
  /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(74)(module)))
  
  /***/ }),
  
  /***/ 44:
  /***/ (function(module, exports) {
  
  module.exports = require("http");
  
  /***/ }),
  
  /***/ 45:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  
  // EXPORTS
  __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ getLogger; });
  __webpack_require__.d(__webpack_exports__, "b", function() { return /* binding */ overrideHook; });
  
  // UNUSED EXPORTS: exposeInternal, addDebugCommand, globalThis, createV1
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/1-stdlib/globalthis-ponyfill/dist/src.es2019/index.js
  var src_es2019 = __webpack_require__(17);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/2-foundation/practical-logger-minimal-noop/dist/src.es2019/index.js
  function src_es2019_NOP() {}
  
  const src_es2019_NOP_LOGGER = {
    setLevel: src_es2019_NOP,
    getLevel: () => 'silly',
    addCommonDetails: src_es2019_NOP,
    fatal: src_es2019_NOP,
    emerg: src_es2019_NOP,
    alert: src_es2019_NOP,
    crit: src_es2019_NOP,
    error: src_es2019_NOP,
    warning: src_es2019_NOP,
    warn: src_es2019_NOP,
    notice: src_es2019_NOP,
    info: src_es2019_NOP,
    verbose: src_es2019_NOP,
    log: src_es2019_NOP,
    debug: src_es2019_NOP,
    trace: src_es2019_NOP,
    silly: src_es2019_NOP,
    group: src_es2019_NOP,
    groupCollapsed: src_es2019_NOP,
    groupEnd: src_es2019_NOP
  };
  
  function createLogger(_) {
    return src_es2019_NOP_LOGGER;
  }
  
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/3-advanced--multi/universal-debug-api-placeholder/dist/src.es2019/v1.js
  
  function create() {
    //console.trace('[UDA--placeholder installing…]')
    function NOP() {}
  
    const NOP_LOGGER = createLogger();
    return {
      getLogger: () => NOP_LOGGER,
      overrideHook: (k, v) => v,
      exposeInternal: NOP,
      addDebugCommand: NOP
    };
  }
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/3-advanced--multi/universal-debug-api-placeholder/dist/src.es2019/index.js
  
  
  const globalThis = Object(src_es2019["a" /* getGlobalThis */])(); // ensure the root is present
  
  globalThis._debug = globalThis._debug || {}; // install globally if no other implementation already present
  
  globalThis._debug.v1 = globalThis._debug.v1 || create(); // expose the installed implementation
  
  const instance = globalThis._debug.v1;
  const {
    getLogger,
    exposeInternal,
    overrideHook,
    addDebugCommand
  } = instance;
   // types & sub-types, for convenience
  
  
  
  /***/ }),
  
  /***/ 48:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return SyncPromise; });
  /* harmony import */ var _is__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9);
  /* eslint-disable @typescript-eslint/explicit-function-return-type */
  /* eslint-disable @typescript-eslint/typedef */
  /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
  /* eslint-disable @typescript-eslint/no-explicit-any */
  
  /** SyncPromise internal states */
  var States;
  (function (States) {
      /** Pending */
      States["PENDING"] = "PENDING";
      /** Resolved / OK */
      States["RESOLVED"] = "RESOLVED";
      /** Rejected / Error */
      States["REJECTED"] = "REJECTED";
  })(States || (States = {}));
  /**
   * Thenable class that behaves like a Promise and follows it's interface
   * but is not async internally
   */
  var SyncPromise = /** @class */ (function () {
      function SyncPromise(executor) {
          var _this = this;
          this._state = States.PENDING;
          this._handlers = [];
          /** JSDoc */
          this._resolve = function (value) {
              _this._setResult(States.RESOLVED, value);
          };
          /** JSDoc */
          this._reject = function (reason) {
              _this._setResult(States.REJECTED, reason);
          };
          /** JSDoc */
          this._setResult = function (state, value) {
              if (_this._state !== States.PENDING) {
                  return;
              }
              if (Object(_is__WEBPACK_IMPORTED_MODULE_0__[/* isThenable */ "j"])(value)) {
                  void value.then(_this._resolve, _this._reject);
                  return;
              }
              _this._state = state;
              _this._value = value;
              _this._executeHandlers();
          };
          // TODO: FIXME
          /** JSDoc */
          this._attachHandler = function (handler) {
              _this._handlers = _this._handlers.concat(handler);
              _this._executeHandlers();
          };
          /** JSDoc */
          this._executeHandlers = function () {
              if (_this._state === States.PENDING) {
                  return;
              }
              var cachedHandlers = _this._handlers.slice();
              _this._handlers = [];
              cachedHandlers.forEach(function (handler) {
                  if (handler.done) {
                      return;
                  }
                  if (_this._state === States.RESOLVED) {
                      if (handler.onfulfilled) {
                          // eslint-disable-next-line @typescript-eslint/no-floating-promises
                          handler.onfulfilled(_this._value);
                      }
                  }
                  if (_this._state === States.REJECTED) {
                      if (handler.onrejected) {
                          handler.onrejected(_this._value);
                      }
                  }
                  handler.done = true;
              });
          };
          try {
              executor(this._resolve, this._reject);
          }
          catch (e) {
              this._reject(e);
          }
      }
      /** JSDoc */
      SyncPromise.resolve = function (value) {
          return new SyncPromise(function (resolve) {
              resolve(value);
          });
      };
      /** JSDoc */
      SyncPromise.reject = function (reason) {
          return new SyncPromise(function (_, reject) {
              reject(reason);
          });
      };
      /** JSDoc */
      SyncPromise.all = function (collection) {
          return new SyncPromise(function (resolve, reject) {
              if (!Array.isArray(collection)) {
                  reject(new TypeError("Promise.all requires an array as input."));
                  return;
              }
              if (collection.length === 0) {
                  resolve([]);
                  return;
              }
              var counter = collection.length;
              var resolvedCollection = [];
              collection.forEach(function (item, index) {
                  void SyncPromise.resolve(item)
                      .then(function (value) {
                      resolvedCollection[index] = value;
                      counter -= 1;
                      if (counter !== 0) {
                          return;
                      }
                      resolve(resolvedCollection);
                  })
                      .then(null, reject);
              });
          });
      };
      /** JSDoc */
      SyncPromise.prototype.then = function (onfulfilled, onrejected) {
          var _this = this;
          return new SyncPromise(function (resolve, reject) {
              _this._attachHandler({
                  done: false,
                  onfulfilled: function (result) {
                      if (!onfulfilled) {
                          // TODO: ¯\_(ツ)_/¯
                          // TODO: FIXME
                          resolve(result);
                          return;
                      }
                      try {
                          resolve(onfulfilled(result));
                          return;
                      }
                      catch (e) {
                          reject(e);
                          return;
                      }
                  },
                  onrejected: function (reason) {
                      if (!onrejected) {
                          reject(reason);
                          return;
                      }
                      try {
                          resolve(onrejected(reason));
                          return;
                      }
                      catch (e) {
                          reject(e);
                          return;
                      }
                  },
              });
          });
      };
      /** JSDoc */
      SyncPromise.prototype.catch = function (onrejected) {
          return this.then(function (val) { return val; }, onrejected);
      };
      /** JSDoc */
      SyncPromise.prototype.finally = function (onfinally) {
          var _this = this;
          return new SyncPromise(function (resolve, reject) {
              var val;
              var isRejected;
              return _this.then(function (value) {
                  isRejected = false;
                  val = value;
                  if (onfinally) {
                      onfinally();
                  }
              }, function (reason) {
                  isRejected = true;
                  val = reason;
                  if (onfinally) {
                      onfinally();
                  }
              }).then(function () {
                  if (isRejected) {
                      reject(val);
                      return;
                  }
                  resolve(val);
              });
          });
      };
      /** JSDoc */
      SyncPromise.prototype.toString = function () {
          return '[object SyncPromise]';
      };
      return SyncPromise;
  }());
  
  //# sourceMappingURL=syncpromise.js.map
  
  /***/ }),
  
  /***/ 5:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* unused harmony export TRACEPARENT_REGEXP */
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return hasTracingEnabled; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return extractTraceparentData; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return getActiveTransaction; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return msToSec; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return secToMs; });
  /* harmony import */ var _sentry_hub__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(26);
  
  var TRACEPARENT_REGEXP = new RegExp('^[ \\t]*' + // whitespace
      '([0-9a-f]{32})?' + // trace_id
      '-?([0-9a-f]{16})?' + // span_id
      '-?([01])?' + // sampled
      '[ \\t]*$');
  /**
   * Determines if tracing is currently enabled.
   *
   * Tracing is enabled when at least one of `tracesSampleRate` and `tracesSampler` is defined in the SDK config.
   */
  function hasTracingEnabled(options) {
      if (options === void 0) { options = (_a = Object(_sentry_hub__WEBPACK_IMPORTED_MODULE_0__[/* getCurrentHub */ "b"])()
          .getClient()) === null || _a === void 0 ? void 0 : _a.getOptions(); }
      var _a;
      if (!options) {
          return false;
      }
      return 'tracesSampleRate' in options || 'tracesSampler' in options;
  }
  /**
   * Extract transaction context data from a `sentry-trace` header.
   *
   * @param traceparent Traceparent string
   *
   * @returns Object containing data from the header, or undefined if traceparent string is malformed
   */
  function extractTraceparentData(traceparent) {
      var matches = traceparent.match(TRACEPARENT_REGEXP);
      if (matches) {
          var parentSampled = void 0;
          if (matches[3] === '1') {
              parentSampled = true;
          }
          else if (matches[3] === '0') {
              parentSampled = false;
          }
          return {
              traceId: matches[1],
              parentSampled: parentSampled,
              parentSpanId: matches[2],
          };
      }
      return undefined;
  }
  /** Grabs active transaction off scope, if any */
  function getActiveTransaction(hub) {
      if (hub === void 0) { hub = Object(_sentry_hub__WEBPACK_IMPORTED_MODULE_0__[/* getCurrentHub */ "b"])(); }
      var _a, _b;
      return (_b = (_a = hub) === null || _a === void 0 ? void 0 : _a.getScope()) === null || _b === void 0 ? void 0 : _b.getTransaction();
  }
  /**
   * Converts from milliseconds to seconds
   * @param time time in ms
   */
  function msToSec(time) {
      return time / 1000;
  }
  /**
   * Converts from seconds to milliseconds
   * @param time time in seconds
   */
  function secToMs(time) {
      return time * 1000;
  }
  // so it can be used in manual instrumentation without necessitating a hard dependency on @sentry/utils
  
  //# sourceMappingURL=utils.js.map
  
  /***/ }),
  
  /***/ 53:
  /***/ (function(module, exports) {
  
  module.exports = function(module) {
  	if (!module.webpackPolyfill) {
  		module.deprecate = function() {};
  		module.paths = [];
  		// module.parent = undefined by default
  		if (!module.children) module.children = [];
  		Object.defineProperty(module, "loaded", {
  			enumerable: true,
  			get: function() {
  				return module.l;
  			}
  		});
  		Object.defineProperty(module, "id", {
  			enumerable: true,
  			get: function() {
  				return module.i;
  			}
  		});
  		module.webpackPolyfill = 1;
  	}
  	return module;
  };
  
  
  /***/ }),
  
  /***/ 54:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.CHANNEL = void 0;
  
  const typescript_string_enums_1 = __webpack_require__(12);
  
  const api_interface_1 = __webpack_require__(67); /////////////////////////////////////////////////
  
  
  exports.CHANNEL = (() => {
    /*console.log('CHANNEL detection', {
        'process.env.CHANNEL': process.env.CHANNEL,
        'process.env.AWS_SECRET_ACCESS_KEY': process.env.AWS_SECRET_ACCESS_KEY,
        'process.env.NODE_ENV': process.env.NODE_ENV,
    })*/
    if (typescript_string_enums_1.Enum.isType(api_interface_1.ReleaseChannel, process.env.CHANNEL)) return process.env.CHANNEL;
    if (process.env.AWS_SECRET_ACCESS_KEY) return api_interface_1.ReleaseChannel.prod;
    return  false ? undefined : api_interface_1.ReleaseChannel.prod;
  })();
  
  /***/ }),
  
  /***/ 549:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.handler = void 0;
  /*
  process.env.UDA_OVERRIDE__LOGGER__UDA_INTERNAL_LOGLEVEL = '"silly"'
  process.env.UDA_OVERRIDE__LOGGER_UDA_LOGLEVEL = '"silly"'
  process.env.UDA_OVERRIDE__LOGGER_OA_DB_LOGLEVEL = '"silly"'
  process.env.UDA_OVERRIDE__LOGGER_OA_API_LOGLEVEL = '"silly"'
  process.env.UDA_OVERRIDE__KNEX_DEBUG = 'true'
  */
  
  __webpack_require__(60);
  
  const api_interface_1 = __webpack_require__(67);
  
  const sentry_1 = __webpack_require__(157); ////////////////////////////////////
  
  
  const handler = async (event, badly_typed_context) => {
    var _a;
  
    let message = ((_a = event === null || event === void 0 ? void 0 : event.queryStringParameters) === null || _a === void 0 ? void 0 : _a.message) || 'Unknown error!';
    if (!message.endsWith('!')) message = message + '!';
    const err = new Error(message);
    await (0, sentry_1.on_error)(err);
    return {
      statusCode: 200,
      headers: {},
      body: JSON.stringify((0, api_interface_1.create_server_response_body__data)({
        result: 'Error reported✔',
        err_message: message
      }))
    };
  };
  
  exports.handler = handler;
  
  /***/ }),
  
  /***/ 56:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return getFunctionName; });
  var defaultFunctionName = '<anonymous>';
  /**
   * Safely extract function name from itself
   */
  function getFunctionName(fn) {
      try {
          if (!fn || typeof fn !== 'function') {
              return defaultFunctionName;
          }
          return fn.name || defaultFunctionName;
      }
      catch (e) {
          // Just accessing custom props in some Selenium environments
          // can cause a "Permission denied" exception (see raven-js#495).
          return defaultFunctionName;
      }
  }
  //# sourceMappingURL=stacktrace.js.map
  
  /***/ }),
  
  /***/ 57:
  /***/ (function(module, exports) {
  
  module.exports = require("https");
  
  /***/ }),
  
  /***/ 58:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Scope; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return addGlobalEventProcessor; });
  /* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
  /* harmony import */ var _sentry_utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9);
  /* harmony import */ var _sentry_utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(37);
  /* harmony import */ var _sentry_utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(48);
  /* harmony import */ var _sentry_utils__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(11);
  
  
  /**
   * Absolute maximum number of breadcrumbs added to an event.
   * The `maxBreadcrumbs` option cannot be higher than this value.
   */
  var MAX_BREADCRUMBS = 100;
  /**
   * Holds additional event information. {@link Scope.applyToEvent} will be
   * called by the client before an event will be sent.
   */
  var Scope = /** @class */ (function () {
      function Scope() {
          /** Flag if notifying is happening. */
          this._notifyingListeners = false;
          /** Callback for client to receive scope changes. */
          this._scopeListeners = [];
          /** Callback list that will be called after {@link applyToEvent}. */
          this._eventProcessors = [];
          /** Array of breadcrumbs. */
          this._breadcrumbs = [];
          /** User */
          this._user = {};
          /** Tags */
          this._tags = {};
          /** Extra */
          this._extra = {};
          /** Contexts */
          this._contexts = {};
      }
      /**
       * Inherit values from the parent scope.
       * @param scope to clone.
       */
      Scope.clone = function (scope) {
          var newScope = new Scope();
          if (scope) {
              newScope._breadcrumbs = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __spread */ "b"])(scope._breadcrumbs);
              newScope._tags = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, scope._tags);
              newScope._extra = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, scope._extra);
              newScope._contexts = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, scope._contexts);
              newScope._user = scope._user;
              newScope._level = scope._level;
              newScope._span = scope._span;
              newScope._session = scope._session;
              newScope._transactionName = scope._transactionName;
              newScope._fingerprint = scope._fingerprint;
              newScope._eventProcessors = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __spread */ "b"])(scope._eventProcessors);
              newScope._requestSession = scope._requestSession;
          }
          return newScope;
      };
      /**
       * Add internal on change listener. Used for sub SDKs that need to store the scope.
       * @hidden
       */
      Scope.prototype.addScopeListener = function (callback) {
          this._scopeListeners.push(callback);
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.addEventProcessor = function (callback) {
          this._eventProcessors.push(callback);
          return this;
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.setUser = function (user) {
          this._user = user || {};
          if (this._session) {
              this._session.update({ user: user });
          }
          this._notifyScopeListeners();
          return this;
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.getUser = function () {
          return this._user;
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.getRequestSession = function () {
          return this._requestSession;
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.setRequestSession = function (requestSession) {
          this._requestSession = requestSession;
          return this;
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.setTags = function (tags) {
          this._tags = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, this._tags), tags);
          this._notifyScopeListeners();
          return this;
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.setTag = function (key, value) {
          var _a;
          this._tags = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, this._tags), (_a = {}, _a[key] = value, _a));
          this._notifyScopeListeners();
          return this;
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.setExtras = function (extras) {
          this._extra = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, this._extra), extras);
          this._notifyScopeListeners();
          return this;
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.setExtra = function (key, extra) {
          var _a;
          this._extra = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, this._extra), (_a = {}, _a[key] = extra, _a));
          this._notifyScopeListeners();
          return this;
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.setFingerprint = function (fingerprint) {
          this._fingerprint = fingerprint;
          this._notifyScopeListeners();
          return this;
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.setLevel = function (level) {
          this._level = level;
          this._notifyScopeListeners();
          return this;
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.setTransactionName = function (name) {
          this._transactionName = name;
          this._notifyScopeListeners();
          return this;
      };
      /**
       * Can be removed in major version.
       * @deprecated in favor of {@link this.setTransactionName}
       */
      Scope.prototype.setTransaction = function (name) {
          return this.setTransactionName(name);
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.setContext = function (key, context) {
          var _a;
          if (context === null) {
              // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
              delete this._contexts[key];
          }
          else {
              this._contexts = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, this._contexts), (_a = {}, _a[key] = context, _a));
          }
          this._notifyScopeListeners();
          return this;
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.setSpan = function (span) {
          this._span = span;
          this._notifyScopeListeners();
          return this;
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.getSpan = function () {
          return this._span;
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.getTransaction = function () {
          var _a, _b, _c, _d;
          // often, this span will be a transaction, but it's not guaranteed to be
          var span = this.getSpan();
          // try it the new way first
          if ((_a = span) === null || _a === void 0 ? void 0 : _a.transaction) {
              return (_b = span) === null || _b === void 0 ? void 0 : _b.transaction;
          }
          // fallback to the old way (known bug: this only finds transactions with sampled = true)
          if ((_d = (_c = span) === null || _c === void 0 ? void 0 : _c.spanRecorder) === null || _d === void 0 ? void 0 : _d.spans[0]) {
              return span.spanRecorder.spans[0];
          }
          // neither way found a transaction
          return undefined;
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.setSession = function (session) {
          if (!session) {
              delete this._session;
          }
          else {
              this._session = session;
          }
          this._notifyScopeListeners();
          return this;
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.getSession = function () {
          return this._session;
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.update = function (captureContext) {
          if (!captureContext) {
              return this;
          }
          if (typeof captureContext === 'function') {
              var updatedScope = captureContext(this);
              return updatedScope instanceof Scope ? updatedScope : this;
          }
          if (captureContext instanceof Scope) {
              this._tags = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, this._tags), captureContext._tags);
              this._extra = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, this._extra), captureContext._extra);
              this._contexts = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, this._contexts), captureContext._contexts);
              if (captureContext._user && Object.keys(captureContext._user).length) {
                  this._user = captureContext._user;
              }
              if (captureContext._level) {
                  this._level = captureContext._level;
              }
              if (captureContext._fingerprint) {
                  this._fingerprint = captureContext._fingerprint;
              }
              if (captureContext._requestSession) {
                  this._requestSession = captureContext._requestSession;
              }
          }
          else if (Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_1__[/* isPlainObject */ "e"])(captureContext)) {
              // eslint-disable-next-line no-param-reassign
              captureContext = captureContext;
              this._tags = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, this._tags), captureContext.tags);
              this._extra = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, this._extra), captureContext.extra);
              this._contexts = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, this._contexts), captureContext.contexts);
              if (captureContext.user) {
                  this._user = captureContext.user;
              }
              if (captureContext.level) {
                  this._level = captureContext.level;
              }
              if (captureContext.fingerprint) {
                  this._fingerprint = captureContext.fingerprint;
              }
              if (captureContext.requestSession) {
                  this._requestSession = captureContext.requestSession;
              }
          }
          return this;
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.clear = function () {
          this._breadcrumbs = [];
          this._tags = {};
          this._extra = {};
          this._user = {};
          this._contexts = {};
          this._level = undefined;
          this._transactionName = undefined;
          this._fingerprint = undefined;
          this._requestSession = undefined;
          this._span = undefined;
          this._session = undefined;
          this._notifyScopeListeners();
          return this;
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.addBreadcrumb = function (breadcrumb, maxBreadcrumbs) {
          var maxCrumbs = typeof maxBreadcrumbs === 'number' ? Math.min(maxBreadcrumbs, MAX_BREADCRUMBS) : MAX_BREADCRUMBS;
          // No data has been changed, so don't notify scope listeners
          if (maxCrumbs <= 0) {
              return this;
          }
          var mergedBreadcrumb = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({ timestamp: Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_2__[/* dateTimestampInSeconds */ "b"])() }, breadcrumb);
          this._breadcrumbs = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __spread */ "b"])(this._breadcrumbs, [mergedBreadcrumb]).slice(-maxCrumbs);
          this._notifyScopeListeners();
          return this;
      };
      /**
       * @inheritDoc
       */
      Scope.prototype.clearBreadcrumbs = function () {
          this._breadcrumbs = [];
          this._notifyScopeListeners();
          return this;
      };
      /**
       * Applies the current context and fingerprint to the event.
       * Note that breadcrumbs will be added by the client.
       * Also if the event has already breadcrumbs on it, we do not merge them.
       * @param event Event
       * @param hint May contain additional information about the original exception.
       * @hidden
       */
      Scope.prototype.applyToEvent = function (event, hint) {
          var _a;
          if (this._extra && Object.keys(this._extra).length) {
              event.extra = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, this._extra), event.extra);
          }
          if (this._tags && Object.keys(this._tags).length) {
              event.tags = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, this._tags), event.tags);
          }
          if (this._user && Object.keys(this._user).length) {
              event.user = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, this._user), event.user);
          }
          if (this._contexts && Object.keys(this._contexts).length) {
              event.contexts = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, this._contexts), event.contexts);
          }
          if (this._level) {
              event.level = this._level;
          }
          if (this._transactionName) {
              event.transaction = this._transactionName;
          }
          // We want to set the trace context for normal events only if there isn't already
          // a trace context on the event. There is a product feature in place where we link
          // errors with transaction and it relies on that.
          if (this._span) {
              event.contexts = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({ trace: this._span.getTraceContext() }, event.contexts);
              var transactionName = (_a = this._span.transaction) === null || _a === void 0 ? void 0 : _a.name;
              if (transactionName) {
                  event.tags = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({ transaction: transactionName }, event.tags);
              }
          }
          this._applyFingerprint(event);
          event.breadcrumbs = Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __spread */ "b"])((event.breadcrumbs || []), this._breadcrumbs);
          event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;
          return this._notifyEventProcessors(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __spread */ "b"])(getGlobalEventProcessors(), this._eventProcessors), event, hint);
      };
      /**
       * This will be called after {@link applyToEvent} is finished.
       */
      Scope.prototype._notifyEventProcessors = function (processors, event, hint, index) {
          var _this = this;
          if (index === void 0) { index = 0; }
          return new _sentry_utils__WEBPACK_IMPORTED_MODULE_3__[/* SyncPromise */ "a"](function (resolve, reject) {
              var processor = processors[index];
              if (event === null || typeof processor !== 'function') {
                  resolve(event);
              }
              else {
                  var result = processor(Object(tslib__WEBPACK_IMPORTED_MODULE_0__[/* __assign */ "a"])({}, event), hint);
                  if (Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_1__[/* isThenable */ "j"])(result)) {
                      void result
                          .then(function (final) { return _this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve); })
                          .then(null, reject);
                  }
                  else {
                      void _this._notifyEventProcessors(processors, result, hint, index + 1)
                          .then(resolve)
                          .then(null, reject);
                  }
              }
          });
      };
      /**
       * This will be called on every set call.
       */
      Scope.prototype._notifyScopeListeners = function () {
          var _this = this;
          // We need this check for this._notifyingListeners to be able to work on scope during updates
          // If this check is not here we'll produce endless recursion when something is done with the scope
          // during the callback.
          if (!this._notifyingListeners) {
              this._notifyingListeners = true;
              this._scopeListeners.forEach(function (callback) {
                  callback(_this);
              });
              this._notifyingListeners = false;
          }
      };
      /**
       * Applies fingerprint from the scope to the event if there's one,
       * uses message if there's one instead or get rid of empty fingerprint
       */
      Scope.prototype._applyFingerprint = function (event) {
          // Make sure it's an array first and we actually have something in place
          event.fingerprint = event.fingerprint
              ? Array.isArray(event.fingerprint)
                  ? event.fingerprint
                  : [event.fingerprint]
              : [];
          // If we have something on the scope, then merge it with event
          if (this._fingerprint) {
              event.fingerprint = event.fingerprint.concat(this._fingerprint);
          }
          // If we have no data at all, remove empty array default
          if (event.fingerprint && !event.fingerprint.length) {
              delete event.fingerprint;
          }
      };
      return Scope;
  }());
  
  /**
   * Returns the global event processors.
   */
  function getGlobalEventProcessors() {
      /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access  */
      var global = Object(_sentry_utils__WEBPACK_IMPORTED_MODULE_4__[/* getGlobalObject */ "f"])();
      global.__SENTRY__ = global.__SENTRY__ || {};
      global.__SENTRY__.globalEventProcessors = global.__SENTRY__.globalEventProcessors || [];
      return global.__SENTRY__.globalEventProcessors;
      /* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */
  }
  /**
   * Add a EventProcessor to be kept globally.
   * @param callback EventProcessor to add
   */
  function addGlobalEventProcessor(callback) {
      getGlobalEventProcessors().push(callback);
  }
  //# sourceMappingURL=scope.js.map
  
  /***/ }),
  
  /***/ 59:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return TransactionSamplingMethod; });
  var TransactionSamplingMethod;
  (function (TransactionSamplingMethod) {
      TransactionSamplingMethod["Explicit"] = "explicitly_set";
      TransactionSamplingMethod["Sampler"] = "client_sampler";
      TransactionSamplingMethod["Rate"] = "client_rate";
      TransactionSamplingMethod["Inheritance"] = "inheritance";
  })(TransactionSamplingMethod || (TransactionSamplingMethod = {}));
  //# sourceMappingURL=transaction.js.map
  
  /***/ }),
  
  /***/ 60:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  // ESM COMPAT FLAG
  __webpack_require__.r(__webpack_exports__);
  
  // EXPORTS
  __webpack_require__.d(__webpack_exports__, "getLogger", function() { return /* binding */ src_es2019_getLogger; });
  __webpack_require__.d(__webpack_exports__, "exposeInternal", function() { return /* binding */ src_es2019_exposeInternal; });
  __webpack_require__.d(__webpack_exports__, "overrideHook", function() { return /* binding */ src_es2019_overrideHook; });
  __webpack_require__.d(__webpack_exports__, "addDebugCommand", function() { return /* binding */ src_es2019_addDebugCommand; });
  __webpack_require__.d(__webpack_exports__, "globalThis", function() { return /* binding */ src_es2019_globalThis; });
  __webpack_require__.d(__webpack_exports__, "createV1", function() { return /* reexport */ v1_create; });
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/1-stdlib/globalthis-ponyfill/dist/src.es2019/index.js
  var src_es2019 = __webpack_require__(17);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/2-foundation/practical-logger-core/dist/src.es2019/consts.js
  const LIB = '@offirmo/practical-logger-core'; // level to a numerical value, for ordering and filtering.
  // mnemonic:  100 = 100% = you will see 100% of the logs
  //              1 =   1% = you will see 1% of the logs (obviously the most important)
  
  const LOG_LEVEL_TO_INTEGER = {
    fatal: 1,
    emerg: 2,
    alert: 10,
    crit: 20,
    error: 30,
    warning: 40,
    warn: 40,
    notice: 45,
    info: 50,
    verbose: 70,
    log: 80,
    debug: 81,
    trace: 90,
    silly: 100
  };
  const ALL_LOG_LEVELS = Object.keys(LOG_LEVEL_TO_INTEGER).map(s => s).sort((a, b) => LOG_LEVEL_TO_INTEGER[a] - LOG_LEVEL_TO_INTEGER[b]); // rationalization to a clear, human understandable string
  // generated to shave a few bytes
  // not using fromEntries bc not available in node <12
  
  const LOG_LEVEL_TO_HUMAN = ALL_LOG_LEVELS.reduce((acc, ll) => {
    acc[ll] = {
      em: 'emergency',
      wa: 'warn'
    }[ll.slice(0, 1)] || ll;
    return acc;
  }, {});
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/2-foundation/practical-logger-core/dist/src.es2019/consts-base.js
  // base to be directly importable from other modules
  // without a full lib penalty.
  // This a very very specific use case, don't mind.
  const DEFAULT_LOG_LEVEL = 'error';
  const DEFAULT_LOGGER_KEY = ''; // yes, can be used as a key
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/2-foundation/practical-logger-core/dist/src.es2019/normalize-args.js
  // TODO externalize?
  function looksLikeAnError(x) {
    return !!((x === null || x === void 0 ? void 0 : x.name) && (x === null || x === void 0 ? void 0 : x.message) && (x === null || x === void 0 ? void 0 : x.stack));
  } // harmonize
  // also try to recover from incorrect invocations
  
  function normalizeArguments(raw_args) {
    var _a;
  
    const message_parts = [];
    let details = {};
    let err = undefined;
    Array.from(raw_args).forEach(arg => {
      if (!arg) return; // errors are first class, look for them first
  
      if (looksLikeAnError(arg)) {
        if (!err) err = arg; // extract it
  
        return;
      }
  
      if (!err && looksLikeAnError(arg.err)) {
        err = arg.err; // extract it
        // don't return, still stuff to pick
      }
  
      if (typeof arg === 'object') {
        details = { ...details,
          ...arg
        };
        return;
      }
  
      message_parts.push(String(arg));
    });
  
    if (typeof details.message === 'string' && !message_parts.length) {
      message_parts.push(details.message);
      delete details.message;
    }
  
    const message = message_parts.join(' ') || ((_a = err) === null || _a === void 0 ? void 0 : _a.message) || '(no message)';
    if (err) details.err = err;else delete details.err; // because could be present but not be a correct err type
  
    return [message, details];
  }
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/2-foundation/practical-logger-core/dist/src.es2019/core.js
  
  
  function checkLevel(level) {
    if (!ALL_LOG_LEVELS.includes(level)) throw new Error(`[${LIB}] Not a valid log level: "${level}"!`);
  }
  function create({
    name = DEFAULT_LOGGER_KEY,
    suggestedLevel = DEFAULT_LOG_LEVEL,
    forcedLevel,
    commonDetails = {}
  } = {}, outputFn = console.log) {
    const internalState = {
      name,
      level: forcedLevel || suggestedLevel,
      commonDetails: { ...commonDetails
      },
      outputFn
    };
    let levelAsInt = 100; // so far
  
    const logger = ALL_LOG_LEVELS.reduce((logger, level) => {
      const primitive = function (rawMessage, rawDetails) {
        if (!isLevelEnabled(level)) return;
        const [message, details] = normalizeArguments(arguments);
        internalState.outputFn(serializer(level, message, details));
      };
  
      logger[level] = primitive;
      return logger;
    }, {
      setLevel,
      getLevel,
      addCommonDetails,
  
      group() {},
  
      groupCollapsed() {},
  
      groupEnd() {}
  
    });
  
    function setLevel(level) {
      checkLevel(level);
      internalState.level = level;
      levelAsInt = LOG_LEVEL_TO_INTEGER[level];
    }
  
    setLevel(getLevel()); // to check it
  
    function isLevelEnabled(level) {
      checkLevel(level);
      return LOG_LEVEL_TO_INTEGER[level] <= levelAsInt;
    }
  
    function getLevel() {
      return internalState.level;
    }
  
    function addCommonDetails(details) {
      if (details.err) throw new Error(`[${LIB}] Can't set reserved property "err"!`);
      internalState.commonDetails = { ...internalState.commonDetails,
        ...details
      };
    }
  
    function serializer(level, msg, {
      err,
      ...details
    }) {
      const payload = {
        level,
        name,
        msg,
        time: +new Date(),
        details: { ...internalState.commonDetails,
          ...details
        }
      };
      if (err) payload.err = err;
      return payload;
    }
  
    return logger;
  }
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/chalk/source/index.js
  var source = __webpack_require__(0);
  var source_default = /*#__PURE__*/__webpack_require__.n(source);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/2-foundation/prettify-any/dist/src.es2019/injectable-lib--chalk.js
  // to make this lib isomorphic, we allow dependency injections
  ////////////////////////////////////////////////////////////////////////////////////
  let chalk = null;
  function inject_lib__chalk(chalk_lib) {
    chalk = chalk_lib;
  }
  function get_lib__chalk() {
    return chalk;
  }
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/2-foundation/prettify-any/dist/src.es2019/utils.js
  ////////////////////////////////////
  // https://2ality.com/2012/03/signedzero.html (outdated)
  function is_negative_zero(x) {
    return Object.is(x, -0);
  } // https://stackoverflow.com/a/51398944/587407
  
  const COMPARABLE_TYPES = ['number', 'string'];
  function cmp(a, b) {
    const ta = typeof a;
    const tb = typeof b;
    if (ta !== tb) return cmp(ta, tb);
  
    if (!COMPARABLE_TYPES.includes(ta)) {
      // Very crude. mainly for symbols.
      return cmp(String(a), String(b));
    }
  
    return -(a < b) || +(a > b);
  }
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/2-foundation/prettify-any/dist/src.es2019/options--compatible.js
   ////////////////////////////////////////////////////////////////////////////////////
  
  const DEFAULTS_STYLE_OPTIONS = {
    max_width: null,
    outline: false,
    indent: 'tabs',
    max_primitive_str_size: null,
    should_recognize_constants: true,
    should_recognize_globals: true,
    quote: '\'',
    date_serialization_fn: 'toLocaleString'
  };
  const DEFAULTS_STYLIZE_OPTIONS__NONE = {
    stylize_dim: s => s,
    stylize_suspicious: s => s,
    stylize_error: s => s,
    stylize_global: s => s,
    stylize_primitive: s => s,
    stylize_syntax: s => s,
    stylize_user: s => s
  };
  const DEBUG = false;
  const DEFAULTS_PRETTIFY_OPTIONS = {
    // TODO follow max string size
    // primitives
    prettify_string: (s, st) => {
      const {
        o
      } = st;
      return o.stylize_dim(o.quote) + o.stylize_user(s) + o.stylize_dim(o.quote);
    },
    prettify_number: (n, st) => {
      const {
        o
      } = st;
  
      if (o.should_recognize_constants) {
        switch (n) {
          case Number.EPSILON:
            return o.stylize_global('Number.EPSILON');
  
          case Number.MAX_VALUE:
            return o.stylize_global('Number.MAX_VALUE');
  
          case Number.MIN_VALUE:
            return o.stylize_global('Number.MIN_VALUE');
  
          case Number.MAX_SAFE_INTEGER:
            return o.stylize_global('Number.MAX_SAFE_INTEGER');
  
          case Number.MIN_SAFE_INTEGER:
            return o.stylize_global('Number.MIN_SAFE_INTEGER');
  
          case Math.PI:
            return o.stylize_global('Math.PI');
  
          case Math.E:
            return o.stylize_global('Math.E');
          // no more Math, seldom used
  
          default: // fallback
  
        }
      }
  
      return isNaN(n) ? o.stylize_error(String(n)) : is_negative_zero(n) ? o.stylize_error('-0') : o.stylize_primitive(String(n));
    },
    prettify_bigint: (b, st) => {
      const {
        o
      } = st;
      return o.stylize_primitive(String(b) + 'n');
    },
    prettify_boolean: (b, st) => {
      const {
        o
      } = st;
      return o.stylize_primitive(String(b));
    },
    prettify_undefined: (u, st) => {
      const {
        o
      } = st;
      return o.stylize_suspicious(String(u));
    },
    prettify_symbol: (s, st) => {
      var _a;
  
      const {
        o
      } = st;
  
      try {
        return '' + o.stylize_global('Symbol') + o.stylize_syntax('(') + (s.description ? o.prettify_string(s.description, st) : '') + o.stylize_syntax(')');
      } catch (err) {
        return o.stylize_error(`[error prettifying:${(_a = err) === null || _a === void 0 ? void 0 : _a.message}/ps]`);
      }
    },
    // objects
    prettify_function: (f, st, {
      as_prop = false
    } = {}) => {
      const {
        o
      } = st;
  
      if (f.name && globalThis[f.name] === f) {
        return o.stylize_user(f.name);
      }
  
      let result = '';
  
      if (f.name) {
        if (!as_prop) {
          // class detection may not work with Babel
          result += o.stylize_syntax(f.toString().startsWith('class ') ? 'class ' : 'function ');
        }
  
        result += o.stylize_user(f.name);
      }
  
      result += o.stylize_syntax('()');
      result += o.stylize_syntax(f.name ? ' ' : ' => ');
      result += o.stylize_syntax('{');
      result += o.stylize_dim('\/\*…\*\/');
      result += o.stylize_syntax('}');
      return result;
    },
    prettify_array: (a, st) => {
      if (DEBUG) console.log('prettify_array', a);
      st = { ...st,
        circular: new Set([...Array.from(st.circular), a])
      };
      const {
        o
      } = st;
      return o.stylize_syntax('[') + a.map(e => o.prettify_any(e, st)) // NOTE when fully empty, map won't execute (but it looks nice, no pb)
      .join(o.stylize_syntax(',')) + o.stylize_syntax(']');
    },
    prettify_property_name: (p, st) => {
      var _a;
  
      const {
        o
      } = st;
  
      try {
        switch (typeof p) {
          case 'number':
            return o.prettify_number(p, st);
  
          case 'string':
            {
              // does it need to be quoted?
              // https://mathiasbynens.be/notes/javascript-properties
              return o.prettify_string(p, st);
            }
  
          case 'symbol':
            return o.stylize_syntax('[') + o.prettify_symbol(p, st) + o.stylize_syntax(']');
        }
      } catch (err) {
        return o.stylize_error(`[error prettifying:${(_a = err) === null || _a === void 0 ? void 0 : _a.message}/ppn]`);
      }
    },
    prettify_object: (obj, st, {
      skip_constructor = false
    } = {}) => {
      var _a, _b, _c;
  
      if (DEBUG) console.log('prettify_object', obj);
      const {
        o
      } = st;
  
      try {
        if (obj === null) return o.stylize_primitive('null');
        if (Array.isArray(obj)) return o.prettify_array(obj, st);
  
        if (o.should_recognize_globals) {
          try {
            switch (obj) {
              case globalThis:
                return o.stylize_global('globalThis');
  
              default: // fallback
  
            }
          } catch (err) {
            return o.stylize_error(`[error prettifying:${(_a = err) === null || _a === void 0 ? void 0 : _a.message}/po.g]`);
          }
        }
  
        if (!skip_constructor) {
          try {
            const proto = Object.getPrototypeOf(obj);
  
            if (proto && proto.constructor && proto.constructor.name) {
              // can we do better?
              if (proto.constructor !== Object) {
                return o.stylize_syntax('new ') + (globalThis[proto.constructor.name] === proto.constructor ? o.stylize_global(proto.constructor.name) : o.stylize_user(proto.constructor.name)) + o.stylize_syntax('(') + (() => {
                  switch (proto.constructor.name) {
                    // all primitives that can be an Object
                    case 'String':
                      return o.prettify_string(obj, st);
  
                    case 'Number':
                      return o.prettify_number(obj, st);
  
                    case 'Boolean':
                      return o.prettify_boolean(obj, st);
                    // recognize some objects
  
                    case 'Set':
                      return o.prettify_array(Array.from(obj.keys()), st);
  
                    case 'WeakSet':
                      return o.stylize_dim('/\*not enumerable*\/');
  
                    case 'Date':
                      return o.stylize_dim(`/*${obj[o.date_serialization_fn]()}*/`);
                    // node
  
                    case 'Buffer':
                      // too big!
                      return '/*…*/';
  
                    case 'Gunzip':
                      // seen in fetch_ponyfill response
                      // too big!
                      return '/*…*/';
                    // other
  
                    default:
                      if (proto.constructor.name.endsWith('Error')) {
                        const err = obj; // no need to pretty print it as copy/pastable to code,
                        // 99.9% chance that's not what we want here
  
                        return o.stylize_error(o.quote + err.message + o.quote);
                      } // Beware! This can turn into a huge thing, ex. a fetch response
                      // REM we MUST have skip_constructor = true to avoid infinite loops
  
  
                      return o.prettify_object(obj, st, {
                        skip_constructor: true
                      });
                    //return '/*…*/'
                  }
                })() + o.stylize_syntax(')');
              }
            }
          } catch (err) {
            return o.stylize_error(`[error prettifying:${(_b = err) === null || _b === void 0 ? void 0 : _b.message}/po.c]`);
          }
        }
  
        const keys = Reflect.ownKeys(obj).sort((a, b) => {
          let res = cmp(typeof a, typeof b);
  
          if (res === 0) {
            res = cmp(a, b);
          }
  
          return res;
        });
  
        if (keys.length === 0 && skip_constructor) {
          return o.stylize_dim(`/*${obj.toString()}*/`);
        }
  
        st = { ...st,
          circular: new Set([...Array.from(st.circular), obj])
        };
        return o.stylize_syntax('{') + keys.map(k => {
          const v = obj[k];
          if (typeof v === 'function' && v.name === k) return o.prettify_function(v, st, {
            as_prop: true
          });
          return o.prettify_property_name(k, st) + o.stylize_syntax(': ') + o.prettify_any(v, st);
        }).join(o.stylize_syntax(',')) + o.stylize_syntax('}');
      } catch (err) {
        return o.stylize_error(`[error prettifying:${(_c = err) === null || _c === void 0 ? void 0 : _c.message}/po]`);
      }
    },
  
    // root
    prettify_any(any, st) {
      var _a;
  
      if (DEBUG) console.log('prettify_any', any);
      const {
        o
      } = st;
  
      try {
        switch (typeof any) {
          /////// primitive type ///////
          case 'string':
            return o.prettify_string(any, st);
  
          case 'number':
            return o.prettify_number(any, st);
  
          case 'bigint':
            return o.prettify_bigint(any, st);
  
          case 'boolean':
            return o.prettify_boolean(any, st);
  
          case 'undefined':
            return o.prettify_undefined(any, st);
  
          case 'symbol':
            return o.prettify_symbol(any, st);
          /////// non-primitive type ///////
  
          case 'function':
            // special sub-type of object
            return o.prettify_function(any, st);
  
          case 'object':
            {
              if (any !== null) {
                if (st.circular.has(any)) return Array.isArray(any) ? o.stylize_error('[<Circular ref!>]') : o.stylize_error('{<Circular ref!>}');
              }
  
              return o.prettify_object(any, st);
            }
  
          default:
            return `[unsupported type:${typeof any}]`;
        }
      } catch (err) {
        return o.stylize_error(`[error prettifying:${(_a = err) === null || _a === void 0 ? void 0 : _a.message}/pa]`);
      }
    }
  
  };
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/2-foundation/prettify-any/dist/src.es2019/options--ansi.js
  function get_stylize_options_ansi(chalk) {
    return {
      stylize_dim: s => chalk.dim(s),
      stylize_suspicious: s => chalk.bold(s),
      stylize_error: s => chalk.red.bold(s),
      stylize_global: s => chalk.magenta(s),
      stylize_primitive: s => chalk.green(s),
      stylize_syntax: s => chalk.yellow(s),
      stylize_user: s => chalk.blue(s)
    };
  }
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/2-foundation/prettify-any/dist/src.es2019/options.js
  
  
   ////////////////////////////////////////////////////////////////////////////////////
  
  function get_default_options() {
    return { ...DEFAULTS_STYLE_OPTIONS,
      ...DEFAULTS_PRETTIFY_OPTIONS,
      ...DEFAULTS_STYLIZE_OPTIONS__NONE,
      ...(get_lib__chalk() && get_stylize_options_ansi(get_lib__chalk()))
    };
  }
  function get_options(options = {}) {
    return { ...get_default_options(),
      ...options
    };
  }
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/2-foundation/prettify-any/dist/src.es2019/v2.js
   ////////////////////////////////////
  
  function create_state(options) {
    return {
      o: get_options(options),
      circular: new WeakSet()
    };
  }
  
  function prettify_any(js, options = {}) {
    var _a;
  
    try {
      const st = create_state(get_options(options));
      return st.o.prettify_any(js, st);
    } catch (err) {
      return `[error prettifying:${(_a = err) === null || _a === void 0 ? void 0 : _a.message}]`;
    }
  }
  function prettify_json(js, options = {}) {
    const st = create_state(get_options(options)); // TODO show not JSON
  
    return st.o.prettify_any(js, st);
  }
  function dump_prettified_any(msg, data, options = {}) {
    console.log(msg);
    console.log(prettify_any(data, options));
  }
  function is_pure_json(js) {
    return false;
  }
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/2-foundation/error-utils/dist/src.es2019/fields.js
  var fields = __webpack_require__(24);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/2-foundation/print-error-to-ansi/dist/src.es2019/index.js
  /* eslint-disable no-console */
  
   // TODO make it more pro!
  
  function displayErrProp(errLike, prop) {
    if (prop === 'details') {
      const details = errLike.details;
      console.error(source_default.a.red(source_default.a.dim(`🔥  ${prop}:`)));
      Object.entries(details).forEach(([key, value]) => {
        console.error(source_default.a.red(source_default.a.dim(`    ${key}: "`) + value + source_default.a.dim('"')));
      });
    } else if (prop === 'stack') {
      // TODO clean / shorten / relative
      console.error(source_default.a.red(source_default.a.dim(`🔥  ${prop}: "`) + errLike[prop] + source_default.a.dim('"')));
    } else console.error(source_default.a.red(source_default.a.dim(`🔥  ${prop}: "`) + errLike[prop] + source_default.a.dim('"')));
  }
  
  function displayError(errLike = {}) {
    console.error(source_default.a.red(`🔥🔥🔥🔥🔥🔥🔥  ${source_default.a.bold(errLike.name || 'Error')} 🔥🔥🔥🔥🔥🔥🔥`)); // TODO use normalize error?
  
    const displayedProps = new Set();
    displayedProps.add('name');
  
    if (errLike.message) {
      displayErrProp(errLike, 'message');
      displayedProps.add('message');
    }
  
    if (errLike.details) {
      displayErrProp(errLike, 'details');
      displayedProps.add('details');
    }
  
    fields["b" /* COMMON_ERROR_FIELDS_EXTENDED */].forEach(prop => {
      if (prop in errLike && !displayedProps.has(prop)) {
        displayErrProp(errLike, prop);
      }
    });
  }
  
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/2-foundation/practical-logger-node/dist/src.es2019/sinks/common.js
  
  
  const MIN_WIDTH = 7;
  
  function to_aligned_ascii(level) {
    let lvl = level.toUpperCase();
    /*while (lvl.length <= MIN_WIDTH - 2) {
        lvl = ' ' + lvl + ' '
    }*/
  
    if (lvl.length < MIN_WIDTH) lvl = (lvl + '         ').slice(0, MIN_WIDTH);
    return lvl;
  }
  
  const LEVEL_TO_ASCII = {
    fatal: source_default.a.bgRed.white.bold(to_aligned_ascii(' ' + LOG_LEVEL_TO_HUMAN['fatal'])),
    emerg: source_default.a.bgRed.white.bold(to_aligned_ascii(LOG_LEVEL_TO_HUMAN['emerg'])),
    alert: source_default.a.bgRed.white.bold(to_aligned_ascii(' ' + LOG_LEVEL_TO_HUMAN['alert'])),
    crit: source_default.a.bgRed.white.bold(to_aligned_ascii(LOG_LEVEL_TO_HUMAN['crit'])),
    error: source_default.a.red.bold(to_aligned_ascii(LOG_LEVEL_TO_HUMAN['error'])),
    warning: source_default.a.yellow.bold(to_aligned_ascii(LOG_LEVEL_TO_HUMAN['warning'])),
    warn: source_default.a.yellow.bold(to_aligned_ascii(LOG_LEVEL_TO_HUMAN['warn'])),
    notice: source_default.a.blue(to_aligned_ascii(LOG_LEVEL_TO_HUMAN['notice'])),
    info: source_default.a.blue(to_aligned_ascii(LOG_LEVEL_TO_HUMAN['info'])),
    verbose: to_aligned_ascii(LOG_LEVEL_TO_HUMAN['verbose']),
    log: to_aligned_ascii(LOG_LEVEL_TO_HUMAN['log']),
    debug: to_aligned_ascii(LOG_LEVEL_TO_HUMAN['debug']),
    trace: source_default.a.dim(to_aligned_ascii(LOG_LEVEL_TO_HUMAN['trace'])),
    silly: source_default.a.dim(to_aligned_ascii(LOG_LEVEL_TO_HUMAN['silly']))
  };
  const LEVEL_TO_STYLIZE = {
    fatal: s => source_default.a.red.bold(s),
    emerg: s => source_default.a.red.bold(s),
    alert: s => source_default.a.red.bold(s),
    crit: s => source_default.a.red.bold(s),
    error: s => source_default.a.red.bold(s),
    warning: s => source_default.a.yellow(s),
    warn: s => source_default.a.yellow(s),
    notice: s => source_default.a.blue(s),
    info: s => source_default.a.blue(s),
    verbose: s => s,
    log: s => s,
    debug: s => s,
    trace: s => source_default.a.dim(s),
    silly: s => source_default.a.dim(s)
  };
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/2-foundation/practical-logger-node/dist/src.es2019/sinks/to-console.js
  /* eslint-disable no-console */
  
  
  
  inject_lib__chalk(source_default.a);
  
  function createSink(options = {}) {
    const displayTime = options.displayTime || false;
    return payload => {
      const {
        level,
        name,
        msg,
        time,
        details,
        err
      } = payload;
      let line = [displayTime ? source_default.a.dim(String(time)) : '', LEVEL_TO_ASCII[level] + '›', LEVEL_TO_STYLIZE[level]([name, msg].filter(x => !!x).join('› ')), Reflect.ownKeys(details).length === 0 ? '' //: (' ' + JSON.stringify(details))
      : prettify_any(details, {//line_width:
        //first_line_already_used:
      })].filter(x => !!x).join(' ');
      console.log(line); // eslint-disable-line no-console
  
      if (err) displayError(err);
    };
  }
  /* harmony default export */ var to_console = (createSink);
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/2-foundation/practical-logger-node/dist/src.es2019/index.js
  
  
  const ORIGINAL_CONSOLE = console;
  
  function createLogger(p = {}) {
    var _a;
  
    const {
      group,
      groupCollapsed,
      groupEnd
    } = ORIGINAL_CONSOLE;
    return { ...create(p, ((_a = p.sinkOptions) === null || _a === void 0 ? void 0 : _a.sink) || to_console(p.sinkOptions)),
      group,
      groupCollapsed,
      groupEnd
    };
  }
  
  
  
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/3-advanced--multi/universal-debug-api-node/dist/src.es2019/consts.js
  const ENV_ROOT = 'UDA';
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/3-advanced--multi/universal-debug-api-node/dist/src.es2019/v1/keys.js
  
  
  
  function normalizeKey(key) {
    return key.split('-').join('_').split('.').join('_').split('⋄').join('_').split('∙').join('_').split('ꘌ').join('_').split('ꓺ').join('_').split('ː').join('_');
  }
  
  function getOverrideKeyForLogger(name) {
    return `logger_${name || 'default'}_logLevel`.toUpperCase();
  }
  function getEnvKeyForOverride(key) {
    // should we put v1 somewhere? no, most likely overkill.
    return `${ENV_ROOT}_override__${normalizeKey(key)}`.toUpperCase();
  }
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/3-advanced--multi/universal-debug-api-node/dist/src.es2019/v1/index.js
  
  
   ////////////////////////////////////
  
  const OWN_LOGGER_NAME = ENV_ROOT;
  const REVISION = 100.; ////////////////////////////////////
  
  function v1_create() {
    //console.trace('[UDA--node installing…]')
    ////////////////////////////////////
    const loggers = {}; // to avoid creating duplicates
  
    const debugCommands = {}; // TODO check
  
    const exposed = {};
    const overrides = {}; // we'll expose them for clarity
    ////////////////////////////////////
    // TODO override?
    // TODO allow off?
  
    const _ownLogger = createLogger({
      name: OWN_LOGGER_NAME,
      suggestedLevel: 'fatal' // level adjustable, see below
  
    });
  
    function _getOverrideRequestedSJson(ovKey) {
      try {
        const EnvKey = getEnvKeyForOverride(ovKey); //console.log(`- reading EnvKey = "${EnvKey}"`)
  
        const rawValue = process.env[EnvKey] || null; //console.log(`   ↳ read EnvKey "${EnvKey}", content = "${rawValue}"`)
  
        return rawValue;
      } catch (err) {
        _ownLogger.warn(`🔴 error reading ENV for override "${ovKey}"!`, {
          err
        });
  
        return null;
      }
    }
  
    const forcedLevel = _getOverrideRequestedSJson(getOverrideKeyForLogger('_UDA_internal'));
  
    try {
      if (forcedLevel) _ownLogger.setLevel(JSON.parse(forcedLevel));
    } catch (err) {
      _ownLogger.fatal(`🔴 error setting internal logger forced level: "${forcedLevel}"!`);
    }
  
    _ownLogger.debug(`Instantiated. (revision: ${REVISION})`);
  
    function _getOverride(key) {
      if (!overrides[key]) {
        // we only read the env once for speed reason
        overrides[key] = {
          // so far:
          isOn: false,
          value: undefined
        };
  
        const rawValue = _getOverrideRequestedSJson(key);
  
        if (rawValue) {
          overrides[key].isOn = true; // for the node version where escaping is hard, as a convenience, we auto-type common cases
  
          const value = (() => {
            // we allow the non-JSON "undefined"
            if (rawValue === 'undefined') return undefined;
            if (String(Number(rawValue)) === rawValue) return Number(rawValue);
  
            try {
              return JSON.parse(rawValue);
            } catch {
              return rawValue; // as a string
            }
          })();
  
          overrides[key].value = value;
  
          _ownLogger.log(` 🔵 overriden "${key}"`, {
            override: value
          });
        }
      }
  
      return overrides[key];
    } ////////////////////////////////////
  
  
    const api = {
      getLogger,
      exposeInternal,
      overrideHook,
      addDebugCommand,
      _: {
        exposed,
        overrides,
        minor: REVISION,
        source: 'node-lib',
        create: v1_create
      }
    }; ////////////////////////////////////
  
    function overrideHook(key, defaultValue) {
      try {
        const status = _getOverride(key);
  
        if (status.isOn) return status.value;
      } catch (err) {
        // should never happen because _getOverride() already catch
        // TODO check!
        _ownLogger.warn('overrideHook(): error retrieving override!', {
          key,
          err
        });
      }
  
      return defaultValue;
    }
  
    function getLogger(p = {}) {
      const name = p.name || DEFAULT_LOGGER_KEY; // we need a name immediately
  
      if (!loggers[name]) {
        try {
          const ovKey = getOverrideKeyForLogger(name);
  
          if (!p.forcedLevel && _getOverrideRequestedSJson(ovKey)) {
            p = { ...p,
              forcedLevel: overrideHook(ovKey, p.suggestedLevel || DEFAULT_LOG_LEVEL)
            };
          }
        } catch (err) {
          // this warning should appear only once on creation ✔
          _ownLogger.warn('getLogger(): error overriding the level!', {
            name,
            err
          });
        }
  
        loggers[name] = createLogger(p);
      }
  
      return loggers[name];
    }
  
    function exposeInternal(path, value) {
      _ownLogger.warn(`exposeInternal(): alpha, not documented!`);
  
      try {
        const pathParts = path.split('.'); // TODO switch to / ?
  
        const lastIndex = pathParts.length - 1;
        let root = exposed;
        pathParts.forEach((p, index) => {
          root[p] = root[p] || (index === lastIndex ? value : {});
          root = root[p];
        });
      } catch (err) {
        _ownLogger.warn(`exposeInternal(): error exposing!`, {
          path,
          err
        });
      }
    }
  
    function addDebugCommand(commandName, callback) {
      // TODO
      _ownLogger.warn(`addDebugCommand(): alpha, not documented!`); // TODO try catch
  
  
      debugCommands[commandName] = callback;
    }
  
    return api;
  }
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/3-advanced--multi/universal-debug-api-node/dist/src.es2019/index.js
  
  
  const src_es2019_globalThis = Object(src_es2019["a" /* getGlobalThis */])(); // ensure the root is present
  
  src_es2019_globalThis._debug = src_es2019_globalThis._debug || {};
  const root = src_es2019_globalThis._debug; //////////// v1 ////////////
  // TODO extract this common code!
  // install globally if no better implementation already present
  
  root.v1 = (existing => {
    // We CAN'T replace an existing one, even if we are more recent,
    // because the existing one may already have been called
    // and be having a state that can't be carried over.
    // HOWEVER some hints may help the user:
    const candidate = v1_create();
    let ownLogger = candidate.getLogger({
      name: OWN_LOGGER_NAME
    });
    ownLogger.debug('as a candidate, attempting to attach…');
  
    if (!existing) {
      ownLogger.debug('nominal install ✅');
      return candidate; // nominal case, current = real implementation is first
    } // something is wrong,
    // help the user figure it out
  
  
    let isExistingAPlaceholder = !existing._; // we know that the placeholder doesn't define this optional prop
  
    if (isExistingAPlaceholder) {
      ownLogger.warn('install warning: a placeholder is already present, you may miss some calls! the true implementation should be imported earlier!'); // better than nothing, may still miss some calls
  
      ownLogger.log('as a candidate, replacing existing ⚠');
      return candidate;
    }
  
    ownLogger = existing.getLogger({
      name: OWN_LOGGER_NAME
    });
    ownLogger.warn('install warning: several true implementation coexists, only the top module should import it. Check your submodules!');
  
    try {
      const minVersion = Math.min(existing._.minor, candidate._.minor);
      if (minVersion !== candidate._.minor) ownLogger.warn(`install warning: several true implementation coexists, including an outdated one: "v${minVersion}"!`);
    } catch (err) {
      ownLogger.warn(err);
    }
  
    ownLogger.log('as a candidate, discarding myself: existing is good enough ✅');
    return existing; // don't replace
  })(root.v1); //////////// latest ////////////
  // directly expose the latest implementation known to this lib
  
  
  const instance = root.v1;
  const {
    getLogger: src_es2019_getLogger,
    exposeInternal: src_es2019_exposeInternal,
    overrideHook: src_es2019_overrideHook,
    addDebugCommand: src_es2019_addDebugCommand
  } = instance;
   // types
  
  
  
  /***/ }),
  
  /***/ 61:
  /***/ (function(module, exports, __webpack_require__) {
  
  /* MIT license */
  /* eslint-disable no-mixed-operators */
  const cssKeywords = __webpack_require__(99);
  
  // NOTE: conversions should only return primitive values (i.e. arrays, or
  //       values that give correct `typeof` results).
  //       do not use box values types (i.e. Number(), String(), etc.)
  
  const reverseKeywords = {};
  for (const key of Object.keys(cssKeywords)) {
  	reverseKeywords[cssKeywords[key]] = key;
  }
  
  const convert = {
  	rgb: {channels: 3, labels: 'rgb'},
  	hsl: {channels: 3, labels: 'hsl'},
  	hsv: {channels: 3, labels: 'hsv'},
  	hwb: {channels: 3, labels: 'hwb'},
  	cmyk: {channels: 4, labels: 'cmyk'},
  	xyz: {channels: 3, labels: 'xyz'},
  	lab: {channels: 3, labels: 'lab'},
  	lch: {channels: 3, labels: 'lch'},
  	hex: {channels: 1, labels: ['hex']},
  	keyword: {channels: 1, labels: ['keyword']},
  	ansi16: {channels: 1, labels: ['ansi16']},
  	ansi256: {channels: 1, labels: ['ansi256']},
  	hcg: {channels: 3, labels: ['h', 'c', 'g']},
  	apple: {channels: 3, labels: ['r16', 'g16', 'b16']},
  	gray: {channels: 1, labels: ['gray']}
  };
  
  module.exports = convert;
  
  // Hide .channels and .labels properties
  for (const model of Object.keys(convert)) {
  	if (!('channels' in convert[model])) {
  		throw new Error('missing channels property: ' + model);
  	}
  
  	if (!('labels' in convert[model])) {
  		throw new Error('missing channel labels property: ' + model);
  	}
  
  	if (convert[model].labels.length !== convert[model].channels) {
  		throw new Error('channel and label counts mismatch: ' + model);
  	}
  
  	const {channels, labels} = convert[model];
  	delete convert[model].channels;
  	delete convert[model].labels;
  	Object.defineProperty(convert[model], 'channels', {value: channels});
  	Object.defineProperty(convert[model], 'labels', {value: labels});
  }
  
  convert.rgb.hsl = function (rgb) {
  	const r = rgb[0] / 255;
  	const g = rgb[1] / 255;
  	const b = rgb[2] / 255;
  	const min = Math.min(r, g, b);
  	const max = Math.max(r, g, b);
  	const delta = max - min;
  	let h;
  	let s;
  
  	if (max === min) {
  		h = 0;
  	} else if (r === max) {
  		h = (g - b) / delta;
  	} else if (g === max) {
  		h = 2 + (b - r) / delta;
  	} else if (b === max) {
  		h = 4 + (r - g) / delta;
  	}
  
  	h = Math.min(h * 60, 360);
  
  	if (h < 0) {
  		h += 360;
  	}
  
  	const l = (min + max) / 2;
  
  	if (max === min) {
  		s = 0;
  	} else if (l <= 0.5) {
  		s = delta / (max + min);
  	} else {
  		s = delta / (2 - max - min);
  	}
  
  	return [h, s * 100, l * 100];
  };
  
  convert.rgb.hsv = function (rgb) {
  	let rdif;
  	let gdif;
  	let bdif;
  	let h;
  	let s;
  
  	const r = rgb[0] / 255;
  	const g = rgb[1] / 255;
  	const b = rgb[2] / 255;
  	const v = Math.max(r, g, b);
  	const diff = v - Math.min(r, g, b);
  	const diffc = function (c) {
  		return (v - c) / 6 / diff + 1 / 2;
  	};
  
  	if (diff === 0) {
  		h = 0;
  		s = 0;
  	} else {
  		s = diff / v;
  		rdif = diffc(r);
  		gdif = diffc(g);
  		bdif = diffc(b);
  
  		if (r === v) {
  			h = bdif - gdif;
  		} else if (g === v) {
  			h = (1 / 3) + rdif - bdif;
  		} else if (b === v) {
  			h = (2 / 3) + gdif - rdif;
  		}
  
  		if (h < 0) {
  			h += 1;
  		} else if (h > 1) {
  			h -= 1;
  		}
  	}
  
  	return [
  		h * 360,
  		s * 100,
  		v * 100
  	];
  };
  
  convert.rgb.hwb = function (rgb) {
  	const r = rgb[0];
  	const g = rgb[1];
  	let b = rgb[2];
  	const h = convert.rgb.hsl(rgb)[0];
  	const w = 1 / 255 * Math.min(r, Math.min(g, b));
  
  	b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
  
  	return [h, w * 100, b * 100];
  };
  
  convert.rgb.cmyk = function (rgb) {
  	const r = rgb[0] / 255;
  	const g = rgb[1] / 255;
  	const b = rgb[2] / 255;
  
  	const k = Math.min(1 - r, 1 - g, 1 - b);
  	const c = (1 - r - k) / (1 - k) || 0;
  	const m = (1 - g - k) / (1 - k) || 0;
  	const y = (1 - b - k) / (1 - k) || 0;
  
  	return [c * 100, m * 100, y * 100, k * 100];
  };
  
  function comparativeDistance(x, y) {
  	/*
  		See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
  	*/
  	return (
  		((x[0] - y[0]) ** 2) +
  		((x[1] - y[1]) ** 2) +
  		((x[2] - y[2]) ** 2)
  	);
  }
  
  convert.rgb.keyword = function (rgb) {
  	const reversed = reverseKeywords[rgb];
  	if (reversed) {
  		return reversed;
  	}
  
  	let currentClosestDistance = Infinity;
  	let currentClosestKeyword;
  
  	for (const keyword of Object.keys(cssKeywords)) {
  		const value = cssKeywords[keyword];
  
  		// Compute comparative distance
  		const distance = comparativeDistance(rgb, value);
  
  		// Check if its less, if so set as closest
  		if (distance < currentClosestDistance) {
  			currentClosestDistance = distance;
  			currentClosestKeyword = keyword;
  		}
  	}
  
  	return currentClosestKeyword;
  };
  
  convert.keyword.rgb = function (keyword) {
  	return cssKeywords[keyword];
  };
  
  convert.rgb.xyz = function (rgb) {
  	let r = rgb[0] / 255;
  	let g = rgb[1] / 255;
  	let b = rgb[2] / 255;
  
  	// Assume sRGB
  	r = r > 0.04045 ? (((r + 0.055) / 1.055) ** 2.4) : (r / 12.92);
  	g = g > 0.04045 ? (((g + 0.055) / 1.055) ** 2.4) : (g / 12.92);
  	b = b > 0.04045 ? (((b + 0.055) / 1.055) ** 2.4) : (b / 12.92);
  
  	const x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);
  	const y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
  	const z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);
  
  	return [x * 100, y * 100, z * 100];
  };
  
  convert.rgb.lab = function (rgb) {
  	const xyz = convert.rgb.xyz(rgb);
  	let x = xyz[0];
  	let y = xyz[1];
  	let z = xyz[2];
  
  	x /= 95.047;
  	y /= 100;
  	z /= 108.883;
  
  	x = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);
  	y = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);
  	z = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);
  
  	const l = (116 * y) - 16;
  	const a = 500 * (x - y);
  	const b = 200 * (y - z);
  
  	return [l, a, b];
  };
  
  convert.hsl.rgb = function (hsl) {
  	const h = hsl[0] / 360;
  	const s = hsl[1] / 100;
  	const l = hsl[2] / 100;
  	let t2;
  	let t3;
  	let val;
  
  	if (s === 0) {
  		val = l * 255;
  		return [val, val, val];
  	}
  
  	if (l < 0.5) {
  		t2 = l * (1 + s);
  	} else {
  		t2 = l + s - l * s;
  	}
  
  	const t1 = 2 * l - t2;
  
  	const rgb = [0, 0, 0];
  	for (let i = 0; i < 3; i++) {
  		t3 = h + 1 / 3 * -(i - 1);
  		if (t3 < 0) {
  			t3++;
  		}
  
  		if (t3 > 1) {
  			t3--;
  		}
  
  		if (6 * t3 < 1) {
  			val = t1 + (t2 - t1) * 6 * t3;
  		} else if (2 * t3 < 1) {
  			val = t2;
  		} else if (3 * t3 < 2) {
  			val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
  		} else {
  			val = t1;
  		}
  
  		rgb[i] = val * 255;
  	}
  
  	return rgb;
  };
  
  convert.hsl.hsv = function (hsl) {
  	const h = hsl[0];
  	let s = hsl[1] / 100;
  	let l = hsl[2] / 100;
  	let smin = s;
  	const lmin = Math.max(l, 0.01);
  
  	l *= 2;
  	s *= (l <= 1) ? l : 2 - l;
  	smin *= lmin <= 1 ? lmin : 2 - lmin;
  	const v = (l + s) / 2;
  	const sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);
  
  	return [h, sv * 100, v * 100];
  };
  
  convert.hsv.rgb = function (hsv) {
  	const h = hsv[0] / 60;
  	const s = hsv[1] / 100;
  	let v = hsv[2] / 100;
  	const hi = Math.floor(h) % 6;
  
  	const f = h - Math.floor(h);
  	const p = 255 * v * (1 - s);
  	const q = 255 * v * (1 - (s * f));
  	const t = 255 * v * (1 - (s * (1 - f)));
  	v *= 255;
  
  	switch (hi) {
  		case 0:
  			return [v, t, p];
  		case 1:
  			return [q, v, p];
  		case 2:
  			return [p, v, t];
  		case 3:
  			return [p, q, v];
  		case 4:
  			return [t, p, v];
  		case 5:
  			return [v, p, q];
  	}
  };
  
  convert.hsv.hsl = function (hsv) {
  	const h = hsv[0];
  	const s = hsv[1] / 100;
  	const v = hsv[2] / 100;
  	const vmin = Math.max(v, 0.01);
  	let sl;
  	let l;
  
  	l = (2 - s) * v;
  	const lmin = (2 - s) * vmin;
  	sl = s * vmin;
  	sl /= (lmin <= 1) ? lmin : 2 - lmin;
  	sl = sl || 0;
  	l /= 2;
  
  	return [h, sl * 100, l * 100];
  };
  
  // http://dev.w3.org/csswg/css-color/#hwb-to-rgb
  convert.hwb.rgb = function (hwb) {
  	const h = hwb[0] / 360;
  	let wh = hwb[1] / 100;
  	let bl = hwb[2] / 100;
  	const ratio = wh + bl;
  	let f;
  
  	// Wh + bl cant be > 1
  	if (ratio > 1) {
  		wh /= ratio;
  		bl /= ratio;
  	}
  
  	const i = Math.floor(6 * h);
  	const v = 1 - bl;
  	f = 6 * h - i;
  
  	if ((i & 0x01) !== 0) {
  		f = 1 - f;
  	}
  
  	const n = wh + f * (v - wh); // Linear interpolation
  
  	let r;
  	let g;
  	let b;
  	/* eslint-disable max-statements-per-line,no-multi-spaces */
  	switch (i) {
  		default:
  		case 6:
  		case 0: r = v;  g = n;  b = wh; break;
  		case 1: r = n;  g = v;  b = wh; break;
  		case 2: r = wh; g = v;  b = n; break;
  		case 3: r = wh; g = n;  b = v; break;
  		case 4: r = n;  g = wh; b = v; break;
  		case 5: r = v;  g = wh; b = n; break;
  	}
  	/* eslint-enable max-statements-per-line,no-multi-spaces */
  
  	return [r * 255, g * 255, b * 255];
  };
  
  convert.cmyk.rgb = function (cmyk) {
  	const c = cmyk[0] / 100;
  	const m = cmyk[1] / 100;
  	const y = cmyk[2] / 100;
  	const k = cmyk[3] / 100;
  
  	const r = 1 - Math.min(1, c * (1 - k) + k);
  	const g = 1 - Math.min(1, m * (1 - k) + k);
  	const b = 1 - Math.min(1, y * (1 - k) + k);
  
  	return [r * 255, g * 255, b * 255];
  };
  
  convert.xyz.rgb = function (xyz) {
  	const x = xyz[0] / 100;
  	const y = xyz[1] / 100;
  	const z = xyz[2] / 100;
  	let r;
  	let g;
  	let b;
  
  	r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
  	g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
  	b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);
  
  	// Assume sRGB
  	r = r > 0.0031308
  		? ((1.055 * (r ** (1.0 / 2.4))) - 0.055)
  		: r * 12.92;
  
  	g = g > 0.0031308
  		? ((1.055 * (g ** (1.0 / 2.4))) - 0.055)
  		: g * 12.92;
  
  	b = b > 0.0031308
  		? ((1.055 * (b ** (1.0 / 2.4))) - 0.055)
  		: b * 12.92;
  
  	r = Math.min(Math.max(0, r), 1);
  	g = Math.min(Math.max(0, g), 1);
  	b = Math.min(Math.max(0, b), 1);
  
  	return [r * 255, g * 255, b * 255];
  };
  
  convert.xyz.lab = function (xyz) {
  	let x = xyz[0];
  	let y = xyz[1];
  	let z = xyz[2];
  
  	x /= 95.047;
  	y /= 100;
  	z /= 108.883;
  
  	x = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);
  	y = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);
  	z = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);
  
  	const l = (116 * y) - 16;
  	const a = 500 * (x - y);
  	const b = 200 * (y - z);
  
  	return [l, a, b];
  };
  
  convert.lab.xyz = function (lab) {
  	const l = lab[0];
  	const a = lab[1];
  	const b = lab[2];
  	let x;
  	let y;
  	let z;
  
  	y = (l + 16) / 116;
  	x = a / 500 + y;
  	z = y - b / 200;
  
  	const y2 = y ** 3;
  	const x2 = x ** 3;
  	const z2 = z ** 3;
  	y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
  	x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
  	z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
  
  	x *= 95.047;
  	y *= 100;
  	z *= 108.883;
  
  	return [x, y, z];
  };
  
  convert.lab.lch = function (lab) {
  	const l = lab[0];
  	const a = lab[1];
  	const b = lab[2];
  	let h;
  
  	const hr = Math.atan2(b, a);
  	h = hr * 360 / 2 / Math.PI;
  
  	if (h < 0) {
  		h += 360;
  	}
  
  	const c = Math.sqrt(a * a + b * b);
  
  	return [l, c, h];
  };
  
  convert.lch.lab = function (lch) {
  	const l = lch[0];
  	const c = lch[1];
  	const h = lch[2];
  
  	const hr = h / 360 * 2 * Math.PI;
  	const a = c * Math.cos(hr);
  	const b = c * Math.sin(hr);
  
  	return [l, a, b];
  };
  
  convert.rgb.ansi16 = function (args, saturation = null) {
  	const [r, g, b] = args;
  	let value = saturation === null ? convert.rgb.hsv(args)[2] : saturation; // Hsv -> ansi16 optimization
  
  	value = Math.round(value / 50);
  
  	if (value === 0) {
  		return 30;
  	}
  
  	let ansi = 30
  		+ ((Math.round(b / 255) << 2)
  		| (Math.round(g / 255) << 1)
  		| Math.round(r / 255));
  
  	if (value === 2) {
  		ansi += 60;
  	}
  
  	return ansi;
  };
  
  convert.hsv.ansi16 = function (args) {
  	// Optimization here; we already know the value and don't need to get
  	// it converted for us.
  	return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
  };
  
  convert.rgb.ansi256 = function (args) {
  	const r = args[0];
  	const g = args[1];
  	const b = args[2];
  
  	// We use the extended greyscale palette here, with the exception of
  	// black and white. normal palette only has 4 greyscale shades.
  	if (r === g && g === b) {
  		if (r < 8) {
  			return 16;
  		}
  
  		if (r > 248) {
  			return 231;
  		}
  
  		return Math.round(((r - 8) / 247) * 24) + 232;
  	}
  
  	const ansi = 16
  		+ (36 * Math.round(r / 255 * 5))
  		+ (6 * Math.round(g / 255 * 5))
  		+ Math.round(b / 255 * 5);
  
  	return ansi;
  };
  
  convert.ansi16.rgb = function (args) {
  	let color = args % 10;
  
  	// Handle greyscale
  	if (color === 0 || color === 7) {
  		if (args > 50) {
  			color += 3.5;
  		}
  
  		color = color / 10.5 * 255;
  
  		return [color, color, color];
  	}
  
  	const mult = (~~(args > 50) + 1) * 0.5;
  	const r = ((color & 1) * mult) * 255;
  	const g = (((color >> 1) & 1) * mult) * 255;
  	const b = (((color >> 2) & 1) * mult) * 255;
  
  	return [r, g, b];
  };
  
  convert.ansi256.rgb = function (args) {
  	// Handle greyscale
  	if (args >= 232) {
  		const c = (args - 232) * 10 + 8;
  		return [c, c, c];
  	}
  
  	args -= 16;
  
  	let rem;
  	const r = Math.floor(args / 36) / 5 * 255;
  	const g = Math.floor((rem = args % 36) / 6) / 5 * 255;
  	const b = (rem % 6) / 5 * 255;
  
  	return [r, g, b];
  };
  
  convert.rgb.hex = function (args) {
  	const integer = ((Math.round(args[0]) & 0xFF) << 16)
  		+ ((Math.round(args[1]) & 0xFF) << 8)
  		+ (Math.round(args[2]) & 0xFF);
  
  	const string = integer.toString(16).toUpperCase();
  	return '000000'.substring(string.length) + string;
  };
  
  convert.hex.rgb = function (args) {
  	const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
  	if (!match) {
  		return [0, 0, 0];
  	}
  
  	let colorString = match[0];
  
  	if (match[0].length === 3) {
  		colorString = colorString.split('').map(char => {
  			return char + char;
  		}).join('');
  	}
  
  	const integer = parseInt(colorString, 16);
  	const r = (integer >> 16) & 0xFF;
  	const g = (integer >> 8) & 0xFF;
  	const b = integer & 0xFF;
  
  	return [r, g, b];
  };
  
  convert.rgb.hcg = function (rgb) {
  	const r = rgb[0] / 255;
  	const g = rgb[1] / 255;
  	const b = rgb[2] / 255;
  	const max = Math.max(Math.max(r, g), b);
  	const min = Math.min(Math.min(r, g), b);
  	const chroma = (max - min);
  	let grayscale;
  	let hue;
  
  	if (chroma < 1) {
  		grayscale = min / (1 - chroma);
  	} else {
  		grayscale = 0;
  	}
  
  	if (chroma <= 0) {
  		hue = 0;
  	} else
  	if (max === r) {
  		hue = ((g - b) / chroma) % 6;
  	} else
  	if (max === g) {
  		hue = 2 + (b - r) / chroma;
  	} else {
  		hue = 4 + (r - g) / chroma;
  	}
  
  	hue /= 6;
  	hue %= 1;
  
  	return [hue * 360, chroma * 100, grayscale * 100];
  };
  
  convert.hsl.hcg = function (hsl) {
  	const s = hsl[1] / 100;
  	const l = hsl[2] / 100;
  
  	const c = l < 0.5 ? (2.0 * s * l) : (2.0 * s * (1.0 - l));
  
  	let f = 0;
  	if (c < 1.0) {
  		f = (l - 0.5 * c) / (1.0 - c);
  	}
  
  	return [hsl[0], c * 100, f * 100];
  };
  
  convert.hsv.hcg = function (hsv) {
  	const s = hsv[1] / 100;
  	const v = hsv[2] / 100;
  
  	const c = s * v;
  	let f = 0;
  
  	if (c < 1.0) {
  		f = (v - c) / (1 - c);
  	}
  
  	return [hsv[0], c * 100, f * 100];
  };
  
  convert.hcg.rgb = function (hcg) {
  	const h = hcg[0] / 360;
  	const c = hcg[1] / 100;
  	const g = hcg[2] / 100;
  
  	if (c === 0.0) {
  		return [g * 255, g * 255, g * 255];
  	}
  
  	const pure = [0, 0, 0];
  	const hi = (h % 1) * 6;
  	const v = hi % 1;
  	const w = 1 - v;
  	let mg = 0;
  
  	/* eslint-disable max-statements-per-line */
  	switch (Math.floor(hi)) {
  		case 0:
  			pure[0] = 1; pure[1] = v; pure[2] = 0; break;
  		case 1:
  			pure[0] = w; pure[1] = 1; pure[2] = 0; break;
  		case 2:
  			pure[0] = 0; pure[1] = 1; pure[2] = v; break;
  		case 3:
  			pure[0] = 0; pure[1] = w; pure[2] = 1; break;
  		case 4:
  			pure[0] = v; pure[1] = 0; pure[2] = 1; break;
  		default:
  			pure[0] = 1; pure[1] = 0; pure[2] = w;
  	}
  	/* eslint-enable max-statements-per-line */
  
  	mg = (1.0 - c) * g;
  
  	return [
  		(c * pure[0] + mg) * 255,
  		(c * pure[1] + mg) * 255,
  		(c * pure[2] + mg) * 255
  	];
  };
  
  convert.hcg.hsv = function (hcg) {
  	const c = hcg[1] / 100;
  	const g = hcg[2] / 100;
  
  	const v = c + g * (1.0 - c);
  	let f = 0;
  
  	if (v > 0.0) {
  		f = c / v;
  	}
  
  	return [hcg[0], f * 100, v * 100];
  };
  
  convert.hcg.hsl = function (hcg) {
  	const c = hcg[1] / 100;
  	const g = hcg[2] / 100;
  
  	const l = g * (1.0 - c) + 0.5 * c;
  	let s = 0;
  
  	if (l > 0.0 && l < 0.5) {
  		s = c / (2 * l);
  	} else
  	if (l >= 0.5 && l < 1.0) {
  		s = c / (2 * (1 - l));
  	}
  
  	return [hcg[0], s * 100, l * 100];
  };
  
  convert.hcg.hwb = function (hcg) {
  	const c = hcg[1] / 100;
  	const g = hcg[2] / 100;
  	const v = c + g * (1.0 - c);
  	return [hcg[0], (v - c) * 100, (1 - v) * 100];
  };
  
  convert.hwb.hcg = function (hwb) {
  	const w = hwb[1] / 100;
  	const b = hwb[2] / 100;
  	const v = 1 - b;
  	const c = v - w;
  	let g = 0;
  
  	if (c < 1) {
  		g = (v - c) / (1 - c);
  	}
  
  	return [hwb[0], c * 100, g * 100];
  };
  
  convert.apple.rgb = function (apple) {
  	return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];
  };
  
  convert.rgb.apple = function (rgb) {
  	return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];
  };
  
  convert.gray.rgb = function (args) {
  	return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
  };
  
  convert.gray.hsl = function (args) {
  	return [0, 0, args[0]];
  };
  
  convert.gray.hsv = convert.gray.hsl;
  
  convert.gray.hwb = function (gray) {
  	return [0, 100, gray[0]];
  };
  
  convert.gray.cmyk = function (gray) {
  	return [0, 0, 0, gray[0]];
  };
  
  convert.gray.lab = function (gray) {
  	return [gray[0], 0, 0];
  };
  
  convert.gray.hex = function (gray) {
  	const val = Math.round(gray[0] / 100 * 255) & 0xFF;
  	const integer = (val << 16) + (val << 8) + val;
  
  	const string = integer.toString(16).toUpperCase();
  	return '000000'.substring(string.length) + string;
  };
  
  convert.rgb.gray = function (rgb) {
  	const val = (rgb[0] + rgb[1] + rgb[2]) / 3;
  	return [val / 255 * 100];
  };
  
  
  /***/ }),
  
  /***/ 67:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  // ESM COMPAT FLAG
  __webpack_require__.r(__webpack_exports__);
  
  // EXPORTS
  __webpack_require__.d(__webpack_exports__, "LIB", function() { return /* reexport */ LIB; });
  __webpack_require__.d(__webpack_exports__, "HEADER_IMPERSONATE", function() { return /* reexport */ HEADER_IMPERSONATE; });
  __webpack_require__.d(__webpack_exports__, "Endpoint", function() { return /* reexport */ Endpoint; });
  __webpack_require__.d(__webpack_exports__, "SERVER_RESPONSE_VERSION", function() { return /* reexport */ SERVER_RESPONSE_VERSION; });
  __webpack_require__.d(__webpack_exports__, "ReleaseChannel", function() { return /* reexport */ ReleaseChannel; });
  __webpack_require__.d(__webpack_exports__, "get_allowed_origin", function() { return /* reexport */ get_allowed_origin; });
  __webpack_require__.d(__webpack_exports__, "get_api_base_url", function() { return /* reexport */ get_api_base_url; });
  __webpack_require__.d(__webpack_exports__, "create_server_response_body__blank", function() { return /* reexport */ create_server_response_body__blank; });
  __webpack_require__.d(__webpack_exports__, "create_server_response_body__error", function() { return /* reexport */ create_server_response_body__error; });
  __webpack_require__.d(__webpack_exports__, "create_server_response_body__data", function() { return /* reexport */ create_server_response_body__data; });
  __webpack_require__.d(__webpack_exports__, "is_server_response_body", function() { return /* reexport */ is_server_response_body; });
  
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/node_modules/typescript-string-enums/dist/index.js
  var dist = __webpack_require__(12);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/B-apps--support/online-adventur.es/api-interface/dist/src.es2019/consts.js
   /////////////////////////////////////////////////
  
  const LIB = '@online-adventur.es/api-interface'; /////////////////////////////////////////////////
  
  const HEADER_IMPERSONATE = "X-OFFIRMO-IMPERSONATE".toLowerCase(); // tslint:disable-next-line: variable-name
  
  const Endpoint = Object(dist["Enum"])('whoami', 'report-error', 'key-value', // dev
  'echo', 'hello-world', 'hello-world-advanced', 'test-error-handling', 'temp');
  const SERVER_RESPONSE_VERSION = 1;
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/B-apps--support/online-adventur.es/api-interface/dist/src.es2019/types.js
   // tslint:disable-next-line: variable-name
  
  const ReleaseChannel = Object(dist["Enum"])('prod', 'staging', 'dev');
  // EXTERNAL MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/3-advanced--multi/universal-debug-api-placeholder/dist/src.es2019/index.js + 2 modules
  var src_es2019 = __webpack_require__(45);
  
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/B-apps--support/online-adventur.es/api-interface/dist/src.es2019/utils.js
  
   /////////////////////////////////////////////////
  
  function get_allowed_origin(channel) {
    switch (channel) {
      case 'dev':
        return 'http://localhost:8080';
  
      case 'staging':
        return 'https://offirmo-monorepo.netlify.app';
  
      case 'prod':
        return 'https://www.online-adventur.es';
  
      default:
        throw new Error(`[${LIB}] no allowed origin for channel "${channel}"!`);
    }
  }
  
  function _get_api_base_url(channel) {
    switch (channel) {
      case 'dev':
        return 'http://localhost:9000';
  
      case 'staging':
        return 'https://offirmo-monorepo.netlify.app/.netlify/functions';
  
      case 'prod':
        return 'https://www.online-adventur.es/.netlify/functions';
  
      default:
        if (channel === 'unknown') return 'https://test.test';
        throw new Error(`[${LIB}] no base URL for channel "${channel}"!`);
    }
  }
  
  function get_api_base_url(channel) {
    return Object(src_es2019["b" /* overrideHook */])('api-base-url', _get_api_base_url(channel));
  }
  function create_server_response_body__blank() {
    return {
      v: SERVER_RESPONSE_VERSION,
      data: undefined,
      error: undefined,
      side: {},
      meta: {}
    };
  }
  function create_server_response_body__error(error) {
    var _a, _b;
  
    const body = create_server_response_body__blank();
    body.error = {
      message: error.message,
      code: error.code,
      logical_stack: (_b = (_a = error._temp) === null || _a === void 0 ? void 0 : _a.SEC) === null || _b === void 0 ? void 0 : _b.getLogicalStack()
    };
    return body;
  }
  function create_server_response_body__data(data) {
    const body = create_server_response_body__blank();
    body.data = data;
    return body;
  }
  function is_server_response_body(body) {
    return body && body.v && body.side && body.meta && (body.data || body.error);
  }
  // CONCATENATED MODULE: /Users/offirmo/work/src/off/offirmo-monorepo/B-apps--support/online-adventur.es/api-interface/dist/src.es2019/index.js
  
  
  
  
  /***/ }),
  
  /***/ 72:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  const os = __webpack_require__(32);
  const tty = __webpack_require__(73);
  const hasFlag = __webpack_require__(101);
  
  const {env} = process;
  
  let forceColor;
  if (hasFlag('no-color') ||
  	hasFlag('no-colors') ||
  	hasFlag('color=false') ||
  	hasFlag('color=never')) {
  	forceColor = 0;
  } else if (hasFlag('color') ||
  	hasFlag('colors') ||
  	hasFlag('color=true') ||
  	hasFlag('color=always')) {
  	forceColor = 1;
  }
  
  if ('FORCE_COLOR' in env) {
  	if (env.FORCE_COLOR === 'true') {
  		forceColor = 1;
  	} else if (env.FORCE_COLOR === 'false') {
  		forceColor = 0;
  	} else {
  		forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
  	}
  }
  
  function translateLevel(level) {
  	if (level === 0) {
  		return false;
  	}
  
  	return {
  		level,
  		hasBasic: true,
  		has256: level >= 2,
  		has16m: level >= 3
  	};
  }
  
  function supportsColor(haveStream, streamIsTTY) {
  	if (forceColor === 0) {
  		return 0;
  	}
  
  	if (hasFlag('color=16m') ||
  		hasFlag('color=full') ||
  		hasFlag('color=truecolor')) {
  		return 3;
  	}
  
  	if (hasFlag('color=256')) {
  		return 2;
  	}
  
  	if (haveStream && !streamIsTTY && forceColor === undefined) {
  		return 0;
  	}
  
  	const min = forceColor || 0;
  
  	if (env.TERM === 'dumb') {
  		return min;
  	}
  
  	if (process.platform === 'win32') {
  		// Windows 10 build 10586 is the first Windows release that supports 256 colors.
  		// Windows 10 build 14931 is the first release that supports 16m/TrueColor.
  		const osRelease = os.release().split('.');
  		if (
  			Number(osRelease[0]) >= 10 &&
  			Number(osRelease[2]) >= 10586
  		) {
  			return Number(osRelease[2]) >= 14931 ? 3 : 2;
  		}
  
  		return 1;
  	}
  
  	if ('CI' in env) {
  		if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
  			return 1;
  		}
  
  		return min;
  	}
  
  	if ('TEAMCITY_VERSION' in env) {
  		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
  	}
  
  	if (env.COLORTERM === 'truecolor') {
  		return 3;
  	}
  
  	if ('TERM_PROGRAM' in env) {
  		const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
  
  		switch (env.TERM_PROGRAM) {
  			case 'iTerm.app':
  				return version >= 3 ? 3 : 2;
  			case 'Apple_Terminal':
  				return 2;
  			// No default
  		}
  	}
  
  	if (/-256(color)?$/i.test(env.TERM)) {
  		return 2;
  	}
  
  	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
  		return 1;
  	}
  
  	if ('COLORTERM' in env) {
  		return 1;
  	}
  
  	return min;
  }
  
  function getSupportLevel(stream) {
  	const level = supportsColor(stream, stream && stream.isTTY);
  	return translateLevel(level);
  }
  
  module.exports = {
  	supportsColor: getSupportLevel,
  	stdout: translateLevel(supportsColor(true, tty.isatty(1))),
  	stderr: translateLevel(supportsColor(true, tty.isatty(2)))
  };
  
  
  /***/ }),
  
  /***/ 73:
  /***/ (function(module, exports) {
  
  module.exports = require("tty");
  
  /***/ }),
  
  /***/ 74:
  /***/ (function(module, exports) {
  
  module.exports = function(originalModule) {
  	if (!originalModule.webpackPolyfill) {
  		var module = Object.create(originalModule);
  		// module.parent = undefined by default
  		if (!module.children) module.children = [];
  		Object.defineProperty(module, "loaded", {
  			enumerable: true,
  			get: function() {
  				return module.l;
  			}
  		});
  		Object.defineProperty(module, "id", {
  			enumerable: true,
  			get: function() {
  				return module.i;
  			}
  		});
  		Object.defineProperty(module, "exports", {
  			enumerable: true
  		});
  		module.webpackPolyfill = 1;
  	}
  	return module;
  };
  
  
  /***/ }),
  
  /***/ 75:
  /***/ (function(module, exports) {
  
  module.exports = require("assert");
  
  /***/ }),
  
  /***/ 8:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return logger; });
  /* harmony import */ var _misc__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(11);
  /* eslint-disable @typescript-eslint/no-explicit-any */
  
  // TODO: Implement different loggers for different environments
  var global = Object(_misc__WEBPACK_IMPORTED_MODULE_0__[/* getGlobalObject */ "f"])();
  /** Prefix for logging strings */
  var PREFIX = 'Sentry Logger ';
  /** JSDoc */
  var Logger = /** @class */ (function () {
      /** JSDoc */
      function Logger() {
          this._enabled = false;
      }
      /** JSDoc */
      Logger.prototype.disable = function () {
          this._enabled = false;
      };
      /** JSDoc */
      Logger.prototype.enable = function () {
          this._enabled = true;
      };
      /** JSDoc */
      Logger.prototype.log = function () {
          var args = [];
          for (var _i = 0; _i < arguments.length; _i++) {
              args[_i] = arguments[_i];
          }
          if (!this._enabled) {
              return;
          }
          Object(_misc__WEBPACK_IMPORTED_MODULE_0__[/* consoleSandbox */ "d"])(function () {
              global.console.log(PREFIX + "[Log]: " + args.join(' '));
          });
      };
      /** JSDoc */
      Logger.prototype.warn = function () {
          var args = [];
          for (var _i = 0; _i < arguments.length; _i++) {
              args[_i] = arguments[_i];
          }
          if (!this._enabled) {
              return;
          }
          Object(_misc__WEBPACK_IMPORTED_MODULE_0__[/* consoleSandbox */ "d"])(function () {
              global.console.warn(PREFIX + "[Warn]: " + args.join(' '));
          });
      };
      /** JSDoc */
      Logger.prototype.error = function () {
          var args = [];
          for (var _i = 0; _i < arguments.length; _i++) {
              args[_i] = arguments[_i];
          }
          if (!this._enabled) {
              return;
          }
          Object(_misc__WEBPACK_IMPORTED_MODULE_0__[/* consoleSandbox */ "d"])(function () {
              global.console.error(PREFIX + "[Error]: " + args.join(' '));
          });
      };
      return Logger;
  }());
  // Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used
  global.__SENTRY__ = global.__SENTRY__ || {};
  var logger = global.__SENTRY__.logger || (global.__SENTRY__.logger = new Logger());
  
  //# sourceMappingURL=logger.js.map
  
  /***/ }),
  
  /***/ 81:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return htmlTreeAsString; });
  /* harmony import */ var _is__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9);
  
  /**
   * Given a child DOM element, returns a query-selector statement describing that
   * and its ancestors
   * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]
   * @returns generated DOM path
   */
  function htmlTreeAsString(elem, keyAttrs) {
      // try/catch both:
      // - accessing event.target (see getsentry/raven-js#838, #768)
      // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly
      // - can throw an exception in some circumstances.
      try {
          var currentElem = elem;
          var MAX_TRAVERSE_HEIGHT = 5;
          var MAX_OUTPUT_LEN = 80;
          var out = [];
          var height = 0;
          var len = 0;
          var separator = ' > ';
          var sepLength = separator.length;
          var nextStr = void 0;
          // eslint-disable-next-line no-plusplus
          while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {
              nextStr = _htmlElementAsString(currentElem, keyAttrs);
              // bail out if
              // - nextStr is the 'html' element
              // - the length of the string that would be created exceeds MAX_OUTPUT_LEN
              //   (ignore this limit if we are on the first iteration)
              if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= MAX_OUTPUT_LEN)) {
                  break;
              }
              out.push(nextStr);
              len += nextStr.length;
              currentElem = currentElem.parentNode;
          }
          return out.reverse().join(separator);
      }
      catch (_oO) {
          return '<unknown>';
      }
  }
  /**
   * Returns a simple, query-selector representation of a DOM element
   * e.g. [HTMLElement] => input#foo.btn[name=baz]
   * @returns generated DOM path
   */
  function _htmlElementAsString(el, keyAttrs) {
      var _a, _b;
      var elem = el;
      var out = [];
      var className;
      var classes;
      var key;
      var attr;
      var i;
      if (!elem || !elem.tagName) {
          return '';
      }
      out.push(elem.tagName.toLowerCase());
      // Pairs of attribute keys defined in `serializeAttribute` and their values on element.
      var keyAttrPairs = ((_a = keyAttrs) === null || _a === void 0 ? void 0 : _a.length) ? keyAttrs.filter(function (keyAttr) { return elem.getAttribute(keyAttr); }).map(function (keyAttr) { return [keyAttr, elem.getAttribute(keyAttr)]; })
          : null;
      if ((_b = keyAttrPairs) === null || _b === void 0 ? void 0 : _b.length) {
          keyAttrPairs.forEach(function (keyAttrPair) {
              out.push("[" + keyAttrPair[0] + "=\"" + keyAttrPair[1] + "\"]");
          });
      }
      else {
          if (elem.id) {
              out.push("#" + elem.id);
          }
          // eslint-disable-next-line prefer-const
          className = elem.className;
          if (className && Object(_is__WEBPACK_IMPORTED_MODULE_0__[/* isString */ "h"])(className)) {
              classes = className.split(/\s+/);
              for (i = 0; i < classes.length; i++) {
                  out.push("." + classes[i]);
              }
          }
      }
      var allowedAttrs = ['type', 'name', 'title', 'alt'];
      for (i = 0; i < allowedAttrs.length; i++) {
          key = allowedAttrs[i];
          attr = elem.getAttribute(key);
          if (attr) {
              out.push("[" + key + "=\"" + attr + "\"]");
          }
      }
      return out.join('');
  }
  //# sourceMappingURL=browser.js.map
  
  /***/ }),
  
  /***/ 9:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return isError; });
  /* unused harmony export isErrorEvent */
  /* unused harmony export isDOMError */
  /* unused harmony export isDOMException */
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "h", function() { return isString; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return isPrimitive; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return isPlainObject; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return isEvent; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return isElement; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return isRegExp; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "j", function() { return isThenable; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "i", function() { return isSyntheticEvent; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return isInstanceOf; });
  /* eslint-disable @typescript-eslint/no-explicit-any */
  /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
  /**
   * 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 (Object.prototype.toString.call(wat)) {
          case '[object Error]':
              return true;
          case '[object Exception]':
              return true;
          case '[object DOMException]':
              return true;
          default:
              return isInstanceOf(wat, Error);
      }
  }
  /**
   * 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 Object.prototype.toString.call(wat) === '[object 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 Object.prototype.toString.call(wat) === '[object 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 Object.prototype.toString.call(wat) === '[object 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 Object.prototype.toString.call(wat) === '[object String]';
  }
  /**
   * Checks whether given value's 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 || (typeof wat !== 'object' && typeof wat !== 'function');
  }
  /**
   * Checks whether given value's type is an object literal
   * {@link isPlainObject}.
   *
   * @param wat A value to be checked.
   * @returns A boolean representing the result.
   */
  function isPlainObject(wat) {
      return Object.prototype.toString.call(wat) === '[object 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);
  }
  /**
   * 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);
  }
  /**
   * 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 Object.prototype.toString.call(wat) === '[object 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 && 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;
  }
  /**
   * 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.
   */
  function isInstanceOf(wat, base) {
      try {
          return wat instanceof base;
      }
      catch (_e) {
          return false;
      }
  }
  //# sourceMappingURL=is.js.map
  
  /***/ }),
  
  /***/ 97:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(module) {
  
  const wrapAnsi16 = (fn, offset) => (...args) => {
  	const code = fn(...args);
  	return `\u001B[${code + offset}m`;
  };
  
  const wrapAnsi256 = (fn, offset) => (...args) => {
  	const code = fn(...args);
  	return `\u001B[${38 + offset};5;${code}m`;
  };
  
  const wrapAnsi16m = (fn, offset) => (...args) => {
  	const rgb = fn(...args);
  	return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
  };
  
  const ansi2ansi = n => n;
  const rgb2rgb = (r, g, b) => [r, g, b];
  
  const setLazyProperty = (object, property, get) => {
  	Object.defineProperty(object, property, {
  		get: () => {
  			const value = get();
  
  			Object.defineProperty(object, property, {
  				value,
  				enumerable: true,
  				configurable: true
  			});
  
  			return value;
  		},
  		enumerable: true,
  		configurable: true
  	});
  };
  
  /** @type {typeof import('color-convert')} */
  let colorConvert;
  const makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
  	if (colorConvert === undefined) {
  		colorConvert = __webpack_require__(98);
  	}
  
  	const offset = isBackground ? 10 : 0;
  	const styles = {};
  
  	for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
  		const name = sourceSpace === 'ansi16' ? 'ansi' : sourceSpace;
  		if (sourceSpace === targetSpace) {
  			styles[name] = wrap(identity, offset);
  		} else if (typeof suite === 'object') {
  			styles[name] = wrap(suite[targetSpace], offset);
  		}
  	}
  
  	return styles;
  };
  
  function assembleStyles() {
  	const codes = new Map();
  	const styles = {
  		modifier: {
  			reset: [0, 0],
  			// 21 isn't widely supported and 22 does the same thing
  			bold: [1, 22],
  			dim: [2, 22],
  			italic: [3, 23],
  			underline: [4, 24],
  			inverse: [7, 27],
  			hidden: [8, 28],
  			strikethrough: [9, 29]
  		},
  		color: {
  			black: [30, 39],
  			red: [31, 39],
  			green: [32, 39],
  			yellow: [33, 39],
  			blue: [34, 39],
  			magenta: [35, 39],
  			cyan: [36, 39],
  			white: [37, 39],
  
  			// Bright color
  			blackBright: [90, 39],
  			redBright: [91, 39],
  			greenBright: [92, 39],
  			yellowBright: [93, 39],
  			blueBright: [94, 39],
  			magentaBright: [95, 39],
  			cyanBright: [96, 39],
  			whiteBright: [97, 39]
  		},
  		bgColor: {
  			bgBlack: [40, 49],
  			bgRed: [41, 49],
  			bgGreen: [42, 49],
  			bgYellow: [43, 49],
  			bgBlue: [44, 49],
  			bgMagenta: [45, 49],
  			bgCyan: [46, 49],
  			bgWhite: [47, 49],
  
  			// Bright color
  			bgBlackBright: [100, 49],
  			bgRedBright: [101, 49],
  			bgGreenBright: [102, 49],
  			bgYellowBright: [103, 49],
  			bgBlueBright: [104, 49],
  			bgMagentaBright: [105, 49],
  			bgCyanBright: [106, 49],
  			bgWhiteBright: [107, 49]
  		}
  	};
  
  	// Alias bright black as gray (and grey)
  	styles.color.gray = styles.color.blackBright;
  	styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
  	styles.color.grey = styles.color.blackBright;
  	styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
  
  	for (const [groupName, group] of Object.entries(styles)) {
  		for (const [styleName, style] of Object.entries(group)) {
  			styles[styleName] = {
  				open: `\u001B[${style[0]}m`,
  				close: `\u001B[${style[1]}m`
  			};
  
  			group[styleName] = styles[styleName];
  
  			codes.set(style[0], style[1]);
  		}
  
  		Object.defineProperty(styles, groupName, {
  			value: group,
  			enumerable: false
  		});
  	}
  
  	Object.defineProperty(styles, 'codes', {
  		value: codes,
  		enumerable: false
  	});
  
  	styles.color.close = '\u001B[39m';
  	styles.bgColor.close = '\u001B[49m';
  
  	setLazyProperty(styles.color, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, false));
  	setLazyProperty(styles.color, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, false));
  	setLazyProperty(styles.color, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, false));
  	setLazyProperty(styles.bgColor, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, true));
  	setLazyProperty(styles.bgColor, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, true));
  	setLazyProperty(styles.bgColor, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, true));
  
  	return styles;
  }
  
  // Make the export immutable
  Object.defineProperty(module, 'exports', {
  	enumerable: true,
  	get: assembleStyles
  });
  
  /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(53)(module)))
  
  /***/ }),
  
  /***/ 98:
  /***/ (function(module, exports, __webpack_require__) {
  
  const conversions = __webpack_require__(61);
  const route = __webpack_require__(100);
  
  const convert = {};
  
  const models = Object.keys(conversions);
  
  function wrapRaw(fn) {
  	const wrappedFn = function (...args) {
  		const arg0 = args[0];
  		if (arg0 === undefined || arg0 === null) {
  			return arg0;
  		}
  
  		if (arg0.length > 1) {
  			args = arg0;
  		}
  
  		return fn(args);
  	};
  
  	// Preserve .conversion property if there is one
  	if ('conversion' in fn) {
  		wrappedFn.conversion = fn.conversion;
  	}
  
  	return wrappedFn;
  }
  
  function wrapRounded(fn) {
  	const wrappedFn = function (...args) {
  		const arg0 = args[0];
  
  		if (arg0 === undefined || arg0 === null) {
  			return arg0;
  		}
  
  		if (arg0.length > 1) {
  			args = arg0;
  		}
  
  		const result = fn(args);
  
  		// We're assuming the result is an array here.
  		// see notice in conversions.js; don't use box types
  		// in conversion functions.
  		if (typeof result === 'object') {
  			for (let len = result.length, i = 0; i < len; i++) {
  				result[i] = Math.round(result[i]);
  			}
  		}
  
  		return result;
  	};
  
  	// Preserve .conversion property if there is one
  	if ('conversion' in fn) {
  		wrappedFn.conversion = fn.conversion;
  	}
  
  	return wrappedFn;
  }
  
  models.forEach(fromModel => {
  	convert[fromModel] = {};
  
  	Object.defineProperty(convert[fromModel], 'channels', {value: conversions[fromModel].channels});
  	Object.defineProperty(convert[fromModel], 'labels', {value: conversions[fromModel].labels});
  
  	const routes = route(fromModel);
  	const routeModels = Object.keys(routes);
  
  	routeModels.forEach(toModel => {
  		const fn = routes[toModel];
  
  		convert[fromModel][toModel] = wrapRounded(fn);
  		convert[fromModel][toModel].raw = wrapRaw(fn);
  	});
  });
  
  module.exports = convert;
  
  
  /***/ }),
  
  /***/ 99:
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  module.exports = {
  	"aliceblue": [240, 248, 255],
  	"antiquewhite": [250, 235, 215],
  	"aqua": [0, 255, 255],
  	"aquamarine": [127, 255, 212],
  	"azure": [240, 255, 255],
  	"beige": [245, 245, 220],
  	"bisque": [255, 228, 196],
  	"black": [0, 0, 0],
  	"blanchedalmond": [255, 235, 205],
  	"blue": [0, 0, 255],
  	"blueviolet": [138, 43, 226],
  	"brown": [165, 42, 42],
  	"burlywood": [222, 184, 135],
  	"cadetblue": [95, 158, 160],
  	"chartreuse": [127, 255, 0],
  	"chocolate": [210, 105, 30],
  	"coral": [255, 127, 80],
  	"cornflowerblue": [100, 149, 237],
  	"cornsilk": [255, 248, 220],
  	"crimson": [220, 20, 60],
  	"cyan": [0, 255, 255],
  	"darkblue": [0, 0, 139],
  	"darkcyan": [0, 139, 139],
  	"darkgoldenrod": [184, 134, 11],
  	"darkgray": [169, 169, 169],
  	"darkgreen": [0, 100, 0],
  	"darkgrey": [169, 169, 169],
  	"darkkhaki": [189, 183, 107],
  	"darkmagenta": [139, 0, 139],
  	"darkolivegreen": [85, 107, 47],
  	"darkorange": [255, 140, 0],
  	"darkorchid": [153, 50, 204],
  	"darkred": [139, 0, 0],
  	"darksalmon": [233, 150, 122],
  	"darkseagreen": [143, 188, 143],
  	"darkslateblue": [72, 61, 139],
  	"darkslategray": [47, 79, 79],
  	"darkslategrey": [47, 79, 79],
  	"darkturquoise": [0, 206, 209],
  	"darkviolet": [148, 0, 211],
  	"deeppink": [255, 20, 147],
  	"deepskyblue": [0, 191, 255],
  	"dimgray": [105, 105, 105],
  	"dimgrey": [105, 105, 105],
  	"dodgerblue": [30, 144, 255],
  	"firebrick": [178, 34, 34],
  	"floralwhite": [255, 250, 240],
  	"forestgreen": [34, 139, 34],
  	"fuchsia": [255, 0, 255],
  	"gainsboro": [220, 220, 220],
  	"ghostwhite": [248, 248, 255],
  	"gold": [255, 215, 0],
  	"goldenrod": [218, 165, 32],
  	"gray": [128, 128, 128],
  	"green": [0, 128, 0],
  	"greenyellow": [173, 255, 47],
  	"grey": [128, 128, 128],
  	"honeydew": [240, 255, 240],
  	"hotpink": [255, 105, 180],
  	"indianred": [205, 92, 92],
  	"indigo": [75, 0, 130],
  	"ivory": [255, 255, 240],
  	"khaki": [240, 230, 140],
  	"lavender": [230, 230, 250],
  	"lavenderblush": [255, 240, 245],
  	"lawngreen": [124, 252, 0],
  	"lemonchiffon": [255, 250, 205],
  	"lightblue": [173, 216, 230],
  	"lightcoral": [240, 128, 128],
  	"lightcyan": [224, 255, 255],
  	"lightgoldenrodyellow": [250, 250, 210],
  	"lightgray": [211, 211, 211],
  	"lightgreen": [144, 238, 144],
  	"lightgrey": [211, 211, 211],
  	"lightpink": [255, 182, 193],
  	"lightsalmon": [255, 160, 122],
  	"lightseagreen": [32, 178, 170],
  	"lightskyblue": [135, 206, 250],
  	"lightslategray": [119, 136, 153],
  	"lightslategrey": [119, 136, 153],
  	"lightsteelblue": [176, 196, 222],
  	"lightyellow": [255, 255, 224],
  	"lime": [0, 255, 0],
  	"limegreen": [50, 205, 50],
  	"linen": [250, 240, 230],
  	"magenta": [255, 0, 255],
  	"maroon": [128, 0, 0],
  	"mediumaquamarine": [102, 205, 170],
  	"mediumblue": [0, 0, 205],
  	"mediumorchid": [186, 85, 211],
  	"mediumpurple": [147, 112, 219],
  	"mediumseagreen": [60, 179, 113],
  	"mediumslateblue": [123, 104, 238],
  	"mediumspringgreen": [0, 250, 154],
  	"mediumturquoise": [72, 209, 204],
  	"mediumvioletred": [199, 21, 133],
  	"midnightblue": [25, 25, 112],
  	"mintcream": [245, 255, 250],
  	"mistyrose": [255, 228, 225],
  	"moccasin": [255, 228, 181],
  	"navajowhite": [255, 222, 173],
  	"navy": [0, 0, 128],
  	"oldlace": [253, 245, 230],
  	"olive": [128, 128, 0],
  	"olivedrab": [107, 142, 35],
  	"orange": [255, 165, 0],
  	"orangered": [255, 69, 0],
  	"orchid": [218, 112, 214],
  	"palegoldenrod": [238, 232, 170],
  	"palegreen": [152, 251, 152],
  	"paleturquoise": [175, 238, 238],
  	"palevioletred": [219, 112, 147],
  	"papayawhip": [255, 239, 213],
  	"peachpuff": [255, 218, 185],
  	"peru": [205, 133, 63],
  	"pink": [255, 192, 203],
  	"plum": [221, 160, 221],
  	"powderblue": [176, 224, 230],
  	"purple": [128, 0, 128],
  	"rebeccapurple": [102, 51, 153],
  	"red": [255, 0, 0],
  	"rosybrown": [188, 143, 143],
  	"royalblue": [65, 105, 225],
  	"saddlebrown": [139, 69, 19],
  	"salmon": [250, 128, 114],
  	"sandybrown": [244, 164, 96],
  	"seagreen": [46, 139, 87],
  	"seashell": [255, 245, 238],
  	"sienna": [160, 82, 45],
  	"silver": [192, 192, 192],
  	"skyblue": [135, 206, 235],
  	"slateblue": [106, 90, 205],
  	"slategray": [112, 128, 144],
  	"slategrey": [112, 128, 144],
  	"snow": [255, 250, 250],
  	"springgreen": [0, 255, 127],
  	"steelblue": [70, 130, 180],
  	"tan": [210, 180, 140],
  	"teal": [0, 128, 128],
  	"thistle": [216, 191, 216],
  	"tomato": [255, 99, 71],
  	"turquoise": [64, 224, 208],
  	"violet": [238, 130, 238],
  	"wheat": [245, 222, 179],
  	"white": [255, 255, 255],
  	"whitesmoke": [245, 245, 245],
  	"yellow": [255, 255, 0],
  	"yellowgreen": [154, 205, 50]
  };
  
  
  /***/ })
  
  /******/ })));