1;!function(){try { var e="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof global?global:"undefined"!=typeof window?window:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&((e._debugIds|| (e._debugIds={}))[n]="eee4fc12-1f4b-9c60-cfeb-409879c757ac")}catch(e){}}(); 2(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined, 3225304, ((__turbopack_context__) => { 4"use strict"; 5 6const GLOBAL_OBJ = globalThis; 7; 8__turbopack_context__.s([ 9 "GLOBAL_OBJ", 10 0, 11 GLOBAL_OBJ 12]); 13}), 14111139, ((__turbopack_context__) => { 15"use strict"; 16 17var __TURBOPACK__imported__module__225304__ = __turbopack_context__.i(225304); 18; 19let RESOLVED_RUNNER; 20function withRandomSafeContext(cb) { 21 if (RESOLVED_RUNNER !== void 0) { 22 return RESOLVED_RUNNER ? RESOLVED_RUNNER(cb) : cb(); 23 } 24 const sym = /* @__PURE__ */ Symbol.for("__SENTRY_SAFE_RANDOM_ID_WRAPPER__"); 25 const globalWithSymbol = __TURBOPACK__imported__module__225304__["GLOBAL_OBJ"]; 26 if (sym in globalWithSymbol && typeof globalWithSymbol[sym] === "function") { 27 RESOLVED_RUNNER = globalWithSymbol[sym]; 28 return RESOLVED_RUNNER(cb); 29 } 30 RESOLVED_RUNNER = null; 31 return cb(); 32} 33function safeMathRandom() { 34 return withRandomSafeContext(()=>Math.random()); 35} 36function safeDateNow() { 37 return withRandomSafeContext(()=>Date.now()); 38} 39; 40__turbopack_context__.s([ 41 "safeDateNow", 42 0, 43 safeDateNow, 44 "safeMathRandom", 45 0, 46 safeMathRandom, 47 "withRandomSafeContext", 48 0, 49 withRandomSafeContext 50]); 51}), 52605394, ((__turbopack_context__) => { 53"use strict"; 54 55var __TURBOPACK__imported__module__111139__ = __turbopack_context__.i(111139); 56var __TURBOPACK__imported__module__225304__ = __turbopack_context__.i(225304); 57; 58; 59const ONE_SECOND_IN_MS = 1e3; 60function dateTimestampInSeconds() { 61 return (0, __TURBOPACK__imported__module__111139__["safeDateNow"])() / ONE_SECOND_IN_MS; 62} 63function createUnixTimestampInSecondsFunc() { 64 const { performance } = __TURBOPACK__imported__module__225304__["GLOBAL_OBJ"]; 65 if (!(performance === null || performance === void 0 ? void 0 : performance.now) || !performance.timeOrigin) { 66 return dateTimestampInSeconds; 67 } 68 const timeOrigin = performance.timeOrigin; 69 return ()=>{ 70 return (timeOrigin + (0, __TURBOPACK__imported__module__111139__["withRandomSafeContext"])(()=>performance.now())) / ONE_SECOND_IN_MS; 71 }; 72} 73let _cachedTimestampInSeconds; 74function timestampInSeconds() { 75 const func = _cachedTimestampInSeconds !== null && _cachedTimestampInSeconds !== void 0 ? _cachedTimestampInSeconds : _cachedTimestampInSeconds = createUnixTimestampInSecondsFunc(); 76 return func(); 77} 78let cachedTimeOrigin = null; 79function getBrowserTimeOrigin() { 80 var _performance_timing; 81 const { performance } = __TURBOPACK__imported__module__225304__["GLOBAL_OBJ"]; 82 if (!(performance === null || performance === void 0 ? void 0 : performance.now)) { 83 return void 0; 84 } 85 const threshold = 3e5; 86 const performanceNow = (0, __TURBOPACK__imported__module__111139__["withRandomSafeContext"])(()=>performance.now()); 87 const dateNow = (0, __TURBOPACK__imported__module__111139__["safeDateNow"])(); 88 const timeOrigin = performance.timeOrigin; 89 if (typeof timeOrigin === "number") { 90 const timeOriginDelta = Math.abs(timeOrigin + performanceNow - dateNow); 91 if (timeOriginDelta < threshold) { 92 return timeOrigin; 93 } 94 } 95 const navigationStart = (_performance_timing = performance.timing) === null || _performance_timing === void 0 ? void 0 : _performance_timing.navigationStart; 96 if (typeof navigationStart === "number") { 97 const navigationStartDelta = Math.abs(navigationStart + performanceNow - dateNow); 98 if (navigationStartDelta < threshold) { 99 return navigationStart; 100 } 101 } 102 return dateNow - performanceNow; 103} 104function browserPerformanceTimeOrigin() { 105 if (cachedTimeOrigin === null) { 106 cachedTimeOrigin = getBrowserTimeOrigin(); 107 } 108 return cachedTimeOrigin; 109} 110; 111__turbopack_context__.s([ 112 "browserPerformanceTimeOrigin", 113 0, 114 browserPerformanceTimeOrigin, 115 "dateTimestampInSeconds", 116 0, 117 dateTimestampInSeconds, 118 "timestampInSeconds", 119 0, 120 timestampInSeconds 121]); 122}), 123901020, ((__turbopack_context__) => { 124"use strict"; 125 126const DEBUG_BUILD = typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__; 127; 128__turbopack_context__.s([ 129 "DEBUG_BUILD", 130 0, 131 DEBUG_BUILD 132]); 133}), 134591401, ((__turbopack_context__) => { 135"use strict"; 136 137const SDK_VERSION = "10.74.0"; 138; 139__turbopack_context__.s([ 140 "SDK_VERSION", 141 0, 142 SDK_VERSION 143]); 144}), 145923288, ((__turbopack_context__) => { 146"use strict"; 147 148var __TURBOPACK__imported__module__591401__ = __turbopack_context__.i(591401); 149var __TURBOPACK__imported__module__225304__ = __turbopack_context__.i(225304); 150; 151; 152function getMainCarrier() { 153 getSentryCarrier(__TURBOPACK__imported__module__225304__["GLOBAL_OBJ"]); 154 return __TURBOPACK__imported__module__225304__["GLOBAL_OBJ"]; 155} 156function getSentryCarrier(carrier) { 157 const __SENTRY__ = carrier.__SENTRY__ = carrier.__SENTRY__ || {}; 158 __SENTRY__.version = __SENTRY__.version || __TURBOPACK__imported__module__591401__["SDK_VERSION"]; 159 return __SENTRY__[__TURBOPACK__imported__module__591401__["SDK_VERSION"]] = __SENTRY__[__TURBOPACK__imported__module__591401__["SDK_VERSION"]] || {}; 160} 161function getGlobalSingleton(name, creator) { 162 let obj = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : __TURBOPACK__imported__module__225304__["GLOBAL_OBJ"]; 163 const __SENTRY__ = obj.__SENTRY__ = obj.__SENTRY__ || {}; 164 const carrier = __SENTRY__[__TURBOPACK__imported__module__591401__["SDK_VERSION"]] = __SENTRY__[__TURBOPACK__imported__module__591401__["SDK_VERSION"]] || {}; 165 return carrier[name] || (carrier[name] = creator()); 166} 167; 168__turbopack_context__.s([ 169 "getGlobalSingleton", 170 0, 171 getGlobalSingleton, 172 "getMainCarrier", 173 0, 174 getMainCarrier, 175 "getSentryCarrier", 176 0, 177 getSentryCarrier 178]); 179}), 180272598, ((__turbopack_context__) => { 181"use strict"; 182 183var __TURBOPACK__imported__module__923288__ = __turbopack_context__.i(923288); 184var __TURBOPACK__imported__module__901020__ = __turbopack_context__.i(901020
184); 185var __TURBOPACK__imported__module__225304__ = __turbopack_context__.i(225304); 186; 187; 188; 189const CONSOLE_LEVELS = [ 190 "debug", 191 "info", 192 "warn", 193 "error", 194 "log", 195 "assert", 196 "trace" 197]; 198const PREFIX = "Sentry Logger "; 199const originalConsoleMethods = {}; 200function consoleSandbox(callback) { 201 if (!("console" in __TURBOPACK__imported__module__225304__["GLOBAL_OBJ"])) { 202 return callback(); 203 } 204 const console = __TURBOPACK__imported__module__225304__["GLOBAL_OBJ"].console; 205 const wrappedFuncs = {}; 206 const wrappedLevels = Object.keys(originalConsoleMethods); 207 wrappedLevels.forEach((level)=>{ 208 const originalConsoleMethod = originalConsoleMethods[level]; 209 wrappedFuncs[level] = console[level]; 210 console[level] = originalConsoleMethod; 211 }); 212 try { 213 return callback(); 214 } finally{ 215 wrappedLevels.forEach((level)=>{ 216 console[level] = wrappedFuncs[level]; 217 }); 218 } 219} 220function enable() { 221 _getLoggerSettings().enabled = true; 222} 223function disable() { 224 _getLoggerSettings().enabled = false; 225} 226function isEnabled() { 227 return _getLoggerSettings().enabled; 228} 229function log() { 230 for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){ 231 args[_key] = arguments[_key]; 232 } 233 _maybeLog("log", ...args); 234} 235function warn() { 236 for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){ 237 args[_key] = arguments[_key]; 238 } 239 _maybeLog("warn", ...args); 240} 241function error() { 242 for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){ 243 args[_key] = arguments[_key]; 244 } 245 _maybeLog("error", ...args); 246} 247function _maybeLog(level) { 248 for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){ 249 args[_key - 1] = arguments[_key]; 250 } 251 if (!__TURBOPACK__imported__module__901020__["DEBUG_BUILD"]) { 252 return; 253 } 254 if (isEnabled()) { 255 consoleSandbox(()=>{ 256 __TURBOPACK__imported__module__225304__["GLOBAL_OBJ"].console[level]("".concat(PREFIX, "[").concat(level, "]:"), ...args); 257 }); 258 } 259} 260function _getLoggerSettings() { 261 if (!__TURBOPACK__imported__module__901020__["DEBUG_BUILD"]) { 262 return { 263 enabled: false 264 }; 265 } 266 return (0, __TURBOPACK__imported__module__923288__["getGlobalSingleton"])("loggerSettings", ()=>({ 267 enabled: false 268 })); 269} 270const debug = { 271 /** Enable logging. */ enable, 272 /** Disable logging. */ disable, 273 /** Check if logging is enabled. */ isEnabled, 274 /** Log a message. */ log, 275 /** Log a warning. */ warn, 276 /** Log an error. */ error 277}; 278; 279__turbopack_context__.s([ 280 "CONSOLE_LEVELS", 281 0, 282 CONSOLE_LEVELS, 283 "consoleSandbox", 284 0, 285 consoleSandbox, 286 "debug", 287 0, 288 debug, 289 "originalConsoleMethods", 290 0, 291 originalConsoleMethods 292]); 293}), 294453288, ((__turbopack_context__) => { 295"use strict"; 296 297const objectToString = Object.prototype.toString; 298function isError(wat) { 299 switch(objectToString.call(wat)){ 300 case "[object Error]":
301 case "[object Exception]": 302 case "[object DOMException]": 303 case "[object WebAssembly.Exception]": 304 return true; 305 default: 306 return isInstanceOf(wat, Error); 307 } 308} 309function isBuiltin(wat, className) { 310 return objectToString.call(wat) === "[object ".concat(className, "]"); 311} 312function isErrorEvent(wat) { 313 return isBuiltin(wat, "ErrorEvent"); 314} 315function isDOMError(wat) { 316 return isBuiltin(wat, "DOMError"); 317} 318function isDOMException(wat) { 319 return isBuiltin(wat, "DOMException"); 320} 321function isString(wat) { 322 return isBuiltin(wat, "String"); 323} 324function isParameterizedString(wat) { 325 return typeof wat === "object" && wat !== null && "__sentry_template_string__" in wat && "__sentry_template_values__" in wat; 326} 327function isPrimitive(wat) { 328 return wat === null || isParameterizedString(wat) || typeof wat !== "object" && typeof wat !== "function"; 329} 330function isPlainObject(wat) { 331 return isBuiltin(wat, "Object"); 332} 333function isObjectLike(wat) { 334 return typeof wat === "object" && wat !== null; 335} 336function isEvent(wat) { 337 return typeof Event !== "undefined" && isInstanceOf(wat, Event); 338} 339function isElement(wat) { 340 return typeof Element !== "undefined" && isInstanceOf(wat, Element); 341} 342function isRegExp(wat) { 343 return isBuiltin(wat, "RegExp"); 344} 345function isThenable(wat) { 346 return Boolean((wat === null || wat === void 0 ? void 0 : wat.then) && typeof wat.then === "function"); 347} 348function isSyntheticEvent(wat) { 349 return isPlainObject(wat) && "nativeEvent" in wat && "preventDefault" in wat && "stopPropagation" in wat; 350} 351function isInstanceOf(wat, base) { 352 try { 353 return wat instanceof base; 354 } catch (unused) { 355 return false; 356 } 357} 358function isVueViewModel(wat) { 359 return !!(typeof wat === "object" && wat !== null && (wat.__isVue || wat._isVue || wat.__v_isVNode)); 360} 361function isRequest(request) { 362 return typeof Request !== "undefined" && isInstanceOf(request, Request); 363} 364; 365__turbopack_context__.s([ 366 "isDOMError", 367 0, 368 isDOMError, 369 "isDOMException", 370 0, 371 isDOMException, 372 "isError", 373 0, 374 isError, 375 "isErrorEvent", 376 0, 377 isErrorEvent, 378 "isEvent", 379 0, 380 isEvent, 381 "isInstanceOf", 382 0, 383 isInstanceOf, 384 "isObjectLike", 385 0, 386 isObjectLike, 387 "isParameterizedString", 388 0, 389 isParameterizedString, 390 "isPlainObject", 391 0, 392 isPlainObject, 393 "isPrimitive", 394 0, 395 isPrimitive, 396 "isRegExp", 397 0, 398 isRegExp, 399 "isRequest", 400 0, 401 isRequest, 402 "isString", 403 0, 404 isString, 405 "isThenable", 406 0, 407 isThenable 408]); 409}), 410951497, ((__turbopack_context__) => { 411"use strict"; 412 413var __TURBOPACK__imported__module__901020__ = __turbopack_context__.i(901020); 414var __TURBOPACK__imported__module__272598__ = __turbopack_context__.i(272598); 415var __TURBOPACK__imported__module__453288__ = __turbopack_context__.i(453288); 416; 417; 418; 419function fill(source, name, replacementFactory) { 420 if (!(name in source)) { 421 return; 422 } 423 const original = source[name]; 424 if (typeof original !== "function") { 425 return; 426 } 427 const wrapped = replacementFactory(original); 428 if (typeof wrapped === "function") { 429 markFunctionWrapped(wrapped, original); 430 } 431 try { 432 source[name] = wrapped; 433 } catch (unused) { 434 __TURBOPACK__imported__module__901020__["DEBUG_BUILD"] && __TURBOPACK__imported__module__272598__["debug"].log('Failed to replace method "'.concat(name, '" in object'), source); 435 } 436} 437function addNonEnumerableProperty(obj, name, value) { 438 try { 439 Object.defineProperty(obj, name, { 440 // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it 441 value, 442 writable: true, 443 configurable: true 444 }); 445 } catch (unused) { 446 __TURBOPACK__imported__module__901020__["DEBUG_BUILD"] && __TURBOPACK__imported__module__272598__["debug"].log('Failed to add non-enumerable property "'.concat(String(name), '" to object'), obj); 447 } 448} 449function markFunctionWrapped(wrapped, original) { 450 try { 451 const proto = original.prototype || {}; 452 wrapped.prototype = original.prototype = proto; 453 addNonEnumerableProperty(wrapped, "__sentry_original__", original); 454 } catch (unused) {} 455} 456function wrapMethod(obj, field, wrapped) { 457 let enumerable = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : true; 458 const original = obj[field]; 459 if (typeof original !== "function") { 460 throw new Error("Cannot wrap method: ".concat(field, " is not a function")); 461 } 462 if (getOriginalFunction(original)) { 463 throw new Error("Attempting to wrap method ".concat(field, " multiple times")); 464 } 465 markFunctionWrapped(wrapped, original);
466 Object.defineProperty(obj, field, { 467 writable: true, 468 configurable: true, 469 enumerable, 470 value: wrapped 471 }); 472} 473function getOriginalFunction(func) { 474 return func.__sentry_original__; 475} 476function convertToPlainObject(value) { 477 if ((0, __TURBOPACK__imported__module__453288__["isError"])(value)) { 478 return { 479 message: value.message, 480 name: value.name, 481 stack: value.stack, 482 ...getOwnProperties(value) 483 }; 484 } 485 if ((0, __TURBOPACK__imported__module__453288__["isEvent"])(value)) { 486 const { type, target, currentTarget, detail } = value; 487 return { 488 type, 489 target, 490 currentTarget, 491 ...detail ? { 492 detail 493 } : {}, 494 ...getOwnProperties(value) 495 }; 496 } 497 return value; 498} 499function getOwnProperties(obj) { 500 if ((0, __TURBOPACK__imported__module__453288__["isObjectLike"])(obj)) { 501 return Object.fromEntries(Object.entries(obj)); 502 } 503 return {}; 504} 505function extractExceptionKeysForMessage(exception) { 506 const keys = Object.keys(convertToPlainObject(exception)); 507 keys.sort(); 508 return !keys[0] ? "[object has no keys]" : keys.join(", "); 509} 510function dropUndefinedKeys(inputValue) { 511 const memoizationMap = /* @__PURE__ */ new Map(); 512 return _dropUndefinedKeys(inputValue, memoizationMap); 513} 514function _dropUndefinedKeys(inputValue, memoizationMap) { 515 if (inputValue === null || typeof inputValue !== "object") { 516 return inputValue; 517 } 518 const memoVal = memoizationMap.get(inputValue); 519 if (memoVal !== void 0) { 520 return memoVal; 521 } 522 if (Array.isArray(inputValue)) { 523 const returnValue = []; 524 memoizationMap.set(inputValue, returnValue); 525 inputValue.forEach((value)=>{ 526 returnValue.push(_dropUndefinedKeys(value, memoizationMap)); 527 }); 528 return returnValue; 529 } 530 if (isPojo(inputValue)) { 531 const returnValue = {}; 532 memoizationMap.set(inputValue, returnValue); 533 const keys = Object.keys(inputValue); 534 keys.forEach((key)=>{ 535 const val = inputValue[key]; 536 if (val !== void 0) { 537 returnValue[key] = _dropUndefinedKeys(val, memoizationMap); 538 } 539 }); 540 return returnValue; 541 } 542 return inputValue; 543} 544function isPojo(input) { 545 const constructor = input.constructor; 546 return constructor === Object || constructor === void 0; 547} 548function objectify(wat) { 549 let objectified; 550 switch(true){ 551 // this will catch both undefined and null 552 case wat == void 0: 553 objectified = new String(wat); 554 break; 555 // Though symbols and bigints do have wrapper classes (`Symbol` and `BigInt`, respectively), for whatever reason 556 // those classes don't have constructors which can be used with the `new` keyword. We therefore need to cast each as 557 // an object in order to wrap it. 558 case typeof wat === "symbol" || typeof wat === "bigint": 559 objectified = Object(wat); 560 break; 561 // this will catch the remaining primitives: `String`, `Number`, and `Boolean` 562 case (0, __TURBOPACK__imported__module__453288__["isPrimitive"])(wat): 563 objectified = new wat.constructor(wat); 564 break; 565 // by process of elimination, at this point we know that `wat` must already be an object 566 default: 567 objectified = wat; 568 break; 569 } 570 return objectified; 571} 572; 573__turbopack_context__.s([ 574 "addNonEnumerableProperty", 575 0, 576 addNonEnumerableProperty, 577 "convertToPlainObject", 578 0, 579 convertToPlainObject, 580 "extractExceptionKeysForMessage", 581 0, 582 extractExceptionKeysForMessage, 583 "fill", 584 0, 585 fill, 586 "getOriginalFunction", 587 0, 588 getOriginalFunction, 589 "markFunctionWrapped", 590 0, 591 markFunctionWrapped 592]); 593}), 594682564, 685658, 595936032, 59645968, 597821593, 598((__turbopack_context__) => { 599"use strict"; 600 601// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/misc.js [app-client] (ecmascript) 602; 603var __TURBOPACK__imported__module__951497__ = __turbopack_context__.i(951497); 604var __TURBOPACK__imported__module__111139__ = __turbopack_context__.i(111139); 605// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/string.js [a
605pp-client] (ecmascript) 606; 607var __TURBOPACK__imported__module__453288__ = __turbopack_context__.i(453288); 608// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/normalize.js [app-client] (ecmascript) 609; 610// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/normalizationHints.js [app-client] (ecmascript) 611; 612var __TURBOPACK__imported__module__951497__1 = __TURBOPACK__imported__module__951497__; 613; 614const SENTRY_SKIP_NORMALIZATION = /* @__PURE__ */ Symbol.for("sentry.skipNormalization"); 615const SENTRY_OVERRIDE_NORMALIZATION_DEPTH = /* @__PURE__ */ Symbol.for("sentry.overrideNormalizationDepth"); 616function setSkipNormalizationHint(obj) { 617 (0, __TURBOPACK__imported__module__951497__1["addNonEnumerableProperty"])(obj, SENTRY_SKIP_NORMALIZATION, true); 618} 619function setNormalizationDepthOverrideHint(obj, depth) { 620 (0, __TURBOPACK__imported__module__951497__1["addNonEnumerableProperty"])(obj, SENTRY_OVERRIDE_NORMALIZATION_DEPTH, depth); 621} 622function hasSkipNormalizationHint(value) { 623 return Boolean(value[SENTRY_SKIP_NORMALIZATION]); 624} 625function getNormalizationDepthOverrideHint(value) { 626 const v = value[SENTRY_OVERRIDE_NORMALIZATION_DEPTH]; 627 return typeof v === "number" ? v : void 0; 628} 629; 630__turbopack_context__.s([ 631 "getNormalizationDepthOverrideHint", 632 0, 633 getNormalizationDepthOverrideHint, 634 "hasSkipNormalizationHint", 635 0, 636 hasSkipNormalizationHint, 637 "setSkipNormalizationHint", 638 0, 639 setSkipNormalizationHint 640], 685658); 641var __TURBOPACK__imported__module__951497__2 = __TURBOPACK__imported__module__951497__; 642// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/stacktrace.js [app-client] (ecmascript) 643; 644const STACKTRACE_FRAME_LIMIT = 50; 645const UNKNOWN_FUNCTION = "?"; 646const WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/; 647const STRIP_FRAME_REGEXP = /captureMessage|captureException/; 648function createStackParser() { 649 for(var _len = arguments.length, parsers = new Array(_len), _key = 0; _key < _len; _key++){ 650 parsers[_key] = arguments[_key]; 651 } 652 const sortedParsers = parsers.sort((a, b)=>a[0] - b[0]).map((p)=>p[1]); 653 return function(stack) { 654 let skipFirstLines = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0, framesToPop = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0; 655 const frames = []; 656 const lines = stack.split("\n"); 657 for(let i = skipFirstLines; i < lines.length; i++){ 658 let line = lines[i]; 659 if (line.length > 1024) { 660 line = line.slice(0, 1024); 661 } 662 const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, "$1") : line; 663 if (cleanedLine.includes("Error: ")) { 664 continue; 665 } 666 for (const parser of sortedParsers){ 667 const frame = parser(cleanedLine); 668 if (frame) { 669 frames.push(frame); 670 break; 671 } 672 } 673 if (frames.length >= STACKTRACE_FRAME_LIMIT + framesToPop) { 674 break; 675 } 676 } 677 return stripSentryFramesAndReverse(frames.slice(framesToPop)); 678 }; 679} 680function stackParserFromStackParserOptions(stackParser) { 681 if (Array.isArray(stackParser)) { 682 return createStackParser(...stackParser); 683 } 684 return stackParser; 685} 686function stripSentryFramesAndReverse(stack) { 687 if (!stack.length) { 688 return []; 689 } 690 const localStack = Array.from(stack); 691 if (/sentryWrapped/.test(getLastStackFrame(localStack).function || "")) { 692 localStack.pop(); 693 } 694 localStack.reverse(); 695 if (STRIP_FRAME_REGEXP.test(getLastStackFrame(localStack).function || "")) { 696 localStack.pop(); 697 if (STRIP_FRAME_REGEXP.test(getLastStackFrame(localStack).function || "")) { 698 localStack.pop(); 699 } 700 } 701 return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map((frame)=>({ 702 ...frame, 703 filename: frame.filename || getLastStackFrame(localStack).filename, 704 function: frame.function || UNKNOWN_FUNCTION 705 })); 706} 707function getLastStackFrame(arr) { 708 return arr[arr.length - 1] || {}; 709} 710const defaultFunctionName = "<anonymous>"; 711function getFunctionName(fn) { 712 try { 713 if (!fn || typeof fn !== "function") { 714 return defaultFunctionName; 715 } 716 return fn.name || defaultFunctionName; 717 } catch (unused) { 718 return defaultFunctionName; 719 } 720} 721function getFramesFromEvent(event) { 722 const exception = event.exception; 723 if (exception) { 724 const frames = []; 725 try {
726 exception.values.forEach((value)=>{ 727 if (value.stacktrace.frames) { 728 frames.push(...value.stacktrace.frames); 729 } 730 }); 731 return frames; 732 } catch (unused) { 733 return void 0; 734 } 735 } 736 return void 0; 737} 738function normalizeStackTracePath(path) { 739 let filename = (path === null || path === void 0 ? void 0 : path.startsWith("file://")) ? path.slice(7) : path; 740 if (filename === null || filename === void 0 ? void 0 : filename.match(/\/[A-Z]:/)) { 741 filename = filename.slice(1); 742 } 743 return filename; 744} 745; 746__turbopack_context__.s([ 747 "UNKNOWN_FUNCTION", 748 0, 749 UNKNOWN_FUNCTION, 750 "createStackParser", 751 0, 752 createStackParser, 753 "getFramesFromEvent", 754 0, 755 getFramesFromEvent, 756 "getFunctionName", 757 0, 758 getFunctionName, 759 "normalizeStackTracePath", 760 0, 761 normalizeStackTracePath, 762 "stackParserFromStackParserOptions", 763 0, 764 stackParserFromStackParserOptions 765], 936032); 766; 767; 768; 769let stringifier; 770function setNormalizeStringifier(newStringifier) { 771 stringifier = newStringifier; 772} 773function normalize(input) { 774 let depth = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 100, maxProperties = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : Infinity; 775 try { 776 return visit("", input, depth, maxProperties); 777 } catch (err) { 778 return { 779 ERROR: "**non-serializable** (".concat(err, ")") 780 }; 781 } 782} 783function normalizeToSize(object) { 784 let depth = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 3, maxSize = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 100 * 1024; 785 const normalized = normalize(object, depth); 786 if (jsonSize(normalized) > maxSize) { 787 return normalizeToSize(object, depth - 1, maxSize); 788 } 789 return normalized; 790} 791function visit(key, value) { 792 let depth = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : Infinity, maxProperties = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : Infinity, memo = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : memoBuilder(); 793 const [memoize, unmemoize] = memo; 794 if (value == null || // this matches null and undefined -> eqeq not eqeqeq 795 [ 796 "boolean", 797 "string" 798 ].includes(typeof value) || typeof value === "number" && Number.isFinite(value)) { 799 return value; 800 } 801 const stringified = stringifyValue(key, value); 802 if (!stringified.startsWith("[object ")) { 803 return stringified; 804 } 805 if (hasSkipNormalizationHint(value)) { 806 return value; 807 } 808 const overrideDepth = getNormalizationDepthOverrideHint(value); 809 const remainingDepth = overrideDepth !== void 0 ? overrideDepth : depth; 810 if (remainingDepth === 0) { 811 return stringified.replace("object ", ""); 812 } 813 if (memoize(value)) { 814 return "[Circular ~]"; 815 } 816 const valueWithToJSON = value; 817 if (valueWithToJSON && typeof valueWithToJSON.toJSON === "function") { 818 try { 819 const jsonValue = valueWithToJSON.toJSON(); 820 return visit("", jsonValue, remainingDepth - 1, maxProperties, memo); 821 } catch (unused) {} 822 } 823 const normalized = Array.isArray(value) ? [] : {}; 824 let numAdded = 0; 825 const visitable = (0, __TURBOPACK__imported__module__951497__2["convertToPlainObject"])(value); 826 for(const visitKey in visitable){ 827 if (!Object.prototype.hasOwnProperty.call(visitable, visitKey)) { 828 continue; 829 } 830 if (numAdded >= maxProperties) { 831 normalized[visitKey] = "[MaxProperties ~]"; 832 break; 833 } 834 const visitValue = visitable[visitKey]; 835 normalized[visitKey] = visit(visitKey, visitValue, remainingDepth - 1, maxProperties, memo); 836 numAdded++; 837 } 838 unmemoize(value); 839 return normalized; 840} 841function stringifyValue(key, value) { 842 try { 843 if (stringifier) { 844 const stringified = stringifier(value); 845 if (stringified) { 846 return stringified; 847 } 848 } 849 if (("TURBOPACK compile-time value", "object") !== "undefined" && value === /*TURBOPACK member replacement*/ __turbopack_context__.g) { 850 return "[Global]"; 851 } 852 if (typeof value === "number" && !Number.isFinite(value)) { 853 return "[".concat(value, "]"); 854 } 855 if (typeof value === "function") { 856 return "[Function: ".concat(getFunctionName(value), "]"); 857 } 858 if (typeof value === "symbol") { 859 return "[".concat(String(value), "]"); 860 } 861 if (typeof value === "bigint") { 862 return "[BigInt: ".concat(String(value), "]"); 863 } 864 const objName = getConstructorName(value); 865 return "[object ".concat(objName, "]"); 866 } catch (err) { 867 return "**non-serializable** (".concat(err, ")"); 868 } 869} 870function getConstructorName(value) { 871 const prototype = Object.getPrototypeOf(value); 872 return (prototype === null || prototype === void 0 ? void 0 : prototype.constructor) ? prototype.constructor.name : "null prototype"; 873} 874function utf8Length(value) { 875 return ~-encodeURI(value).split(/%..|./).length; 876} 877function jsonSize(value) { 878 return utf8Length(JSON.stringify(value)); 879} 880function normalizeUrlToBase(url, basePath) { 881 const escapedBase = basePath.replace(/\\/g, "/").replace(/[|\\{}()[\]^$+*?.]/g, "\\$&"); 882 let newUrl = url; 883 try { 884 newUrl = decodeURI(url); 885 } catch (unused) {} 886 return newUrl.replace(/\\/g, "/").replace(/webpack:\/?/g, "").replace(new RegExp("(file://)?/*".concat(escapedBase, "/*"), "ig"), "app:///"); 887} 888function memoBuilder() { 889 const inner = /* @__PURE__ */ new WeakSet();
890 function memoize(obj) { 891 if (inner.has(obj)) { 892 return true; 893 } 894 inner.add(obj); 895 return false; 896 } 897 function unmemoize(obj) { 898 inner.delete(obj); 899 } 900 return [ 901 memoize, 902 unmemoize 903 ]; 904} 905; 906__turbopack_context__.s([ 907 "normalize", 908 0, 909 normalize, 910 "normalizeToSize", 911 0, 912 normalizeToSize, 913 "setNormalizeStringifier", 914 0, 915 setNormalizeStringifier, 916 "stringifyValue", 917 0, 918 stringifyValue 919], 45968); 920; 921; 922function stringify(value) { 923 let fallback = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "[unserializable]"; 924 if (typeof value === "string") { 925 return value; 926 } 927 try { 928 return JSON.stringify(value); 929 } catch (unused) { 930 return typeof fallback === "function" ? fallback(value) : fallback; 931 } 932} 933function truncate(str) { 934 let max = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0; 935 if (typeof str !== "string" || max === 0) { 936 return str; 937 } 938 return str.length <= max ? str : "".concat(str.slice(0, max), "..."); 939} 940function snipLine(line, colno) { 941 let newLine = line; 942 const lineLength = newLine.length; 943 if (lineLength <= 150) { 944 return newLine; 945 } 946 if (colno > lineLength) { 947 colno = lineLength; 948 } 949 let start = Math.max(colno - 60, 0); 950 if (start < 5) { 951 start = 0; 952 } 953 let end = Math.min(start + 140, lineLength); 954 if (end > lineLength - 5) { 955 end = lineLength; 956 } 957 if (end === lineLength) { 958 start = Math.max(end - 140, 0); 959 } 960 newLine = newLine.slice(start, end); 961 if (start > 0) { 962 newLine = "'{snip} ".concat(newLine); 963 } 964 if (end < lineLength) { 965 newLine += " {snip}"; 966 } 967 return newLine; 968} 969function safeJoin(input, delimiter) { 970 if (!Array.isArray(input)) { 971 return ""; 972 } 973 const output = []; 974 for(let i = 0; i < input.length; i++){ 975 const value = input[i]; 976 if ((0, __TURBOPACK__imported__module__453288__["isPrimitive"])(value)) { 977 output.push(String(value)); 978 } else if (value instanceof Error) { 979 output.push(value.message ? "".concat(value.name, ": ").concat(value.message) : value.name); 980 } else { 981 output.push(stringifyValue(void 0, value)); 982 } 983 } 984 return output.join(delimiter); 985} 986function isMatchingPattern(value, pattern) { 987 let requireExactStringMatch = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false; 988 if (!(0, __TURBOPACK__imported__module__453288__["isString"])(value)) { 989 return false; 990 } 991 if ((0, __TURBOPACK__imported__module__453288__["isRegExp"])(pattern)) { 992 return pattern.test(value); 993 } 994 if ((0, __TURBOPACK__imported__module__453288__["isString"])(pattern)) { 995 return requireExactStringMatch ? value === pattern : value.includes(pattern); 996 } 997 if (typeof pattern === "function") { 998 return pattern(value); 999 } 1000 return false; 1001} 1002function stringMatchesSomePattern(testString) { 1003 let patterns = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [], requireExactStringMatch = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false; 1004 for (const pattern of patterns){ 1005 if (isMatchingPattern(testString, pattern, requireExactStringMatch)) { 1006 return true; 1007 } 1008 } 1009 return false; 1010} 1011; 1012__turbopack_context__.s([ 1013 "isMatchingPattern", 1014 0, 1015 isMatchingPattern, 1016 "safeJoin", 1017 0, 1018 safeJoin, 1019 "snipLine", 1020 0, 1021 snipLine, 1022 "stringMatchesSomePattern", 1023 0, 1024 stringMatchesSomePattern, 1025 "truncate", 1026 0, 1027 truncate 1028], 821593); 1029var __TURBOPACK__imported__module__225304__ = __turbopack_context__.i(225304); 1030; 1031; 1032; 1033; 1034function getCrypto() { 1035 const gbl = __TURBOPACK__imported__module__225304__["GLOBAL_OBJ"]; 1036 return gbl.crypto || gbl.msCrypto; 1037} 1038let emptyUuid; 1039function getRandomByte() { 1040 return (0, __TURBOPACK__imported__module__111139__["safeMathRandom"])() * 16; 1041} 1042function uuid4() {
1043 let crypto = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : getCrypto(); 1044 try { 1045 if (crypto === null || crypto === void 0 ? void 0 : crypto.randomUUID) { 1046 return (0, __TURBOPACK__imported__module__111139__["withRandomSafeContext"])(()=>crypto.randomUUID()).replace(/-/g, ""); 1047 } 1048 } catch (unused) {} 1049 if (!emptyUuid) { 1050 emptyUuid = "10000000100040008000" + 1e11; 1051 } 1052 return emptyUuid.replace(/[018]/g, (c)=>// eslint-disable-next-line no-bitwise 1053 (c ^ (getRandomByte() & 15) >> c / 4).toString(16)); 1054} 1055function getFirstException(event) { 1056 var _event_exception_values, _event_exception; 1057 return (_event_exception = event.exception) === null || _event_exception === void 0 ? void 0 : (_event_exception_values = _event_exception.values) === null || _event_exception_values === void 0 ? void 0 : _event_exception_values[0]; 1058} 1059function getEventDescription(event) { 1060 const { message, event_id: eventId } = event; 1061 if (message) { 1062 return message; 1063 } 1064 const firstException = getFirstException(event); 1065 if (firstException) { 1066 if (firstException.type && firstException.value) { 1067 return "".concat(firstException.type, ": ").concat(firstException.value); 1068 } 1069 return firstException.type || firstException.value || eventId || "<unknown>"; 1070 } 1071 return eventId || "<unknown>"; 1072} 1073function addExceptionTypeValue(event, value, type) { 1074 const exception = event.exception = event.exception || {}; 1075 const values = exception.values = exception.values || []; 1076 const firstException = values[0] = values[0] || {}; 1077 if (!firstException.value) { 1078 firstException.value = value || ""; 1079 } 1080 if (!firstException.type) { 1081 firstException.type = type || "Error"; 1082 } 1083} 1084function addExceptionMechanism(event, newMechanism) { 1085 const firstException = getFirstException(event); 1086 if (!firstException) { 1087 return; 1088 } 1089 const defaultMechanism = { 1090 type: "generic", 1091 handled: true 1092 }; 1093 const currentMechanism = firstException.mechanism; 1094 firstException.mechanism = { 1095 ...defaultMechanism, 1096 ...currentMechanism, 1097 ...newMechanism 1098 }; 1099 if (newMechanism && "data" in newMechanism) { 1100 const mergedData = { 1101 ...currentMechanism === null || currentMechanism === void 0 ? void 0 : currentMechanism.data, 1102 ...newMechanism.data 1103 }; 1104 firstException.mechanism.data = mergedData; 1105 } 1106} 1107const 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-]+)*))?$/; 1108function _parseInt(input) { 1109 return parseInt(input || "", 10); 1110} 1111function parseSemver(input) { 1112 const match = input.match(SEMVER_REGEXP) || []; 1113 const major = _parseInt(match[1]); 1114 const minor = _parseInt(match[2]); 1115 const patch = _parseInt(match[3]); 1116 return { 1117 buildmetadata: match[5], 1118 major: isNaN(major) ? void 0 : major, 1119 minor: isNaN(minor) ? void 0 : minor, 1120 patch: isNaN(patch) ? void 0 : patch, 1121 prerelease: match[4] 1122 }; 1123} 1124function addContextToFrame(lines, frame) { 1125 let linesOfContext = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 5; 1126 if (frame.lineno === void 0) { 1127 return; 1128 } 1129 const maxLines = lines.length; 1130 const sourceLine = Math.max(Math.min(maxLines - 1, frame.lineno - 1), 0); 1131 frame.pre_context = lines.slice(Math.max(0, sourceLine - linesOfContext), sourceLine).map((line)=>snipLine(line, 0)); 1132 const lineIndex = Math.min(maxLines - 1, sourceLine); 1133 frame.context_line = snipLine(lines[lineIndex], frame.colno || 0); 1134 frame.post_context = lines.slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext).map((line)=>snipLine(line, 0)); 1135} 1136function checkOrSetAlreadyCaught(exception) { 1137 if (isAlreadyCaptured(exception)) { 1138 return true; 1139 } 1140 try { 1141 (0, __TURBOPACK__imported__module__951497__["addNonEnumerableProperty"])(exception, "__sentry_captured__", true); 1142 } catch (unused) {} 1143 return false;
1144} 1145function isAlreadyCaptured(exception) { 1146 try { 1147 return exception.__sentry_captured__; 1148 } catch (unused) {} 1149} 1150; 1151__turbopack_context__.s([ 1152 "addExceptionMechanism", 1153 0, 1154 addExceptionMechanism, 1155 "addExceptionTypeValue", 1156 0, 1157 addExceptionTypeValue, 1158 "checkOrSetAlreadyCaught", 1159 0, 1160 checkOrSetAlreadyCaught, 1161 "getEventDescription", 1162 0, 1163 getEventDescription, 1164 "uuid4", 1165 0, 1166 uuid4 1167], 682564); 1168}), 1169250804, 341041, 1170318746, 1171373382, 1172960224, 1173821061, 1174994218, 1175450574, 1176301263, 1177((__turbopack_context__) => { 1178"use strict"; 1179 1180// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/currentScopes.js [app-client] (ecmascript) 1181; 1182// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/asyncContext/index.js [app-client] (ecmascript) 1183; 1184var __TURBOPACK__imported__module__923288__ = __turbopack_context__.i(923288); 1185// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/asyncContext/stackStrategy.js [app-client] (ecmascript) 1186; 1187// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/defaultScopes.js [app-client] (ecmascript) 1188; 1189var __TURBOPACK__imported__module__923288__1 = __TURBOPACK__imported__module__923288__; 1190// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/scope.js [app-client] (ecmascript) 1191; 1192var __TURBOPACK__imported__module__901020__ = __turbopack_context__.i(901020); 1193// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/session.js [app-client] (ecmascript) 1194; 1195var __TURBOPACK__imported__module__682564__ = __turbopack_context__.i(682564); 1196var __TURBOPACK__imported__module__605394__ = __turbopack_context__.i(605394); 1197; 1198; 1199function makeSession(context) { 1200 const startingTime = (0, __TURBOPACK__imported__module__605394__["timestampInSeconds"])(); 1201 const session = { 1202 sid: (0, __TURBOPACK__imported__module__682564__["uuid4"])(), 1203 init: true, 1204 timestamp: startingTime, 1205 started: startingTime, 1206 duration: 0, 1207 status: "ok", 1208 errors: 0, 1209 ignoreDuration: false, 1210 toJSON: ()=>sessionToJSON(session) 1211 }; 1212 if (context) { 1213 updateSession(session, context); 1214 } 1215 return session; 1216} 1217function updateSession(session) {
1218 let context = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; 1219 if (context.user) { 1220 if (!session.ipAddress && context.user.ip_address) { 1221 session.ipAddress = context.user.ip_address; 1222 } 1223 if (!session.did && !context.did) { 1224 session.did = context.user.id || context.user.email || context.user.username; 1225 } 1226 } 1227 session.timestamp = context.timestamp || (0, __TURBOPACK__imported__module__605394__["timestampInSeconds"])(); 1228 if (context.abnormal_mechanism) { 1229 session.abnormal_mechanism = context.abnormal_mechanism; 1230 } 1231 if (context.ignoreDuration) { 1232 session.ignoreDuration = context.ignoreDuration; 1233 } 1234 if (context.sid) { 1235 session.sid = context.sid.length === 32 ? context.sid : (0, __TURBOPACK__imported__module__682564__["uuid4"])(); 1236 } 1237 if (context.init !== void 0) { 1238 session.init = context.init; 1239 } 1240 if (!session.did && context.did) { 1241 session.did = "".concat(context.did); 1242 } 1243 if (typeof context.started === "number") { 1244 session.started = context.started; 1245 } 1246 if (session.ignoreDuration) { 1247 session.duration = void 0; 1248 } else if (typeof context.duration === "number") { 1249 session.duration = context.duration; 1250 } else { 1251 const duration = session.timestamp - session.started; 1252 session.duration = duration >= 0 ? duration : 0; 1253 } 1254 if (context.release) { 1255 session.release = context.release; 1256 } 1257 if (context.environment) { 1258 session.environment = context.environment; 1259 } 1260 if (!session.ipAddress && context.ipAddress) { 1261 session.ipAddress = context.ipAddress; 1262 } 1263 if (!session.userAgent && context.userAgent) { 1264 session.userAgent = context.userAgent; 1265 } 1266 if (typeof context.errors === "number") { 1267 session.errors = context.errors; 1268 } 1269 if (context.status) { 1270 session.status = context.status; 1271 } 1272} 1273function closeSession(session, status) {
1274 let context = {}; 1275 if (status) { 1276 context = { 1277 status 1278 }; 1279 } else if (session.status === "ok") { 1280 context = { 1281 status: "exited" 1282 }; 1283 } 1284 updateSession(session, context); 1285} 1286function sessionToJSON(session) { 1287 return { 1288 sid: "".concat(session.sid), 1289 init: session.init, 1290 // Make sure that sec is converted to ms for date constructor 1291 started: new Date(session.started * 1e3).toISOString(), 1292 timestamp: new Date(session.timestamp * 1e3).toISOString(), 1293 status: session.status, 1294 errors: session.errors, 1295 did: typeof session.did === "number" || typeof session.did === "string" ? "".concat(session.did) : void 0, 1296 duration: session.duration, 1297 abnormal_mechanism: session.abnormal_mechanism, 1298 attrs: { 1299 release: session.release, 1300 environment: session.environment, 1301 ip_address: session.ipAddress, 1302 user_agent: session.userAgent 1303 } 1304 }; 1305} 1306; 1307__turbopack_context__.s([ 1308 "closeSession", 1309 0, 1310 closeSession, 1311 "makeSession", 1312 0, 1313 makeSession, 1314 "updateSession", 1315 0, 1316 updateSession 1317], 341041); 1318var __TURBOPACK__imported__module__272598__ = __turbopack_context__.i(272598); 1319var __TURBOPACK__imported__module__453288__ = __turbopack_context__.i(453288); 1320// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/merge.js [app-client] (ecmascript) 1321; 1322function merge(initialObj, mergeObj) { 1323 let levels = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 2; 1324 if (!mergeObj || typeof mergeObj !== "object" || levels <= 0) { 1325 return mergeObj; 1326 } 1327 if (initialObj && Object.keys(mergeObj).length === 0) { 1328 return initialObj; 1329 } 1330 const output = { 1331 ...initialObj 1332 }; 1333 for(const key in mergeObj){ 1334 if (Object.prototype.hasOwnProperty.call(mergeObj, key)) { 1335 output[key] = merge(output[key], mergeObj[key], levels - 1); 1336 } 1337 } 1338 return output; 1339} 1340; 1341__turbopack_context__.s([ 1342 "merge", 1343 0, 1344 merge 1345], 318746); 1346var __TURBOPACK__imported__module__682564__1 = __TURBOPACK__imported__module__682564__; 1347// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/propagationContext.js [app-client] (ecmascript) 1348; 1349var __TURBOPACK__imported__module__682564__2 = __TURBOPACK__imported__module__682564__; 1350; 1351function generateTraceId() { 1352 return (0, __TURBOPACK__imported__module__682564__2["uuid4"])(); 1353} 1354function generateSpanId() { 1355 return (0, __TURBOPACK__imported__module__682564__2["uuid4"])().substring(16); 1356} 1357; 1358__turbopack_context__.s([ 1359 "generateSpanId", 1360 0, 1361 generateSpanId, 1362 "generateTraceId", 1363 0, 1364 generateTraceId 1365], 373382); 1366var __TURBOPACK__imported__module__111139__ = __turbopack_context__.i(111139); 1367// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/spanOnScope.js [app-client] (ecmascript) 1368; 1369var __TURBOPACK__imported__module__951497__ = __turbopack_context__.i(951497); 1370// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/weakRef.js [app-client] (ecmascript) 1371; 1372var __TURBOPACK__imported__module__225304__ = __turbopack_context__.i(225304); 1373; 1374function makeWeakRef(value) { 1375 try { 1376 const WeakRefImpl = __TURBOPACK__imported__module__225304__["GLOBAL_OBJ"].WeakRef; 1377 if (typeof WeakRefImpl === "function") { 1378 return new WeakRefImpl(value); 1379 } 1380 } catch (unused) {} 1381 return value; 1382} 1383function derefWeakRef(ref) { 1384 if (!ref) { 1385 return void 0; 1386 } 1387 if (typeof ref === "object" && "deref" in ref && typeof ref.deref === "function") { 1388 try { 1389 return ref.deref(); 1390 } catch (unused) { 1391 return void 0; 1392 } 1393 } 1394 return ref; 1395} 1396; 1397__turbopack_context__.s([ 1398 "derefWeakRef", 1399 0, 1400 derefWeakRef, 1401 "makeWeakRef", 1402 0, 1403 makeWeakRef 1404], 960224); 1405; 1406; 1407const SCOPE_SPAN_FIELD = "_sentrySpan"; 1408function _setSpanForScope(scope, span) { 1409 if (span) { 1410 (0, __TURBOPACK__imported__module__951497__["addNonEnumerableProperty"])(scope, SCOPE_SPAN_FIELD, makeWeakRef(span)); 1411 } else { 1412 delete scope[SCOPE_SPAN_FIELD]; 1413 } 1414} 1415function _getSpanForScope(scope) { 1416 return derefWeakRef(scope[SCOPE_SPAN_FIELD]); 1417} 1418; 1419__turbopack_context__.s([
1420 "_getSpanForScope", 1421 0, 1422 _getSpanForScope, 1423 "_setSpanForScope", 1424 0, 1425 _setSpanForScope 1426], 821061); 1427var __TURBOPACK__imported__module__821593__ = __turbopack_context__.i(821593); 1428var __TURBOPACK__imported__module__605394__1 = __TURBOPACK__imported__module__605394__; 1429; 1430; 1431; 1432; 1433; 1434; 1435; 1436; 1437; 1438; 1439; 1440const DEFAULT_MAX_BREADCRUMBS = 100; 1441class Scope { 1442 /** 1443 * Clone all data from this scope into a new scope. 1444 */ clone() { 1445 const newScope = new Scope(); 1446 newScope._breadcrumbs = [ 1447 ...this._breadcrumbs 1448 ]; 1449 newScope._tags = { 1450 ...this._tags 1451 }; 1452 newScope._attributes = { 1453 ...this._attributes 1454 }; 1455 newScope._extra = { 1456 ...this._extra 1457 }; 1458 newScope._contexts = { 1459 ...this._contexts 1460 }; 1461 if (this._contexts.flags) { 1462 newScope._contexts.flags = { 1463 values: [ 1464 ...this._contexts.flags.values 1465 ] 1466 }; 1467 } 1468 newScope._user = this._user; 1469 newScope._level = this._level; 1470 newScope._session = this._session; 1471 newScope._transactionName = this._transactionName; 1472 newScope._fingerprint = this._fingerprint; 1473 newScope._eventProcessors = [ 1474 ...this._eventProcessors 1475 ]; 1476 newScope._attachments = [ 1477 ...this._attachments 1478 ]; 1479 newScope._sdkProcessingMetadata = { 1480 ...this._sdkProcessingMetadata 1481 }; 1482 newScope._propagationContext = { 1483 ...this._propagationContext 1484 }; 1485 newScope._client = this._client; 1486 newScope._lastEventId = this._lastEventId; 1487 newScope._conversationId = this._conversationId; 1488 _setSpanForScope(newScope, _getSpanForScope(this)); 1489 return newScope; 1490 } 1491 /** 1492 * Update the client assigned to this scope. 1493 * Note that not every scope will have a client assigned - isolation scopes & the global scope will generally not have a client, 1494 * as well as manually created scopes. 1495 */ setClient(client) { 1496 this._client = client; 1497 } 1498 /** 1499 * Set the ID of the last captured error event. 1500 * This is generally only captured on the isolation scope. 1501 */ setLastEventId(lastEventId) { 1502 this._lastEventId = lastEventId; 1503 } 1504 /** 1505 * Get the client assigned to this scope. 1506 */ getClient() { 1507 return this._client; 1508 } 1509 /** 1510 * Get the ID of the last captured error event. 1511 * This is generally only available on the isolation scope. 1512 */ lastEventId() { 1513 return this._lastEventId; 1514 } 1515 /** 1516 * @inheritDoc 1517 */ addScopeListener(callback) { 1518 this._scopeListeners.push(callback); 1519 } 1520 /** 1521 * Add an event processor that will be called before an event is sent. 1522 */ addEventProcessor(callback) { 1523 this._eventProcessors.push(callback); 1524 return this; 1525 } 1526 /** 1527 * Set the user for this scope. 1528 * Set to `null` to unset the user. 1529 */ setUser(user) { 1530 this._user = user || { 1531 email: void 0, 1532 id: void 0, 1533 ip_address: void 0, 1534 username: void 0 1535 }; 1536 if (this._session) { 1537 updateSession(this._session, { 1538 user 1539 }); 1540 } 1541 this._notifyScopeListeners(); 1542 return this; 1543 } 1544 /** 1545 * Get the user from this scope. 1546 */ getUser() { 1547 return this._user; 1548 } 1549 /** 1550 * Set the conversation ID for this scope. 1551 * Set to `null` to unset the conversation ID. 1552 */ setConversationId(conversationId) { 1553 this._conversationId = conversationId || void 0; 1554 this._notifyScopeListeners(); 1555 return this; 1556 } 1557 /** 1558 * Set an object that will be merged into existing tags on the scope, 1559 * and will be sent as tags data with the event. 1560 */ setTags(tags) { 1561 this._tags = { 1562 ...this._tags, 1563 ...tags 1564 }; 1565 this._notifyScopeListeners(); 1566 return this; 1567 } 1568 /** 1569 * Set a single tag that will be sent as tags data with the event. 1570 */ setTag(key, value) { 1571 return this.setTags({ 1572 [key]: value 1573 }); 1574 } 1575 /** 1576 * Sets attributes onto the scope. 1577 * 1578 * These attributes are applied to logs, metrics and streamed spans. 1579 * 1580 * Supported attribute value types are `string`, `number`, `boolean`, `string[]`, `number[]` and `boolean[]`. 1581 * 1582 * @param newAttributes - The attributes to set on the scope, as key-value pairs. 1583 * 1584 * @example 1585 * ```typescript 1586 * scope.setAttributes({ 1587 * is_admin: true, 1588 * payment_selection: 'credit_card', 1589 * render_duration: 150, 1590 * }); 1591 * ``` 1592 */ setAttributes(newAttributes) { 1593 this._attributes = { 1594 ...this._attributes, 1595 ...newAttributes 1596 }; 1597 this._notifyScopeListeners(); 1598 return this; 1599 } 1600 /** 1601 * Sets an attribute onto the scope. 1602 * 1603 * These attributes are applied to logs, metrics and streamed spans. 1604 * 1605 * Supported attribute value types are `string`, `number`, `boolean`, `string[]`, `number[]` and `boolean[]`. 1606 * 1607 * @param key - The attribute key. 1608 * @param value - The attribute value. 1609 * 1610 * @example 1611 * ```typescript 1612 * scope.setAttribute('is_admin', true); 1613 * scope.setAttribute('render_duration', 150); 1614 * ``` 1615 */ // eslint-disable-next-line @typescript-eslint/no-explicit-any 1616 setAttribute(key, value) { 1617 return this.setAttributes({ 1618 [key]: value 1619 }); 1620 } 1621 /** 1622 * Removes the attribute with the given key from the scope. 1623 * 1624 * @param key - The attribute key. 1625 * 1626 * @example 1627 * ```typescript 1628 * scope.removeAttribute('is_admin'); 1629 * ``` 1630 */ removeAttribute(key) { 1631 if (key in this._attributes) { 1632 delete this._attributes[key]; 1633 this._notifyScopeListeners(); 1634 } 1635 return this; 1636 } 1637 /** 1638 * Set an object that will be merged into existing extra on the scope, 1639 * and will be sent as extra data with the event. 1640 */ setExtras(extras) { 1641 this._extra = { 1642 ...this._extra, 1643 ...extras 1644 }; 1645 this._notifyScopeListeners(); 1646 return this; 1647 } 1648 /** 1649 * Set a single key:value extra entry that will be sent as extra data with the event. 1650 */ setExtra(key, extra) { 1651 this._extra = { 1652 ...this._extra, 1653 [key]: extra 1654 }; 1655 this._notifyScopeListeners(); 1656 return this; 1657 } 1658 /** 1659 * Sets the fingerprint on the scope to send with the events. 1660 * @param {string[]} fingerprint Fingerprint to group events in Sentry. 1661 */ setFingerprint(fingerprint) { 1662 this._fingerprint = fingerprint; 1663 this._notifyScopeListeners(); 1664 return this; 1665 } 1666 /** 1667 * Sets the level on the scope for future events. 1668 */ setLevel(level) { 1669 this._level = level; 1670 this._notifyScopeListeners(); 1671 return this; 1672 } 1673 /** 1674 * Sets the transaction name on the scope so that the name of e.g. taken server route or 1675 * the page location is attached to future events. 1676 *
1677 * IMPORTANT: Calling this function does NOT change the name of the currently active 1678 * root span. If you want to change the name of the active root span, use 1679 * `Sentry.updateSpanName(rootSpan, 'new name')` instead. 1680 * 1681 * By default, the SDK updates the scope's transaction name automatically on sensible 1682 * occasions, such as a page navigation or when handling a new request on the server. 1683 */ setTransactionName(name) { 1684 this._transactionName = name; 1685 this._notifyScopeListeners(); 1686 return this; 1687 } 1688 /** 1689 * Sets context data with the given name. 1690 * Data passed as context will be normalized. You can also pass `null` to unset the context. 1691 * Note that context data will not be merged - calling `setContext` will overwrite an existing context with the same key. 1692 */ setContext(key, context) { 1693 if (context === null) { 1694 delete this._contexts[key]; 1695 } else { 1696 this._contexts[key] = context; 1697 } 1698 this._notifyScopeListeners(); 1699 return this; 1700 } 1701 /** 1702 * Set the session for the scope. 1703 */ setSession(session) { 1704 if (!session) { 1705 delete this._session; 1706 } else { 1707 this._session = session; 1708 } 1709 this._notifyScopeListeners(); 1710 return this; 1711 } 1712 /** 1713 * Get the session from the scope. 1714 */ getSession() { 1715 return this._session; 1716 } 1717 /** 1718 * Updates the scope with provided data. Can work in three variations:
1719 * - plain object containing updatable attributes 1720 * - Scope instance that'll extract the attributes from 1721 * - callback function that'll receive the current scope as an argument and allow for modifications 1722 */ update(captureContext) { 1723 if (!captureContext) { 1724 return this; 1725 } 1726 const scopeToMerge = typeof captureContext === "function" ? captureContext(this) : captureContext; 1727 const scopeInstance = scopeToMerge instanceof Scope ? scopeToMerge.getScopeData() : (0, __TURBOPACK__imported__module__453288__["isPlainObject"])(scopeToMerge) ? captureContext : void 0; 1728 const { tags, attributes, extra, user, contexts, level, fingerprint = [], propagationContext, conversationId } = scopeInstance || {}; 1729 this._tags = { 1730 ...this._tags, 1731 ...tags 1732 }; 1733 this._attributes = { 1734 ...this._attributes, 1735 ...attributes 1736 }; 1737 this._extra = { 1738 ...this._extra, 1739 ...extra 1740 }; 1741 this._contexts = { 1742 ...this._contexts, 1743 ...contexts 1744 }; 1745 if (user && Object.keys(user).length) { 1746 this._user = user; 1747 } 1748 if (level) { 1749 this._level = level; 1750 } 1751 if (fingerprint.length) { 1752 this._fingerprint = fingerprint; 1753 } 1754 if (propagationContext) { 1755 this._propagationContext = propagationContext; 1756 } 1757 if (conversationId) { 1758 this._conversationId = conversationId; 1759 } 1760 return this; 1761 } 1762 /** 1763 * Clears the current scope and resets its properties. 1764 * Note: The client will not be cleared. 1765 * 1766 * @deprecated This method will be removed in v11. To reset scope state, re-initialize the SDK or run 1767 * your code in a fresh scope via `withScope` instead. 1768 */ clear() { 1769 this._breadcrumbs = []; 1770 this._tags = {}; 1771 this._attributes = {}; 1772 this._extra = {}; 1773 this._user = {}; 1774 this._contexts = {}; 1775 this._level = void 0; 1776 this._transactionName = void 0; 1777 this._fingerprint = void 0; 1778 this._session = void 0; 1779 this._conversationId = void 0; 1780 _setSpanForScope(this, void 0); 1781 this._attachments = []; 1782 this.setPropagationContext({ 1783 traceId: generateTraceId(), 1784 sampleRand: (0, __TURBOPACK__imported__module__111139__["safeMathRandom"])() 1785 }); 1786 this._notifyScopeListeners(); 1787 return this; 1788 } 1789 /** 1790 * Adds a breadcrumb to the scope. 1791 * By default, the last 100 breadcrumbs are kept. 1792 */ addBreadcrumb(breadcrumb, maxBreadcrumbs) { 1793 const maxCrumbs = typeof maxBreadcrumbs === "number" ? maxBreadcrumbs : DEFAULT_MAX_BREADCRUMBS; 1794 if (maxCrumbs <= 0) { 1795 return this; 1796 } 1797 const mergedBreadcrumb = { 1798 timestamp: (0, __TURBOPACK__imported__module__605394__1["dateTimestampInSeconds"])(), 1799 ...breadcrumb, 1800 // Breadcrumb messages can theoretically be infinitely large and they're held in memory so we truncate them not to leak (too much) memory 1801 message: breadcrumb.message ? (0, __TURBOPACK__imported__module__821593__["truncate"])(breadcrumb.message, 2048) : breadcrumb.message 1802 }; 1803 this._breadcrumbs.push(mergedBreadcrumb); 1804 if (this._breadcrumbs.length > maxCrumbs) { 1805 var _this__client; 1806 this._breadcrumbs = this._breadcrumbs.slice(-maxCrumbs); 1807 (_this__client = this._client) === null || _this__client === void 0 ? void 0 : _this__client.recordDroppedEvent("buffer_overflow", "log_item"); 1808 } 1809 this._notifyScopeListeners(); 1810 return this; 1811 } 1812 /** 1813 * Get the last breadcrumb of the scope. 1814 */ getLastBreadcrumb() { 1815 return this._breadcrumbs[this._breadcrumbs.length - 1]; 1816 } 1817 /** 1818 * Clear all breadcrumbs from the scope. 1819 */ clearBreadcrumbs() { 1820 this._breadcrumbs = []; 1821 this._notifyScopeListeners(); 1822 return this; 1823 } 1824 /** 1825 * Add an attachment to the scope. 1826 */ addAttachment(attachment) { 1827 this._attachments.push(attachment); 1828 return this; 1829 } 1830 /** 1831 * Clear all attachments from the scope. 1832 */ clearAttachments() { 1833 this._attachments = []; 1834 return this; 1835 } 1836 /** 1837 * Get the data of this scope, which should be applied to an event during processing. 1838 */ getScopeData() { 1839 return { 1840 breadcrumbs: this._breadcrumbs, 1841 attachments: this._attachments, 1842 contexts: this._contexts, 1843 tags: this._tags, 1844 attributes: this._attributes, 1845 extra: this._extra, 1846 user: this._user, 1847 level: this._level, 1848 fingerprint: this._fingerprint || [], 1849 eventProcessors: this._eventProcessors, 1850 propagationContext: this._propagationContext, 1851 sdkProcessingMetadata: this._sdkProcessingMetadata, 1852 transactionName: this._transactionName, 1853 span: _getSpanForScope(this), 1854 conversationId: this._conversationId 1855 }; 1856 } 1857 /** 1858 * Add data which will be accessible during event processing but won't get sent to Sentry. 1859 */ setSDKProcessingMetadata(newData) { 1860 this._sdkProcessingMetadata = merge(this._sdkProcessingMetadata, newData, 2); 1861 return this; 1862 } 1863 /** 1864 * Add propagation context to the scope, used for distributed tracing 1865 */ setPropagationContext(context) { 1866 this._propagationContext = context; 1867 return this; 1868 } 1869 /**
1870 * Get propagation context from the scope, used for distributed tracing 1871 */ getPropagationContext() { 1872 return this._propagationContext; 1873 } 1874 /** 1875 * Capture an exception for this scope. 1876 * 1877 * @returns {string} The id of the captured Sentry event. 1878 */ captureException(exception, hint) { 1879 const eventId = (hint === null || hint === void 0 ? void 0 : hint.event_id) || (0, __TURBOPACK__imported__module__682564__1["uuid4"])(); 1880 if (!this._client) { 1881 __TURBOPACK__imported__module__901020__["DEBUG_BUILD"] && __TURBOPACK__imported__module__272598__["debug"].warn("No client configured on scope - will not capture exception!"); 1882 return eventId; 1883 } 1884 const syntheticException = new Error("Sentry syntheticException"); 1885 this._client.captureException(exception, { 1886 originalException: exception, 1887 syntheticException, 1888 ...hint, 1889 event_id: eventId 1890 }, this); 1891 return eventId; 1892 } 1893 /** 1894 * Capture a message for this scope. 1895 * 1896 * @returns {string} The id of the captured message. 1897 */ captureMessage(message, level, hint) { 1898 var _ref; 1899 const eventId = (hint === null || hint === void 0 ? void 0 : hint.event_id) || (0, __TURBOPACK__imported__module__682564__1["uuid4"])(); 1900 if (!this._client) { 1901 __TURBOPACK__imported__module__901020__["DEBUG_BUILD"] && __TURBOPACK__imported__module__272598__["debug"].warn("No client configured on scope - will not capture message!"); 1902 return eventId; 1903 } 1904 const syntheticException = (_ref = hint === null || hint === void 0 ? void 0 : hint.syntheticException) !== null && _ref !== void 0 ? _ref : new Error(message); 1905 this._client.captureMessage(message, level, { 1906 originalException: message, 1907 syntheticException, 1908 ...hint, 1909 event_id: eventId 1910 }, this); 1911 return eventId; 1912 } 1913 /** 1914 * Capture a Sentry event for this scope. 1915 * 1916 * @returns {string} The id of the captured event. 1917 */ captureEvent(event, hint) { 1918 const eventId = event.event_id || (hint === null || hint === void 0 ? void 0 : hint.event_id) || (0, __TURBOPACK__imported__module__682564__1["uuid4"])(); 1919 if (!this._client) { 1920 __TURBOPACK__imported__module__901020__["DEBUG_BUILD"] && __TURBOPACK__imported__module__272598__["debug"].warn("No client configured on scope - will not capture event!"); 1921 return eventId; 1922 } 1923 this._client.captureEvent(event, { 1924 ...hint, 1925 event_id: eventId 1926 }, this); 1927 return eventId; 1928 } 1929 /** 1930 * This will be called on every set call. 1931 */ _notifyScopeListeners() { 1932 if (!this._notifyingListeners) { 1933 this._notifyingListeners = true; 1934 this._scopeListeners.forEach((callback)=>{ 1935 callback(this); 1936 }); 1937 this._notifyingListeners = false; 1938 } 1939 } 1940 // NOTE: Any field which gets added here should get added not only to the constructor but also to the `clone` method. 1941 constructor(){ 1942 this._notifyingListeners = false; 1943 this._scopeListeners = []; 1944 this._eventProcessors = []; 1945 this._breadcrumbs = []; 1946 this._attachments = []; 1947 this._user = {}; 1948 this._tags = {}; 1949 this._attributes = {}; 1950 this._extra = {}; 1951 this._contexts = {}; 1952 this._sdkProcessingMetadata = {}; 1953 this._propagationContext = { 1954 traceId: generateTraceId(), 1955 sampleRand: (0, __TURBOPACK__imported__module__111139__["safeMathRandom"])() 1956 }; 1957 } 1958} 1959; 1960__turbopack_context__.s([ 1961 "Scope", 1962 0, 1963 Scope 1964], 994218); 1965; 1966; 1967function getDefaultCurrentScope() { 1968 return (0, __TURBOPACK__imported__module__923288__1["getGlobalSingleton"])("defaultCurrentScope", ()=>new Scope()); 1969} 1970function getDefaultIsolationScope() { 1971 return (0, __TURBOPACK__imported__module__923288__1["getGlobalSingleton"])("defaultIsolationScope", ()=>new Scope()); 1972} 1973; 1974// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/chain-and-copy-promiselike.js [app-client] (ecmascript) 1975; 1976const isActualPromise = (p)=>p instanceof Promise && !p[kChainedCopy]; 1977const kChainedCopy = /* @__PURE__ */ Symbol("chained PromiseLike"); 1978const chainAndCopyPromiseLike = (original, onSuccess, onError)=>{ 1979 const chained = original.then((value)=>{ 1980 onSuccess(value); 1981 return value; 1982 }, (err)=>{ 1983 onError(err); 1984 throw err; 1985 }); 1986 return isActualPromise(chained) && isActualPromise(original) ? chained : copyProps(original, chained); 1987}; 1988const copyProps = (original, chained)=>{ 1989 if (!chained) return original; 1990 let mutated = false;
1991 for(const key in original){ 1992 if (key in chained) continue; 1993 mutated = true; 1994 const value = original[key]; 1995 if (typeof value === "function") { 1996 Object.defineProperty(chained, key, { 1997 value: function() { 1998 for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){ 1999 args[_key] = arguments[_key]; 2000 } 2001 return value.apply(original, args); 2002 }, 2003 enumerable: true, 2004 configurable: true, 2005 writable: true 2006 }); 2007 } else { 2008 chained[key] = value; 2009 } 2010 } 2011 if (mutated) Object.assign(chained, { 2012 [kChainedCopy]: true 2013 }); 2014 return chained; 2015}; 2016; 2017__turbopack_context__.s([ 2018 "chainAndCopyPromiseLike", 2019 0, 2020 chainAndCopyPromiseLike 2021], 450574); 2022var __TURBOPACK__imported__module__453288__1 = __TURBOPACK__imported__module__453288__; 2023var __TURBOPACK__imported__module__923288__2 = __TURBOPACK__imported__module__923288__; 2024; 2025; 2026; 2027; 2028; 2029class AsyncContextStack { 2030 /** 2031 * Fork a scope for the stack. 2032 */ withScope(callback) { 2033 const scope = this._pushScope(); 2034 let maybePromiseResult; 2035 try { 2036 maybePromiseResult = callback(scope); 2037 } catch (e) { 2038 this._popScope(); 2039 throw e; 2040 } 2041 if ((0, __TURBOPACK__imported__module__453288__1["isThenable"])(maybePromiseResult)) { 2042 return chainAndCopyPromiseLike(maybePromiseResult, ()=>this._popScope(), ()=>this._popScope()); 2043 } 2044 this._popScope(); 2045 return maybePromiseResult; 2046 } 2047 /** 2048 * Get the client of the stack. 2049 */ getClient() { 2050 return this.getStackTop().client; 2051 } 2052 /** 2053 * Returns the scope of the top stack. 2054 */ getScope() { 2055 return this.getStackTop().scope; 2056 } 2057 /** 2058 * Get the isolation scope for the stack. 2059 */ getIsolationScope() { 2060 return this._isolationScope; 2061 } 2062 /** 2063 * Returns the topmost scope layer in the order domain > local > process. 2064 */ getStackTop() { 2065 return this._stack[this._stack.length - 1]; 2066 } 2067 /** 2068 * Push a scope to the stack. 2069 */ _pushScope() { 2070 const scope = this.getScope().clone(); 2071 this._stack.push({ 2072 client: this.getClient(), 2073 scope 2074 }); 2075 return scope; 2076 } 2077 /** 2078 * Pop a scope from the stack. 2079 */ _popScope() { 2080 if (this._stack.length <= 1) return false; 2081 return !!this._stack.pop(); 2082 } 2083 constructor(scope, isolationScope){ 2084 let assignedScope; 2085 if (!scope) { 2086 assignedScope = new Scope(); 2087 } else { 2088 assignedScope = scope; 2089 } 2090 let assignedIsolationScope; 2091 if (!isolationScope) { 2092 assignedIsolationScope = new Scope(); 2093 } else { 2094 assignedIsolationScope = isolationScope; 2095 } 2096 this._stack = [ 2097 { 2098 scope: assignedScope 2099 } 2100 ]; 2101 this._isolationScope = assignedIsolationScope; 2102 } 2103} 2104function getAsyncContextStack() { 2105 const registry = (0, __TURBOPACK__imported__module__923288__2["getMainCarrier"])(); 2106 const sentry = (0, __TURBOPACK__imported__module__923288__2["getSentryCarrier"])(registry); 2107 return sentry.stack = sentry.stack || new AsyncContextStack(getDefaultCurrentScope(), getDefaultIsolationScope()); 2108} 2109function withScope(callback) { 2110 return getAsyncContextStack().withScope(callback); 2111} 2112function withSetScope(scope, callback) { 2113 const stack = getAsyncContextStack(); 2114 return stack.withScope(()=>{ 2115 stack.getStackTop().scope = scope; 2116 return callback(scope); 2117 }); 2118} 2119function withIsolationScope(callback) { 2120 return getAsyncContextStack().withScope(()=>{ 2121 return callback(getAsyncContextStack().getIsolationScope()); 2122 }); 2123} 2124function getStackAsyncContextStrategy() { 2125 return { 2126 withIsolationScope, 2127 withScope, 2128 withSetScope, 2129 withSetIsolationScope: (_isolationScope, callback)=>{ 2130 return withIsolationScope(callback); 2131 }, 2132 getCurrentScope: ()=>getAsyncContextStack().getScope(), 2133 getIsolationScope: ()=>getAsyncContextStack().getIsolationScope() 2134 }; 2135} 2136; 2137; 2138; 2139function setAsyncContextStrategy(strategy) { 2140 const registry = (0, __TURBOPACK__imported__module__923288__["getMainCarrier"])(); 2141 const sentry = (0, __TURBOPACK__imported__module__923288__["getSentryCarrier"])(registry); 2142 sentry.acs = strategy; 2143} 2144function getAsyncContextStrategy(carrier) { 2145 const sentry = (0, __TURBOPACK__imported__module__923288__["getSentryCarrier"])(carrier); 2146 if (sentry.acs) { 2147 return sentry.acs; 2148 } 2149 return getStackAsyncContextStrategy(); 2150} 2151; 2152__turbopack_context__.s([ 2153 "getAsyncContextStrategy", 2154 0, 2155 getAsyncContextStrategy 2156], 301263); 2157var __TURBOPACK__imported__module__923288__3 = __TURBOPACK__imported__module__923288__; 2158; 2159; 2160; 2161; 2162let _externalPropagationContextProvider; 2163function registerExternalPropagationContext(fn) { 2164 _externalPropagationContextProvider = fn; 2165} 2166function getExternalPropagationContext() { 2167 return _externalPropagationContextProvider === null || _externalPropagationContextProvider === void 0 ? void 0 : _externalPropagationContextProvider(); 2168} 2169function hasExternalPropagationContext() { 2170 return _externalPropagationContextProvider !== void 0; 2171} 2172function getCurrentScope() { 2173 const carrier = (0, __TURBOPACK__imported__module__923288__3["getMainCarrier"])(); 2174 const acs = getAsyncContextStrategy(carrier); 2175 return acs.getCurrentScope(); 2176} 2177function getIsolationScope() { 2178 const carrier = (0, __TURBOPACK__imported__module__923288__3["getMainCarrier"])(); 2179 const acs = getAsyncContextStrategy(carrier); 2180 return acs.getIsolationScope(); 2181} 2182function getGlobalScope() { 2183 return (0, __TURBOPACK__imported__module__923288__3["getGlobalSingleton"])("globalScope", ()=>new Scope()); 2184} 2185function withScope1() { 2186 for(var _len = arguments.length, rest = new Array(_len), _key = 0; _key < _len; _key++){ 2187 rest[_key] = arguments[_key]; 2188 } 2189 const carrier = (0, __TURBOPACK__imported__module__923288__3["getMainCarrier"])(); 2190 const acs = getAsyncContextStrategy(carrier); 2191 if (rest.length === 2) { 2192 const [scope, callback] = rest; 2193 if (!scope) { 2194 return acs.withScope(callback); 2195 } 2196 return acs.withSetScope(scope, callback); 2197 } 2198 return acs.withScope(rest[0]); 2199} 2200function withIsolationScope1() { 2201 for(var _len = arguments.length, rest = new Array(_len), _key = 0; _key < _len; _key++){ 2202 rest[_key] = arguments[_key]; 2203 } 2204 const carrier = (0, __TURBOPACK__imported__module__923288__3["getMainCarrier"])(); 2205 const acs = getAsyncContextStrategy(carrier); 2206 if (rest.length === 2) { 2207 const [isolationScope, callback] = rest; 2208 if (!isolationScope) { 2209 return acs.withIsolationScope(callback); 2210 } 2211 return acs.withSetIsolationScope(isolationScope, callback); 2212 } 2213 return acs.withIsolationScope(rest[0]); 2214} 2215function getClient() { 2216 return getCurrentScope().getClient(); 2217} 2218function getTraceContextFromScope(scope) { 2219 const externalContext = getExternalPropagationContext(); 2220 if (externalContext) { 2221 return { 2222 trace_id: externalContext.traceId, 2223 span_id: externalContext.spanId 2224 }; 2225 } 2226 const propagationContext = scope.getPropagationContext(); 2227 const { traceId, parentSpanId, propagationSpanId } = propagationContext; 2228 const traceContext = { 2229 trace_id: traceId, 2230 span_id: propagationSpanId || generateSpanId() 2231 }; 2232 if (parentSpanId) { 2233 traceContext.parent_span_id = parentSpanId; 2234 } 2235 return traceContext; 2236} 2237; 2238__turbopack_context__.s([ 2239 "getClient", 2240 0, 2241 getClient, 2242 "getCurrentScope", 2243 0, 2244 getCurrentScope, 2245 "getGlobalScope", 2246 0, 2247 getGlobalScope, 2248 "getIsolationScope", 2249 0, 2250 getIsolationScope, 2251 "getTraceContextFromScope", 2252 0, 2253 getTraceContextFromScope, 2254 "hasExternalPropagationContext", 2255 0, 2256 hasExternalPropagationContext, 2257 "withScope", 2258 0, 2259 withScope1 2260], 250804); 2261}), 2262]); 2263 2264//# debugId=eee4fc12-1f4b-9c60-cfeb-409879c757ac
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.