@juo/blocks 1.4.1 → 1.4.2

package/dist/observability.js

@@ -0,0 +1,1381 @@
+const objectToString = Object.prototype.toString;
+function isBuiltin(wat, className) {
+  return objectToString.call(wat) === `[object ${className}]`;
+}
+function isPlainObject(wat) {
+  return isBuiltin(wat, "Object");
+}
+function isThenable(wat) {
+  return Boolean(wat && wat.then && typeof wat.then === "function");
+}
+function isGlobalObj(obj) {
+  return obj && obj.Math == Math ? obj : void 0;
+}
+const GLOBAL_OBJ = typeof globalThis == "object" && isGlobalObj(globalThis) || // eslint-disable-next-line no-restricted-globals
+typeof window == "object" && isGlobalObj(window) || typeof self == "object" && isGlobalObj(self) || typeof global == "object" && isGlobalObj(global) || /* @__PURE__ */ function() {
+  return this;
+}() || {};
+function getGlobalObject() {
+  return GLOBAL_OBJ;
+}
+function getGlobalSingleton(name, creator, obj) {
+  const gbl = obj || GLOBAL_OBJ;
+  const __SENTRY__ = gbl.__SENTRY__ = gbl.__SENTRY__ || {};
+  const singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());
+  return singleton;
+}
+const PREFIX = "Sentry Logger ";
+const CONSOLE_LEVELS = ["debug", "info", "warn", "error", "log", "assert", "trace"];
+const originalConsoleMethods = {};
+function consoleSandbox(callback) {
+  if (!("console" in GLOBAL_OBJ)) {
+    return callback();
+  }
+  const console2 = GLOBAL_OBJ.console;
+  const wrappedFuncs = {};
+  const wrappedLevels = Object.keys(originalConsoleMethods);
+  wrappedLevels.forEach((level) => {
+    const originalConsoleMethod = originalConsoleMethods[level];
+    wrappedFuncs[level] = console2[level];
+    console2[level] = originalConsoleMethod;
+  });
+  try {
+    return callback();
+  } finally {
+    wrappedLevels.forEach((level) => {
+      console2[level] = wrappedFuncs[level];
+    });
+  }
+}
+function makeLogger() {
+  let enabled = false;
+  const logger2 = {
+    enable: () => {
+      enabled = true;
+    },
+    disable: () => {
+      enabled = false;
+    },
+    isEnabled: () => enabled
+  };
+  if (typeof __SENTRY_DEBUG__ === "undefined" || __SENTRY_DEBUG__) {
+    CONSOLE_LEVELS.forEach((name) => {
+      logger2[name] = (...args) => {
+        if (enabled) {
+          consoleSandbox(() => {
+            GLOBAL_OBJ.console[name](`${PREFIX}[${name}]:`, ...args);
+          });
+        }
+      };
+    });
+  } else {
+    CONSOLE_LEVELS.forEach((name) => {
+      logger2[name] = () => void 0;
+    });
+  }
+  return logger2;
+}
+const logger = makeLogger();
+function dropUndefinedKeys(inputValue) {
+  const memoizationMap = /* @__PURE__ */ new Map();
+  return _dropUndefinedKeys(inputValue, memoizationMap);
+}
+function _dropUndefinedKeys(inputValue, memoizationMap) {
+  if (isPlainObject(inputValue)) {
+    const memoVal = memoizationMap.get(inputValue);
+    if (memoVal !== void 0) {
+      return memoVal;
+    }
+    const returnValue = {};
+    memoizationMap.set(inputValue, returnValue);
+    for (const key of Object.keys(inputValue)) {
+      if (typeof inputValue[key] !== "undefined") {
+        returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap);
+      }
+    }
+    return returnValue;
+  }
+  if (Array.isArray(inputValue)) {
+    const memoVal = memoizationMap.get(inputValue);
+    if (memoVal !== void 0) {
+      return memoVal;
+    }
+    const returnValue = [];
+    memoizationMap.set(inputValue, returnValue);
+    inputValue.forEach((item) => {
+      returnValue.push(_dropUndefinedKeys(item, memoizationMap));
+    });
+    return returnValue;
+  }
+  return inputValue;
+}
+function uuid4() {
+  const gbl = GLOBAL_OBJ;
+  const crypto = gbl.crypto || gbl.msCrypto;
+  let getRandomByte = () => Math.random() * 16;
+  try {
+    if (crypto && crypto.randomUUID) {
+      return crypto.randomUUID().replace(/-/g, "");
+    }
+    if (crypto && crypto.getRandomValues) {
+      getRandomByte = () => crypto.getRandomValues(new Uint8Array(1))[0];
+    }
+  } catch (_) {
+  }
+  return ("10000000100040008000" + 1e11).replace(
+    /[018]/g,
+    (c) => (
+      // eslint-disable-next-line no-bitwise
+      (c ^ (getRandomByte() & 15) >> c / 4).toString(16)
+    )
+  );
+}
+function arrayify(maybeArray) {
+  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];
+}
+function isBrowserBundle() {
+  return typeof __SENTRY_BROWSER_BUNDLE__ !== "undefined" && !!__SENTRY_BROWSER_BUNDLE__;
+}
+function isNodeEnv() {
+  return !isBrowserBundle() && Object.prototype.toString.call(typeof process !== "undefined" ? process : 0) === "[object process]";
+}
+function dynamicRequire(mod, request) {
+  return mod.require(request);
+}
+var States;
+(function(States2) {
+  const PENDING = 0;
+  States2[States2["PENDING"] = PENDING] = "PENDING";
+  const RESOLVED = 1;
+  States2[States2["RESOLVED"] = RESOLVED] = "RESOLVED";
+  const REJECTED = 2;
+  States2[States2["REJECTED"] = REJECTED] = "REJECTED";
+})(States || (States = {}));
+class SyncPromise {
+  constructor(executor) {
+    SyncPromise.prototype.__init.call(this);
+    SyncPromise.prototype.__init2.call(this);
+    SyncPromise.prototype.__init3.call(this);
+    SyncPromise.prototype.__init4.call(this);
+    this._state = States.PENDING;
+    this._handlers = [];
+    try {
+      executor(this._resolve, this._reject);
+    } catch (e) {
+      this._reject(e);
+    }
+  }
+  /** JSDoc */
+  then(onfulfilled, onrejected) {
+    return new SyncPromise((resolve, reject) => {
+      this._handlers.push([
+        false,
+        (result) => {
+          if (!onfulfilled) {
+            resolve(result);
+          } else {
+            try {
+              resolve(onfulfilled(result));
+            } catch (e) {
+              reject(e);
+            }
+          }
+        },
+        (reason) => {
+          if (!onrejected) {
+            reject(reason);
+          } else {
+            try {
+              resolve(onrejected(reason));
+            } catch (e) {
+              reject(e);
+            }
+          }
+        }
+      ]);
+      this._executeHandlers();
+    });
+  }
+  /** JSDoc */
+  catch(onrejected) {
+    return this.then((val) => val, onrejected);
+  }
+  /** JSDoc */
+  finally(onfinally) {
+    return new SyncPromise((resolve, reject) => {
+      let val;
+      let isRejected;
+      return this.then(
+        (value) => {
+          isRejected = false;
+          val = value;
+          if (onfinally) {
+            onfinally();
+          }
+        },
+        (reason) => {
+          isRejected = true;
+          val = reason;
+          if (onfinally) {
+            onfinally();
+          }
+        }
+      ).then(() => {
+        if (isRejected) {
+          reject(val);
+          return;
+        }
+        resolve(val);
+      });
+    });
+  }
+  /** JSDoc */
+  __init() {
+    this._resolve = (value) => {
+      this._setResult(States.RESOLVED, value);
+    };
+  }
+  /** JSDoc */
+  __init2() {
+    this._reject = (reason) => {
+      this._setResult(States.REJECTED, reason);
+    };
+  }
+  /** JSDoc */
+  __init3() {
+    this._setResult = (state, value) => {
+      if (this._state !== States.PENDING) {
+        return;
+      }
+      if (isThenable(value)) {
+        void value.then(this._resolve, this._reject);
+        return;
+      }
+      this._state = state;
+      this._value = value;
+      this._executeHandlers();
+    };
+  }
+  /** JSDoc */
+  __init4() {
+    this._executeHandlers = () => {
+      if (this._state === States.PENDING) {
+        return;
+      }
+      const cachedHandlers = this._handlers.slice();
+      this._handlers = [];
+      cachedHandlers.forEach((handler) => {
+        if (handler[0]) {
+          return;
+        }
+        if (this._state === States.RESOLVED) {
+          handler[1](this._value);
+        }
+        if (this._state === States.REJECTED) {
+          handler[2](this._value);
+        }
+        handler[0] = true;
+      });
+    };
+  }
+}
+const WINDOW = getGlobalObject();
+const dateTimestampSource = {
+  nowSeconds: () => Date.now() / 1e3
+};
+function getBrowserPerformance() {
+  const { performance } = WINDOW;
+  if (!performance || !performance.now) {
+    return void 0;
+  }
+  const timeOrigin = Date.now() - performance.now();
+  return {
+    now: () => performance.now(),
+    timeOrigin
+  };
+}
+function getNodePerformance() {
+  try {
+    const perfHooks = dynamicRequire(module, "perf_hooks");
+    return perfHooks.performance;
+  } catch (_) {
+    return void 0;
+  }
+}
+const platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();
+const timestampSource = platformPerformance === void 0 ? dateTimestampSource : {
+  nowSeconds: () => (platformPerformance.timeOrigin + platformPerformance.now()) / 1e3
+};
+const dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);
+const timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);
+(() => {
+  const { performance } = WINDOW;
+  if (!performance || !performance.now) {
+    return void 0;
+  }
+  const threshold = 3600 * 1e3;
+  const performanceNow = performance.now();
+  const dateNow = Date.now();
+  const timeOriginDelta = performance.timeOrigin ? Math.abs(performance.timeOrigin + performanceNow - dateNow) : threshold;
+  const timeOriginIsReliable = timeOriginDelta < threshold;
+  const navigationStart = performance.timing && performance.timing.navigationStart;
+  const hasNavigationStart = typeof navigationStart === "number";
+  const navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;
+  const navigationStartIsReliable = navigationStartDelta < threshold;
+  if (timeOriginIsReliable || navigationStartIsReliable) {
+    if (timeOriginDelta <= navigationStartDelta) {
+      return performance.timeOrigin;
+    } else {
+      return navigationStart;
+    }
+  }
+  return dateNow;
+})();
+const DEFAULT_ENVIRONMENT = "production";
+function getGlobalEventProcessors() {
+  return getGlobalSingleton("globalEventProcessors", () => []);
+}
+function notifyEventProcessors(processors, event, hint, index = 0) {
+  return new SyncPromise((resolve, reject) => {
+    const processor = processors[index];
+    if (event === null || typeof processor !== "function") {
+      resolve(event);
+    } else {
+      const result = processor({ ...event }, hint);
+      (typeof __SENTRY_DEBUG__ === "undefined" || __SENTRY_DEBUG__) && processor.id && result === null && logger.log(`Event processor "${processor.id}" dropped event`);
+      if (isThenable(result)) {
+        void result.then((final) => notifyEventProcessors(processors, final, hint, index + 1).then(resolve)).then(null, reject);
+      } else {
+        void notifyEventProcessors(processors, result, hint, index + 1).then(resolve).then(null, reject);
+      }
+    }
+  });
+}
+function makeSession(context) {
+  const startingTime = timestampInSeconds();
+  const session = {
+    sid: uuid4(),
+    init: true,
+    timestamp: startingTime,
+    started: startingTime,
+    duration: 0,
+    status: "ok",
+    errors: 0,
+    ignoreDuration: false,
+    toJSON: () => sessionToJSON(session)
+  };
+  if (context) {
+    updateSession(session, context);
+  }
+  return session;
+}
+function updateSession(session, context = {}) {
+  if (context.user) {
+    if (!session.ipAddress && context.user.ip_address) {
+      session.ipAddress = context.user.ip_address;
+    }
+    if (!session.did && !context.did) {
+      session.did = context.user.id || context.user.email || context.user.username;
+    }
+  }
+  session.timestamp = context.timestamp || timestampInSeconds();
+  if (context.abnormal_mechanism) {
+    session.abnormal_mechanism = context.abnormal_mechanism;
+  }
+  if (context.ignoreDuration) {
+    session.ignoreDuration = context.ignoreDuration;
+  }
+  if (context.sid) {
+    session.sid = context.sid.length === 32 ? context.sid : uuid4();
+  }
+  if (context.init !== void 0) {
+    session.init = context.init;
+  }
+  if (!session.did && context.did) {
+    session.did = `${context.did}`;
+  }
+  if (typeof context.started === "number") {
+    session.started = context.started;
+  }
+  if (session.ignoreDuration) {
+    session.duration = void 0;
+  } else if (typeof context.duration === "number") {
+    session.duration = context.duration;
+  } else {
+    const duration = session.timestamp - session.started;
+    session.duration = duration >= 0 ? duration : 0;
+  }
+  if (context.release) {
+    session.release = context.release;
+  }
+  if (context.environment) {
+    session.environment = context.environment;
+  }
+  if (!session.ipAddress && context.ipAddress) {
+    session.ipAddress = context.ipAddress;
+  }
+  if (!session.userAgent && context.userAgent) {
+    session.userAgent = context.userAgent;
+  }
+  if (typeof context.errors === "number") {
+    session.errors = context.errors;
+  }
+  if (context.status) {
+    session.status = context.status;
+  }
+}
+function closeSession(session, status) {
+  let context = {};
+  if (session.status === "ok") {
+    context = { status: "exited" };
+  }
+  updateSession(session, context);
+}
+function sessionToJSON(session) {
+  return dropUndefinedKeys({
+    sid: `${session.sid}`,
+    init: session.init,
+    // Make sure that sec is converted to ms for date constructor
+    started: new Date(session.started * 1e3).toISOString(),
+    timestamp: new Date(session.timestamp * 1e3).toISOString(),
+    status: session.status,
+    errors: session.errors,
+    did: typeof session.did === "number" || typeof session.did === "string" ? `${session.did}` : void 0,
+    duration: session.duration,
+    abnormal_mechanism: session.abnormal_mechanism,
+    attrs: {
+      release: session.release,
+      environment: session.environment,
+      ip_address: session.ipAddress,
+      user_agent: session.userAgent
+    }
+  });
+}
+const DEFAULT_MAX_BREADCRUMBS = 100;
+class Scope {
+  /** Flag if notifying is happening. */
+  /** Callback for client to receive scope changes. */
+  /** Callback list that will be called after {@link applyToEvent}. */
+  /** Array of breadcrumbs. */
+  /** User */
+  /** Tags */
+  /** Extra */
+  /** Contexts */
+  /** Attachments */
+  /** Propagation Context for distributed tracing */
+  /**
+   * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get
+   * sent to Sentry
+   */
+  /** Fingerprint */
+  /** Severity */
+  // eslint-disable-next-line deprecation/deprecation
+  /** Transaction Name */
+  /** Span */
+  /** Session */
+  /** Request Mode Session Status */
+  // NOTE: Any field which gets added here should get added not only to the constructor but also to the `clone` method.
+  constructor() {
+    this._notifyingListeners = false;
+    this._scopeListeners = [];
+    this._eventProcessors = [];
+    this._breadcrumbs = [];
+    this._attachments = [];
+    this._user = {};
+    this._tags = {};
+    this._extra = {};
+    this._contexts = {};
+    this._sdkProcessingMetadata = {};
+    this._propagationContext = generatePropagationContext();
+  }
+  /**
+   * Inherit values from the parent scope.
+   * @param scope to clone.
+   */
+  static clone(scope) {
+    const newScope = new Scope();
+    if (scope) {
+      newScope._breadcrumbs = [...scope._breadcrumbs];
+      newScope._tags = { ...scope._tags };
+      newScope._extra = { ...scope._extra };
+      newScope._contexts = { ...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 = [...scope._eventProcessors];
+      newScope._requestSession = scope._requestSession;
+      newScope._attachments = [...scope._attachments];
+      newScope._sdkProcessingMetadata = { ...scope._sdkProcessingMetadata };
+      newScope._propagationContext = { ...scope._propagationContext };
+    }
+    return newScope;
+  }
+  /**
+   * Add internal on change listener. Used for sub SDKs that need to store the scope.
+   * @hidden
+   */
+  addScopeListener(callback) {
+    this._scopeListeners.push(callback);
+  }
+  /**
+   * @inheritDoc
+   */
+  addEventProcessor(callback) {
+    this._eventProcessors.push(callback);
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setUser(user) {
+    this._user = user || {};
+    if (this._session) {
+      updateSession(this._session, { user });
+    }
+    this._notifyScopeListeners();
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  getUser() {
+    return this._user;
+  }
+  /**
+   * @inheritDoc
+   */
+  getRequestSession() {
+    return this._requestSession;
+  }
+  /**
+   * @inheritDoc
+   */
+  setRequestSession(requestSession) {
+    this._requestSession = requestSession;
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setTags(tags) {
+    this._tags = {
+      ...this._tags,
+      ...tags
+    };
+    this._notifyScopeListeners();
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setTag(key, value) {
+    this._tags = { ...this._tags, [key]: value };
+    this._notifyScopeListeners();
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setExtras(extras) {
+    this._extra = {
+      ...this._extra,
+      ...extras
+    };
+    this._notifyScopeListeners();
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setExtra(key, extra) {
+    this._extra = { ...this._extra, [key]: extra };
+    this._notifyScopeListeners();
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setFingerprint(fingerprint) {
+    this._fingerprint = fingerprint;
+    this._notifyScopeListeners();
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setLevel(level) {
+    this._level = level;
+    this._notifyScopeListeners();
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setTransactionName(name) {
+    this._transactionName = name;
+    this._notifyScopeListeners();
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setContext(key, context) {
+    if (context === null) {
+      delete this._contexts[key];
+    } else {
+      this._contexts[key] = context;
+    }
+    this._notifyScopeListeners();
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setSpan(span) {
+    this._span = span;
+    this._notifyScopeListeners();
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  getSpan() {
+    return this._span;
+  }
+  /**
+   * @inheritDoc
+   */
+  getTransaction() {
+    const span = this.getSpan();
+    return span && span.transaction;
+  }
+  /**
+   * @inheritDoc
+   */
+  setSession(session) {
+    if (!session) {
+      delete this._session;
+    } else {
+      this._session = session;
+    }
+    this._notifyScopeListeners();
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  getSession() {
+    return this._session;
+  }
+  /**
+   * @inheritDoc
+   */
+  update(captureContext) {
+    if (!captureContext) {
+      return this;
+    }
+    if (typeof captureContext === "function") {
+      const updatedScope = captureContext(this);
+      return updatedScope instanceof Scope ? updatedScope : this;
+    }
+    if (captureContext instanceof Scope) {
+      this._tags = { ...this._tags, ...captureContext._tags };
+      this._extra = { ...this._extra, ...captureContext._extra };
+      this._contexts = { ...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;
+      }
+      if (captureContext._propagationContext) {
+        this._propagationContext = captureContext._propagationContext;
+      }
+    } else if (isPlainObject(captureContext)) {
+      captureContext = captureContext;
+      this._tags = { ...this._tags, ...captureContext.tags };
+      this._extra = { ...this._extra, ...captureContext.extra };
+      this._contexts = { ...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;
+      }
+      if (captureContext.propagationContext) {
+        this._propagationContext = captureContext.propagationContext;
+      }
+    }
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  clear() {
+    this._breadcrumbs = [];
+    this._tags = {};
+    this._extra = {};
+    this._user = {};
+    this._contexts = {};
+    this._level = void 0;
+    this._transactionName = void 0;
+    this._fingerprint = void 0;
+    this._requestSession = void 0;
+    this._span = void 0;
+    this._session = void 0;
+    this._notifyScopeListeners();
+    this._attachments = [];
+    this._propagationContext = generatePropagationContext();
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  addBreadcrumb(breadcrumb, maxBreadcrumbs) {
+    const maxCrumbs = typeof maxBreadcrumbs === "number" ? maxBreadcrumbs : DEFAULT_MAX_BREADCRUMBS;
+    if (maxCrumbs <= 0) {
+      return this;
+    }
+    const mergedBreadcrumb = {
+      timestamp: dateTimestampInSeconds(),
+      ...breadcrumb
+    };
+    const breadcrumbs = this._breadcrumbs;
+    breadcrumbs.push(mergedBreadcrumb);
+    this._breadcrumbs = breadcrumbs.length > maxCrumbs ? breadcrumbs.slice(-maxCrumbs) : breadcrumbs;
+    this._notifyScopeListeners();
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  getLastBreadcrumb() {
+    return this._breadcrumbs[this._breadcrumbs.length - 1];
+  }
+  /**
+   * @inheritDoc
+   */
+  clearBreadcrumbs() {
+    this._breadcrumbs = [];
+    this._notifyScopeListeners();
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  addAttachment(attachment) {
+    this._attachments.push(attachment);
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  getAttachments() {
+    return this._attachments;
+  }
+  /**
+   * @inheritDoc
+   */
+  clearAttachments() {
+    this._attachments = [];
+    return this;
+  }
+  /**
+   * Applies data from the scope to the event and runs all event processors on it.
+   *
+   * @param event Event
+   * @param hint Object containing additional information about the original exception, for use by the event processors.
+   * @hidden
+   */
+  applyToEvent(event, hint = {}, additionalEventProcessors) {
+    if (this._extra && Object.keys(this._extra).length) {
+      event.extra = { ...this._extra, ...event.extra };
+    }
+    if (this._tags && Object.keys(this._tags).length) {
+      event.tags = { ...this._tags, ...event.tags };
+    }
+    if (this._user && Object.keys(this._user).length) {
+      event.user = { ...this._user, ...event.user };
+    }
+    if (this._contexts && Object.keys(this._contexts).length) {
+      event.contexts = { ...this._contexts, ...event.contexts };
+    }
+    if (this._level) {
+      event.level = this._level;
+    }
+    if (this._transactionName) {
+      event.transaction = this._transactionName;
+    }
+    if (this._span) {
+      event.contexts = { trace: this._span.getTraceContext(), ...event.contexts };
+      const transaction = this._span.transaction;
+      if (transaction) {
+        event.sdkProcessingMetadata = {
+          dynamicSamplingContext: transaction.getDynamicSamplingContext(),
+          ...event.sdkProcessingMetadata
+        };
+        const transactionName = transaction.name;
+        if (transactionName) {
+          event.tags = { transaction: transactionName, ...event.tags };
+        }
+      }
+    }
+    this._applyFingerprint(event);
+    const scopeBreadcrumbs = this._getBreadcrumbs();
+    const breadcrumbs = [...event.breadcrumbs || [], ...scopeBreadcrumbs];
+    event.breadcrumbs = breadcrumbs.length > 0 ? breadcrumbs : void 0;
+    event.sdkProcessingMetadata = {
+      ...event.sdkProcessingMetadata,
+      ...this._sdkProcessingMetadata,
+      propagationContext: this._propagationContext
+    };
+    return notifyEventProcessors(
+      [...additionalEventProcessors || [], ...getGlobalEventProcessors(), ...this._eventProcessors],
+      event,
+      hint
+    );
+  }
+  /**
+   * Add data which will be accessible during event processing but won't get sent to Sentry
+   */
+  setSDKProcessingMetadata(newData) {
+    this._sdkProcessingMetadata = { ...this._sdkProcessingMetadata, ...newData };
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setPropagationContext(context) {
+    this._propagationContext = context;
+    return this;
+  }
+  /**
+   * @inheritDoc
+   */
+  getPropagationContext() {
+    return this._propagationContext;
+  }
+  /**
+   * Get the breadcrumbs for this scope.
+   */
+  _getBreadcrumbs() {
+    return this._breadcrumbs;
+  }
+  /**
+   * This will be called on every set call.
+   */
+  _notifyScopeListeners() {
+    if (!this._notifyingListeners) {
+      this._notifyingListeners = true;
+      this._scopeListeners.forEach((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
+   */
+  _applyFingerprint(event) {
+    event.fingerprint = event.fingerprint ? arrayify(event.fingerprint) : [];
+    if (this._fingerprint) {
+      event.fingerprint = event.fingerprint.concat(this._fingerprint);
+    }
+    if (event.fingerprint && !event.fingerprint.length) {
+      delete event.fingerprint;
+    }
+  }
+}
+function generatePropagationContext() {
+  return {
+    traceId: uuid4(),
+    spanId: uuid4().substring(16)
+  };
+}
+const API_VERSION = 4;
+const DEFAULT_BREADCRUMBS = 100;
+class Hub {
+  /** Is a {@link Layer}[] containing the client and scope */
+  /** Contains the last event id of a captured event.  */
+  /**
+   * 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.
+   */
+  constructor(client, scope = new Scope(), _version = API_VERSION) {
+    this._version = _version;
+    this._stack = [{ scope }];
+    if (client) {
+      this.bindClient(client);
+    }
+  }
+  /**
+   * @inheritDoc
+   */
+  isOlderThan(version) {
+    return this._version < version;
+  }
+  /**
+   * @inheritDoc
+   */
+  bindClient(client) {
+    const top = this.getStackTop();
+    top.client = client;
+    if (client && client.setupIntegrations) {
+      client.setupIntegrations();
+    }
+  }
+  /**
+   * @inheritDoc
+   */
+  pushScope() {
+    const scope = Scope.clone(this.getScope());
+    this.getStack().push({
+      client: this.getClient(),
+      scope
+    });
+    return scope;
+  }
+  /**
+   * @inheritDoc
+   */
+  popScope() {
+    if (this.getStack().length <= 1) return false;
+    return !!this.getStack().pop();
+  }
+  /**
+   * @inheritDoc
+   */
+  withScope(callback) {
+    const scope = this.pushScope();
+    try {
+      callback(scope);
+    } finally {
+      this.popScope();
+    }
+  }
+  /**
+   * @inheritDoc
+   */
+  getClient() {
+    return this.getStackTop().client;
+  }
+  /** Returns the scope of the top stack. */
+  getScope() {
+    return this.getStackTop().scope;
+  }
+  /** Returns the scope stack for domains or the process. */
+  getStack() {
+    return this._stack;
+  }
+  /** Returns the topmost scope layer in the order domain > local > process. */
+  getStackTop() {
+    return this._stack[this._stack.length - 1];
+  }
+  /**
+   * @inheritDoc
+   */
+  captureException(exception, hint) {
+    const eventId = this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4();
+    const syntheticException = new Error("Sentry syntheticException");
+    this._withClient((client, scope) => {
+      client.captureException(
+        exception,
+        {
+          originalException: exception,
+          syntheticException,
+          ...hint,
+          event_id: eventId
+        },
+        scope
+      );
+    });
+    return eventId;
+  }
+  /**
+   * @inheritDoc
+   */
+  captureMessage(message, level, hint) {
+    const eventId = this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4();
+    const syntheticException = new Error(message);
+    this._withClient((client, scope) => {
+      client.captureMessage(
+        message,
+        level,
+        {
+          originalException: message,
+          syntheticException,
+          ...hint,
+          event_id: eventId
+        },
+        scope
+      );
+    });
+    return eventId;
+  }
+  /**
+   * @inheritDoc
+   */
+  captureEvent(event, hint) {
+    const eventId = hint && hint.event_id ? hint.event_id : uuid4();
+    if (!event.type) {
+      this._lastEventId = eventId;
+    }
+    this._withClient((client, scope) => {
+      client.captureEvent(event, { ...hint, event_id: eventId }, scope);
+    });
+    return eventId;
+  }
+  /**
+   * @inheritDoc
+   */
+  lastEventId() {
+    return this._lastEventId;
+  }
+  /**
+   * @inheritDoc
+   */
+  addBreadcrumb(breadcrumb, hint) {
+    const { scope, client } = this.getStackTop();
+    if (!client) return;
+    const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } = client.getOptions && client.getOptions() || {};
+    if (maxBreadcrumbs <= 0) return;
+    const timestamp = dateTimestampInSeconds();
+    const mergedBreadcrumb = { timestamp, ...breadcrumb };
+    const finalBreadcrumb = beforeBreadcrumb ? consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint)) : mergedBreadcrumb;
+    if (finalBreadcrumb === null) return;
+    if (client.emit) {
+      client.emit("beforeAddBreadcrumb", finalBreadcrumb, hint);
+    }
+    scope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);
+  }
+  /**
+   * @inheritDoc
+   */
+  setUser(user) {
+    this.getScope().setUser(user);
+  }
+  /**
+   * @inheritDoc
+   */
+  setTags(tags) {
+    this.getScope().setTags(tags);
+  }
+  /**
+   * @inheritDoc
+   */
+  setExtras(extras) {
+    this.getScope().setExtras(extras);
+  }
+  /**
+   * @inheritDoc
+   */
+  setTag(key, value) {
+    this.getScope().setTag(key, value);
+  }
+  /**
+   * @inheritDoc
+   */
+  setExtra(key, extra) {
+    this.getScope().setExtra(key, extra);
+  }
+  /**
+   * @inheritDoc
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  setContext(name, context) {
+    this.getScope().setContext(name, context);
+  }
+  /**
+   * @inheritDoc
+   */
+  configureScope(callback) {
+    const { scope, client } = this.getStackTop();
+    if (client) {
+      callback(scope);
+    }
+  }
+  /**
+   * @inheritDoc
+   */
+  run(callback) {
+    const oldHub = makeMain(this);
+    try {
+      callback(this);
+    } finally {
+      makeMain(oldHub);
+    }
+  }
+  /**
+   * @inheritDoc
+   */
+  getIntegration(integration) {
+    const client = this.getClient();
+    if (!client) return null;
+    try {
+      return client.getIntegration(integration);
+    } catch (_oO) {
+      (typeof __SENTRY_DEBUG__ === "undefined" || __SENTRY_DEBUG__) && logger.warn(`Cannot retrieve integration ${integration.id} from the current Hub`);
+      return null;
+    }
+  }
+  /**
+   * @inheritDoc
+   */
+  startTransaction(context, customSamplingContext) {
+    const result = this._callExtensionMethod("startTransaction", context, customSamplingContext);
+    if ((typeof __SENTRY_DEBUG__ === "undefined" || __SENTRY_DEBUG__) && !result) {
+      const client = this.getClient();
+      if (!client) {
+        console.warn(
+          "Tracing extension 'startTransaction' is missing. You should 'init' the SDK before calling 'startTransaction'"
+        );
+      } else {
+        console.warn(`Tracing extension 'startTransaction' has not been added. Call 'addTracingExtensions' before calling 'init':
+Sentry.addTracingExtensions();
+Sentry.init({...});
+`);
+      }
+    }
+    return result;
+  }
+  /**
+   * @inheritDoc
+   */
+  traceHeaders() {
+    return this._callExtensionMethod("traceHeaders");
+  }
+  /**
+   * @inheritDoc
+   */
+  captureSession(endSession = false) {
+    if (endSession) {
+      return this.endSession();
+    }
+    this._sendSessionUpdate();
+  }
+  /**
+   * @inheritDoc
+   */
+  endSession() {
+    const layer = this.getStackTop();
+    const scope = layer.scope;
+    const session = scope.getSession();
+    if (session) {
+      closeSession(session);
+    }
+    this._sendSessionUpdate();
+    scope.setSession();
+  }
+  /**
+   * @inheritDoc
+   */
+  startSession(context) {
+    const { scope, client } = this.getStackTop();
+    const { release, environment = DEFAULT_ENVIRONMENT } = client && client.getOptions() || {};
+    const { userAgent } = GLOBAL_OBJ.navigator || {};
+    const session = makeSession({
+      release,
+      environment,
+      user: scope.getUser(),
+      ...userAgent && { userAgent },
+      ...context
+    });
+    const currentSession = scope.getSession && scope.getSession();
+    if (currentSession && currentSession.status === "ok") {
+      updateSession(currentSession, { status: "exited" });
+    }
+    this.endSession();
+    scope.setSession(session);
+    return session;
+  }
+  /**
+   * Returns if default PII should be sent to Sentry and propagated in ourgoing requests
+   * when Tracing is used.
+   */
+  shouldSendDefaultPii() {
+    const client = this.getClient();
+    const options = client && client.getOptions();
+    return Boolean(options && options.sendDefaultPii);
+  }
+  /**
+   * Sends the current Session on the scope
+   */
+  _sendSessionUpdate() {
+    const { scope, client } = this.getStackTop();
+    const session = scope.getSession();
+    if (session && 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.
+   */
+  _withClient(callback) {
+    const { scope, client } = this.getStackTop();
+    if (client) {
+      callback(client, scope);
+    }
+  }
+  /**
+   * Calls global extension method and binding current instance to the function call
+   */
+  // @ts-expect-error Function lacks ending return statement and return type does not include 'undefined'. ts(2366)
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  _callExtensionMethod(method, ...args) {
+    const carrier = getMainCarrier();
+    const sentry = carrier.__SENTRY__;
+    if (sentry && sentry.extensions && typeof sentry.extensions[method] === "function") {
+      return sentry.extensions[method].apply(this, args);
+    }
+    (typeof __SENTRY_DEBUG__ === "undefined" || __SENTRY_DEBUG__) && logger.warn(`Extension method ${method} couldn't be found, doing nothing.`);
+  }
+}
+function getMainCarrier() {
+  GLOBAL_OBJ.__SENTRY__ = GLOBAL_OBJ.__SENTRY__ || {
+    extensions: {},
+    hub: void 0
+  };
+  return GLOBAL_OBJ;
+}
+function makeMain(hub) {
+  const registry = getMainCarrier();
+  const oldHub = getHubFromCarrier(registry);
+  setHubOnCarrier(registry, hub);
+  return oldHub;
+}
+function getCurrentHub() {
+  const registry = getMainCarrier();
+  if (registry.__SENTRY__ && registry.__SENTRY__.acs) {
+    const hub = registry.__SENTRY__.acs.getCurrentHub();
+    if (hub) {
+      return hub;
+    }
+  }
+  return getGlobalHub(registry);
+}
+function getGlobalHub(registry = getMainCarrier()) {
+  if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {
+    setHubOnCarrier(registry, new Hub());
+  }
+  return getHubFromCarrier(registry);
+}
+function hasHubOnCarrier(carrier) {
+  return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);
+}
+function getHubFromCarrier(carrier) {
+  return getGlobalSingleton("hub", () => new Hub(), carrier);
+}
+function setHubOnCarrier(carrier, hub) {
+  if (!carrier) return false;
+  const __SENTRY__ = carrier.__SENTRY__ = carrier.__SENTRY__ || {};
+  __SENTRY__.hub = hub;
+  return true;
+}
+function captureException(exception, captureContext) {
+  return getCurrentHub().captureException(exception, { captureContext });
+}
+function captureMessage(message, captureContext) {
+  const level = captureContext;
+  const context = void 0;
+  return getCurrentHub().captureMessage(message, level, context);
+}
+function addBreadcrumb(breadcrumb) {
+  getCurrentHub().addBreadcrumb(breadcrumb);
+}
+function withScope(callback) {
+  getCurrentHub().withScope(callback);
+}
+const SDK_TAG = "juo.blocks";
+function applyScope(scope, ctx) {
+  var _a, _b, _c, _d;
+  scope.setTag(`${SDK_TAG}.site`, ctx.site);
+  if (ctx.block) {
+    scope.setTag(`${SDK_TAG}.block_id`, ctx.block.id);
+    scope.setTag(`${SDK_TAG}.block_type`, ctx.block.type);
+    if ((_a = ctx.block.definition) == null ? void 0 : _a.name) {
+      scope.setTag(`${SDK_TAG}.block_name`, ctx.block.definition.name);
+    } else {
+      scope.setTag(`${SDK_TAG}.block_name`, ctx.block.type);
+    }
+    if ((_b = ctx.block.definition) == null ? void 0 : _b.group) {
+      scope.setTag(`${SDK_TAG}.block_group`, ctx.block.definition.group);
+    }
+  }
+  if ((_c = ctx.keys) == null ? void 0 : _c.props) {
+    scope.setExtra("props_keys", ctx.keys.props);
+  }
+  if ((_d = ctx.keys) == null ? void 0 : _d.slots) {
+    scope.setExtra("slots_keys", ctx.keys.slots);
+  }
+  if (ctx.extra) {
+    for (const [key, value] of Object.entries(ctx.extra)) {
+      if (value !== void 0) {
+        scope.setExtra(key, value);
+      }
+    }
+  }
+}
+function reportBlockError(error, ctx) {
+  console.error(`[${SDK_TAG}] ${ctx.site}`, error, ctx);
+  try {
+    withScope((scope) => {
+      applyScope(scope, ctx);
+      captureException(error);
+    });
+  } catch {
+  }
+}
+function reportBlockWarning(message, ctx) {
+  console.warn(`[${SDK_TAG}] ${ctx.site}: ${message}`, ctx);
+  try {
+    withScope((scope) => {
+      applyScope(scope, ctx);
+      captureMessage(message, "warning");
+    });
+  } catch {
+  }
+}
+function blockBreadcrumb(message, ctx) {
+  var _a, _b;
+  try {
+    addBreadcrumb({
+      category: SDK_TAG,
+      level: "info",
+      message,
+      data: {
+        site: ctx.site,
+        block_id: (_a = ctx.block) == null ? void 0 : _a.id,
+        block_type: (_b = ctx.block) == null ? void 0 : _b.type
+      }
+    });
+  } catch {
+  }
+}
+export {
+  blockBreadcrumb,
+  reportBlockError,
+  reportBlockWarning
+};