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]="22cd0856-04f8-3811-85fb-8844725529e5")}catch(e){}}(); 2(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined, 3754394, ((__turbopack_context__, module, exports) => { 4"use strict"; 5 6Object.defineProperty(exports, "__esModule", { 7 value: true 8}); 90 && (module.exports = { 10 HTTPAccessErrorStatus: null, 11 HTTP_ERROR_FALLBACK_ERROR_CODE: null, 12 getAccessFallbackErrorTypeByStatus: null, 13 getAccessFallbackHTTPStatus: null, 14 isHTTPAccessFallbackError: null 15}); 16function _export(target, all) { 17 for(var name in all)Object.defineProperty(target, name, { 18 enumerable: true, 19 get: all[name] 20 }); 21} 22_export(exports, { 23 HTTPAccessErrorStatus: function() { 24 return HTTPAccessErrorStatus; 25 }, 26 HTTP_ERROR_FALLBACK_ERROR_CODE: function() { 27 return HTTP_ERROR_FALLBACK_ERROR_CODE; 28 }, 29 getAccessFallbackErrorTypeByStatus: function() { 30 return getAccessFallbackErrorTypeByStatus; 31 }, 32 getAccessFallbackHTTPStatus: function() { 33 return getAccessFallbackHTTPStatus; 34 }, 35 isHTTPAccessFallbackError: function() { 36 return isHTTPAccessFallbackError; 37 } 38}); 39const HTTPAccessErrorStatus = { 40 NOT_FOUND: 404, 41 FORBIDDEN: 403, 42 UNAUTHORIZED: 401 43}; 44const ALLOWED_CODES = new Set(Object.values(HTTPAccessErrorStatus)); 45const HTTP_ERROR_FALLBACK_ERROR_CODE = 'NEXT_HTTP_ERROR_FALLBACK'; 46function isHTTPAccessFallbackError(error) { 47 if (typeof error !== 'object' || error === null || !('digest' in error) || typeof error.digest !== 'string') { 48 return false; 49 } 50 const [prefix, httpStatus] = error.digest.split(';'); 51 return prefix === HTTP_ERROR_FALLBACK_ERROR_CODE && ALLOWED_CODES.has(Number(httpStatus)); 52} 53function getAccessFallbackHTTPStatus(error) { 54 const httpStatus = error.digest.split(';')[1]; 55 return Number(httpStatus); 56} 57function getAccessFallbackErrorTypeByStatus(status) { 58 switch(status){ 59 case 401: 60 return 'unauthorized'; 61 case 403: 62 return 'forbidden'; 63 case 404: 64 return 'not-found'; 65 default: 66 return; 67 } 68} 69if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') { 70 Object.defineProperty(exports.default, '__esModule', { 71 value: true 72 }); 73 Object.assign(exports.default, exports); 74 module.exports = exports.default; 75} 76}), 77265713, ((__turbopack_context__, module, exports) => { 78"use strict"; 79 80Object.defineProperty(exports, "__esModule", { 81 value: true 82}); 83Object.defineProperty(exports, "isNextRouterError", { 84 enumerable: true, 85 get: function() { 86 return isNextRouterError; 87 } 88}); 89const _httpaccessfallback = __turbopack_context__.r(754394); 90const _redirecterror = __turbopack_context__.r(968391); 91function isNextRouterError(error) { 92 return (0, _redirecterror.isRedirectError)(error) || (0, _httpaccessfallback.isHTTPAccessFallbackError)(error); 93} 94if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') { 95 Object.defineProperty(exports.default, '__esModule', { 96 value: true 97 }); 98 Object.assign(exports.default, exports); 99 module.exports = exports.default; 100} 101}), 102903680, ((__turbopack_context__, module, exports) => { 103"use strict"; 104 105/** 106 * ReadonlyURLSearchParams implementation shared between client and server. 107 * This file is intentionally not marked as 'use client' or 'use server' 108 * so it can be imported by both environments. 109 */ /** @internal */ Object.defineProperty(exports, "__esModule", { 110 value: true 111}); 112Object.defineProperty(exports, "ReadonlyURLSearchParams", { 113 enumerable: true, 114 get: function() { 115 return ReadonlyURLSearchParams; 116 } 117});
118class ReadonlyURLSearchParamsError extends Error { 119 constructor(){ 120 super('Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams'); 121 } 122} 123class ReadonlyURLSearchParams extends URLSearchParams { 124 /** @deprecated Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams */ append() { 125 throw new ReadonlyURLSearchParamsError(); 126 } 127 /** @deprecated Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams */ delete() { 128 throw new ReadonlyURLSearchParamsError(); 129 } 130 /** @deprecated Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams */ set() { 131 throw new ReadonlyURLSearchParamsError(); 132 } 133 /** @deprecated Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams */ sort() { 134 throw new ReadonlyURLSearchParamsError(); 135 } 136} 137if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') { 138 Object.defineProperty(exports.default, '__esModule', { 139 value: true 140 }); 141 Object.assign(exports.default, exports); 142 module.exports = exports.default; 143} 144}), 14547790, ((__turbopack_context__, module, exports) => { 146"use strict"; 147 148var __TURBOPACK__imported__module__247167__ = /*#__PURE__*/ __turbopack_context__.i(247167); 149'use client'; 150"use strict"; 151Object.defineProperty(exports, "__esModule", { 152 value: true 153}); 1540 && (module.exports = { 155 NavigationPromisesContext: null, 156 PathParamsContext: null, 157 PathnameContext: null, 158 ReadonlyURLSearchParams: null, 159 SearchParamsContext: null, 160 createDevToolsInstrumentedPromise: null 161}); 162function _export(target, all) { 163 for(var name in all)Object.defineProperty(target, name, { 164 enumerable: true, 165 get: all[name] 166 }); 167} 168_export(exports, { 169 NavigationPromisesContext: function() { 170 return NavigationPromisesContext; 171 }, 172 PathParamsContext: function() { 173 return PathParamsContext; 174 }, 175 PathnameContext: function() { 176 return PathnameContext; 177 }, 178 ReadonlyURLSearchParams: function() { 179 return _readonlyurlsearchparams.ReadonlyURLSearchParams; 180 }, 181 SearchParamsContext: function() { 182 return SearchParamsContext; 183 }, 184 createDevToolsInstrumentedPromise: function() { 185 return createDevToolsInstrumentedPromise; 186 } 187}); 188const _react = __turbopack_context__.r(271645); 189const _readonlyurlsearchparams = __turbopack_context__.r(903680); 190const SearchParamsContext = (0, _react.createContext)(null); 191const PathnameContext = (0, _react.createContext)(null); 192const PathParamsContext = (0, _react.createContext)(null); 193const NavigationPromisesContext = (0, _react.createContext)(null); 194function createDevToolsInstrumentedPromise(displayName, value) { 195 const promise = Promise.resolve(value); 196 promise.status = 'fulfilled'; 197 promise.value = value; 198 promise.displayName = "".concat(displayName, " (SSR)"); 199 return promise; 200} 201if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable 202; 203}), 204245955, ((__turbopack_context__, module, exports) => { 205"use strict"; 206 207Object.defineProperty(exports, "__esModule", { 208 value: true 209}); 210Object.defineProperty(exports, "workUnitAsyncStorageInstance", { 211 enumerable: true, 212 get: function() { 213 return workUnitAsyncStorageInstance; 214 } 215}); 216const _asynclocalstorage = __turbopack_context__.r(90317); 217const workUnitAsyncStorageInstance = (0, _asynclocalstorage.createAsyncLocalStorage)(); 218}), 219142852, ((__turbopack_context__, module, exports) => { 220"use strict"; 221 222Object.defineProperty(exports, "__esModule", { 223 value: true 224}); 2250 && (module.exports = { 226 RenderStage: null, 227 StagedRenderingController: null 228}); 229function _export(target, all) { 230 for(var name in all)Object.defineProperty(target, name, { 231 enumerable: true, 232 get: all[name] 233 }); 234} 235_export(exports, { 236 RenderStage: function() { 237 return RenderStage; 238 }, 239 StagedRenderingController: function() { 240 return StagedRenderingController; 241 } 242}); 243const _invarianterror = __turbopack_context__.r(312718); 244const _promisewithresolvers = __turbopack_context__.r(839470); 245var RenderStage = /*#__PURE__*/ function(RenderStage) { 246 RenderStage[RenderStage["Before"] = 1] = "Before"; 247 RenderStage[RenderStage["EarlyStatic"] = 2] = "EarlyStatic"; 248 RenderStage[RenderStage["Static"] = 3] = "Static";
249 RenderStage[RenderStage["EarlyRuntime"] = 4] = "EarlyRuntime"; 250 RenderStage[RenderStage["Runtime"] = 5] = "Runtime"; 251 RenderStage[RenderStage["Dynamic"] = 6] = "Dynamic"; 252 RenderStage[RenderStage["Abandoned"] = 7] = "Abandoned"; 253 return RenderStage; 254}({}); 255class StagedRenderingController { 256 onStage(stage, callback) { 257 if (this.currentStage >= stage) { 258 callback(); 259 } else if (stage === 3) { 260 this.staticStageListeners.push(callback); 261 } else if (stage === 4) { 262 this.earlyRuntimeStageListeners.push(callback); 263 } else if (stage === 5) { 264 this.runtimeStageListeners.push(callback); 265 } else if (stage === 6) { 266 this.dynamicStageListeners.push(callback); 267 } else { 268 // This should never happen 269 throw Object.defineProperty(new _invarianterror.InvariantError("Invalid render stage: ".concat(stage)), "__NEXT_ERROR_CODE", { 270 value: "E881", 271 enumerable: false, 272 configurable: true 273 }); 274 } 275 } 276 shouldTrackSyncInterrupt() { 277 if (!this.shouldTrackSyncIO) { 278 return false; 279 } 280 switch(this.currentStage){ 281 case 1: 282 // If we haven't started the render yet, it can't be interrupted. 283 return false; 284 case 2: 285 case 3: 286 return true; 287 case 4: 288 // EarlyRuntime is for runtime-prefetchable segments. Sync IO 289 // should error because it would abort a runtime prefetch. 290 return true; 291 case 5: 292 // Runtime is for non-prefetchable segments. Sync IO is fine there 293 // because in practice this segment will never be runtime prefetched 294 return false; 295 case 6: 296 case 7: 297 return false; 298 default: 299 return false; 300 } 301 } 302 syncInterruptCurrentStageWithReason(reason) { 303 if (this.currentStage === 1) { 304 return; 305 } 306 // If the render has already been abandoned, there's nothing to interrupt. 307 if (this.currentStage === 7) { 308 return; 309 } 310 // If Sync IO occurs during an abandonable render, we trigger the abandon. 311 // The abandon listener will call abandonRender which advances through 312 // stages to let caches fill before marking as Abandoned. 313 if (this.abandonController) { 314 this.abandonController.abort(); 315 return; 316 } 317 if (this.abortSignal) { 318 // If this is an abortable render, we capture the interruption reason and stop advancing. 319 // We don't release any more promises. 320 // The caller is expected to abort the signal. 321 this.syncInterruptReason = reason; 322 this.currentStage = 7; 323 return; 324 } 325 // If we're in a non-abandonable & non-abortable render, 326 // we need to advance to the Dynamic stage and capture the interruption reason. 327 // (in dev, this will be the restarted render) 328 switch(this.currentStage){ 329 case 2: 330 case 3: 331 case 4: 332 { 333 // EarlyRuntime is for runtime-prefetchable segments. Sync IO here 334 // means the prefetch would be aborted too early. 335 this.syncInterruptReason = reason; 336 this.advanceStage(6); 337 return; 338 } 339 case 5: 340 { 341 // canSyncInterrupt returns false for Runtime, so we should 342 // never get here. Defensive no-op. 343 return; 344 } 345 case 6: 346 default: 347 } 348 } 349 getSyncInterruptReason() { 350 return this.syncInterruptReason; 351 } 352 getStaticStageEndTime() { 353 return this.staticStageEndTime; 354 } 355 getRuntimeStageEndTime() { 356 return this.runtimeStageEndTime; 357 } 358 abandonRender() { 359 // In staged rendering, only the initial render is abandonable. 360 // We can abandon the initial render if 361 // 1. We notice a cache miss, and need to wait for caches to fill 362 // 2. A sync IO error occurs, and the render should be interrupted 363 // (this might be a lazy intitialization of a module, 364 // so we still want to restart in this case and see if it still occurs) 365 // In either case, we'll be doing another render after this one, 366 // so we only want to unblock the next stage, not Dynamic, because 367 // unblocking the dynamic stage would likely lead to wasted (uncached) IO. 368 const { currentStage } = this; 369 switch(currentStage){ 370 case 2: 371 { 372 this.resolveStaticStage(); 373 } 374 // intentional fallthrough 375 case 3: 376 { 377 this.resolveEarlyRuntimeStage(); 378 } 379 // intentional fallthrough 380 case 4: 381 { 382 this.resolveRuntimeStage(); 383 } 384 // intentional fallthrough 385 case 5: 386 { 387 this.currentStage = 7; 388 return; 389 } 390 case 6: 391 case 1: 392 case 7: 393 break; 394 default: 395 { 396 currentStage; 397 } 398 } 399 } 400 advanceStage(stage) { 401 // If we're already at the target stage or beyond, do nothing. 402 // (this can happen e.g. if sync IO advanced us to the dynamic stage) 403 if (stage <= this.currentStage) { 404 return; 405 } 406 let currentStage = this.currentStage; 407 this.currentStage = stage; 408 if (currentStage < 3 && stage >= 3) { 409 this.resolveStaticStage(); 410 } 411 if (currentStage < 4 && stage >= 4) { 412 this.resolveEarlyRuntimeStage(); 413 } 414 if (currentStage < 5 && stage >= 5) { 415 this.staticStageEndTime = performance.now() + performance.timeOrigin; 416 this.resolveRuntimeStage(); 417 } 418 if (currentStage < 6 && stage >= 6) { 419 this.runtimeStageEndTime = performance.now() + performance.timeOrigin; 420 this.resolveDynamicStage(); 421 return; 422 } 423 } 424 /** Fire the `onStage` listeners for the static stage and unblock any promises waiting for it. */ resolveStaticStage() { 425 const staticListeners = this.staticStageListeners; 426 for(let i = 0; i < staticListeners.length; i++){ 427 staticListeners[i](); 428 } 429 staticListeners.length = 0; 430 this.staticStagePromise.resolve(); 431 } 432 /** Fire the `onStage` listeners for the early runtime stage and unblock any promises waiting for it. */ resolveEarlyRuntimeStage() { 433 const earlyRuntimeListeners = this.earlyRuntimeStageListeners; 434 for(let i = 0; i < earlyRuntimeListeners.length; i++){ 435 earlyRuntimeListeners[i](); 436 } 437 earlyRuntimeListeners.length = 0; 438 this.earlyRuntimeStagePromise.resolve(); 439 } 440 /** Fire the `onStage` listeners for the runtime stage and unblock any promises waiting for it. */ resolveRuntimeStage() { 441 const runtimeListeners = this.runtimeStageListeners; 442 for(let i = 0; i < runtimeListeners.length; i++){ 443 runtimeListeners[i](); 444 } 445 runtimeListeners.length = 0; 446 this.runtimeStagePromise.resolve(); 447 } 448 /** Fire the `onStage` listeners for the dynamic stage and unblock any promises waiting for it. */ resolveDynamicStage() { 449 const dynamicListeners = this.dynamicStageListeners; 450 for(let i = 0; i < dynamicListeners.length; i++){ 451 dynamicListeners[i](); 452 } 453 dynamicListeners.length = 0; 454 this.dynamicStagePromise.resolve(); 455 } 456 getStagePromise(stage) { 457 switch(stage){ 458 case 3: 459 { 460 return this.staticStagePromise.promise; 461 } 462 case 4: 463 { 464 return this.earlyRuntimeStagePromise.promise; 465 } 466 case 5: 467 { 468 return this.runtimeStagePromise.promise; 469 } 470 case 6: 471 { 472 return this.dynamicStagePromise.promise; 473 } 474 default: 475 { 476 stage; 477 throw Object.defineProperty(new _invarianterror.InvariantError("Invalid render stage: ".concat(stage)), "__NEXT_ERROR_CODE", { 478 value: "E881", 479 enumerable: false, 480 configurable: true 481 }); 482 } 483 } 484 } 485 waitForStage(stage) {
486 return this.getStagePromise(stage); 487 } 488 delayUntilStage(stage, displayName, resolvedValue) { 489 const ioTriggerPromise = this.getStagePromise(stage); 490 const promise = makeDevtoolsIOPromiseFromIOTrigger(ioTriggerPromise, displayName, resolvedValue); 491 // Analogously to `makeHangingPromise`, we might reject this promise if the signal is invoked. 492 // (e.g. in the case where we don't want want the render to proceed to the dynamic stage and abort it). 493 // We shouldn't consider this an unhandled rejection, so we attach a noop catch handler here to suppress this warning. 494 if (this.abortSignal) { 495 promise.catch(ignoreReject); 496 } 497 return promise; 498 } 499 constructor(abortSignal, abandonController, shouldTrackSyncIO){ 500 this.abortSignal = abortSignal; 501 this.abandonController = abandonController; 502 this.shouldTrackSyncIO = shouldTrackSyncIO; 503 this.currentStage = 1; 504 this.syncInterruptReason = null; 505 this.staticStageEndTime = Infinity; 506 this.runtimeStageEndTime = Infinity; 507 this.staticStageListeners = []; 508 this.earlyRuntimeStageListeners = []; 509 this.runtimeStageListeners = []; 510 this.dynamicStageListeners = []; 511 this.staticStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)(); 512 this.earlyRuntimeStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)(); 513 this.runtimeStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)(); 514 this.dynamicStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)(); 515 if (abortSignal) { 516 abortSignal.addEventListener('abort', ()=>{ 517 // Reject all stage promises that haven't already been resolved. 518 // If a promise was already resolved via advanceStage, the reject 519 // is a no-op. The ignoreReject handler suppresses unhandled 520 // rejection warnings for promises that no one is awaiting. 521 const { reason } = abortSignal; 522 this.staticStagePromise.promise.catch(ignoreReject); 523 this.staticStagePromise.reject(reason); 524 this.earlyRuntimeStagePromise.promise.catch(ignoreReject); 525 this.earlyRuntimeStagePromise.reject(reason); 526 this.runtimeStagePromise.promise.catch(ignoreReject); 527 this.runtimeStagePromise.reject(reason); 528 this.dynamicStagePromise.promise.catch(ignoreReject); 529 this.dynamicStagePromise.reject(reason); 530 }, { 531 once: true 532 }); 533 } 534 if (abandonController) { 535 abandonController.signal.addEventListener('abort', ()=>{ 536 this.abandonRender(); 537 }, { 538 once: true 539 }); 540 } 541 } 542} 543function ignoreReject() {} 544// TODO(restart-on-cache-miss): the layering of `delayUntilStage`, 545// `makeDevtoolsIOPromiseFromIOTrigger` and and `makeDevtoolsIOAwarePromise` 546// is confusing, we should clean it up. 547function makeDevtoolsIOPromiseFromIOTrigger(ioTrigger, displayName, resolvedValue) { 548 // If we create a `new Promise` and give it a displayName 549 // (with no userspace code above us in the stack) 550 // React Devtools will use it as the IO cause when determining "suspended by". 551 // In particular, it should shadow any inner IO that resolved/rejected the promise 552 // (in case of staged rendering, this will be the `setTimeout` that triggers the relevant stage) 553 const promise = new Promise((resolve, reject)=>{ 554 ioTrigger.then(resolve.bind(null, resolvedValue), reject); 555 }); 556 if (displayName !== undefined) { 557 // @ts-expect-error 558 promise.displayName = displayName; 559 } 560 return promise; 561} 562}), 563662141, ((__turbopack_context__, module, exports) => { 564"use strict"; 565 566var __TURBOPACK__imported__module__247167__ = /*#__PURE__*/ __turbopack_context__.i(247167); 567"use strict"; 568Object.defineProperty(exports, "__esModule", { 569 value: true 570}); 5710 && (module.exports = { 572 getCacheSignal: null, 573 getDraftModeProviderForCacheScope: null, 574 getHmrRefreshHash: null, 575 getPrerenderResumeDataCache: null, 576 getRenderResumeDataCache: null, 577 getServerComponentsHmrCache: null, 578 getStagedRenderingController: null, 579 isHmrRefresh: null, 580 isInEarlyRenderStage: null, 581 throwForMissingRequestStore: null, 582 throwInvariantForMissingStore: null, 583 workUnitAsyncStorage: null 584}); 585function _export(target, all) { 586 for(var name in all)Object.defineProperty(target, name, { 587 enumerable: true, 588 get: all[name] 589 }); 590} 591_export(exports, { 592 getCacheSignal: function() { 593 return getCacheSignal; 594 }, 595 getDraftModeProviderForCacheScope: function() { 596 return getDraftModeProviderForCacheScope; 597 }, 598 getHmrRefreshHash: function() { 599 return getHmrRefreshHash; 600 }, 601 getPrerenderResumeDataCache: function() { 602 return getPrerenderResumeDataCache; 603 }, 604 getRenderResumeDataCache: function() { 605 return getRenderResumeDataCache; 606 }, 607 getServerComponentsHmrCache: function() { 608 return getServerComponentsHmrCache;
609 }, 610 getStagedRenderingController: function() { 611 return getStagedRenderingController; 612 }, 613 isHmrRefresh: function() { 614 return isHmrRefresh; 615 }, 616 isInEarlyRenderStage: function() { 617 return isInEarlyRenderStage; 618 }, 619 throwForMissingRequestStore: function() { 620 return throwForMissingRequestStore; 621 }, 622 throwInvariantForMissingStore: function() { 623 return throwInvariantForMissingStore; 624 }, 625 workUnitAsyncStorage: function() { 626 return _workunitasyncstorageinstance.workUnitAsyncStorageInstance; 627 } 628}); 629const _workunitasyncstorageinstance = __turbopack_context__.r(245955); 630const _approuterheaders = __turbopack_context__.r(621768); 631const _invarianterror = __turbopack_context__.r(312718); 632const _stagedrendering = __turbopack_context__.r(142852); 633function isInEarlyRenderStage(requestStore) { 634 const stagedRendering = requestStore.stagedRendering; 635 if (stagedRendering) { 636 return stagedRendering.currentStage === _stagedrendering.RenderStage.EarlyStatic || stagedRendering.currentStage === _stagedrendering.RenderStage.EarlyRuntime; 637 } 638 return false; 639} 640function throwForMissingRequestStore(callingExpression) { 641 throw Object.defineProperty(new Error("`".concat(callingExpression, "` was called outside a request scope. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context")), "__NEXT_ERROR_CODE", { 642 value: "E251", 643 enumerable: false, 644 configurable: true 645 }); 646} 647function throwInvariantForMissingStore() { 648 throw Object.defineProperty(new _invarianterror.InvariantError('Expected workUnitAsyncStorage to have a store.'), "__NEXT_ERROR_CODE", { 649 value: "E696", 650 enumerable: false, 651 configurable: true 652 }); 653} 654function getPrerenderResumeDataCache(workUnitStore) { 655 switch(workUnitStore.type){ 656 case 'prerender': 657 case 'prerender-runtime': 658 case 'prerender-ppr': 659 return workUnitStore.prerenderResumeDataCache; 660 case 'prerender-client': 661 case 'validation-client': 662 // TODO eliminate fetch caching in client scope and stop exposing this data 663 // cache during SSR. 664 return workUnitStore.prerenderResumeDataCache; 665 case 'request': 666 { 667 // In dev, we might fill caches even during a dynamic request. 668 if (workUnitStore.prerenderResumeDataCache) { 669 return workUnitStore.prerenderResumeDataCache; 670 } 671 // fallthrough 672 } 673 case 'prerender-legacy': 674 case 'cache': 675 case 'private-cache': 676 case 'unstable-cache': 677 case 'generate-static-params': 678 return null; 679 default: 680 return workUnitStore; 681 } 682} 683function getRenderResumeDataCache(workUnitStore) { 684 switch(workUnitStore.type){ 685 case 'request': 686 case 'prerender': 687 case 'prerender-runtime': 688 case 'prerender-client': 689 case 'validation-client': 690 if (workUnitStore.renderResumeDataCache) { 691 // If we are in a prerender, we might have a render resume data cache 692 // that is used to read from prefilled caches. 693 return workUnitStore.renderResumeDataCache; 694 } 695 // fallthrough 696 case 'prerender-ppr': 697 var _workUnitStore_prerenderResumeDataCache; 698 // Otherwise we return the mutable resume data cache here as an immutable 699 // version of the cache as it can also be used for reading. 700 return (_workUnitStore_prerenderResumeDataCache = workUnitStore.prerenderResumeDataCache) !== null && _workUnitStore_prerenderResumeDataCache !== void 0 ? _workUnitStore_prerenderResumeDataCache : null; 701 case 'cache': 702 case 'private-cache': 703 case 'unstable-cache': 704 case 'prerender-legacy': 705 case 'generate-static-params': 706 return null; 707 default: 708 return workUnitStore; 709 } 710} 711function getHmrRefreshHash(workUnitStore) { 712 if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable 713 { 714 var _workUnitStore_cookies_get; 715 /*TURBOPACK member replacement*/ } 716 return undefined; 717} 718function isHmrRefresh(workUnitStore) { 719 if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable 720 { 721 var _workUnitStore_isHmrRefresh; 722 } 723 return false;
724} 725function getServerComponentsHmrCache(workUnitStore) { 726 if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable 727 ; 728 return undefined; 729} 730function getDraftModeProviderForCacheScope(workStore, workUnitStore) { 731 if (workStore.isDraftMode) { 732 switch(workUnitStore.type){ 733 case 'cache': 734 case 'private-cache': 735 case 'unstable-cache': 736 case 'prerender-runtime': 737 case 'request': 738 return workUnitStore.draftMode; 739 case 'prerender': 740 case 'prerender-client': 741 case 'validation-client': 742 case 'prerender-ppr': 743 case 'prerender-legacy': 744 case 'generate-static-params': 745 break; 746 default: 747 workUnitStore; 748 } 749 } 750 return undefined; 751} 752function getStagedRenderingController(workUnitStore) { 753 switch(workUnitStore.type){ 754 case 'request': 755 case 'prerender-runtime': 756 var _workUnitStore_stagedRendering; 757 return (_workUnitStore_stagedRendering = workUnitStore.stagedRendering) !== null && _workUnitStore_stagedRendering !== void 0 ? _workUnitStore_stagedRendering : null; 758 case 'prerender': 759 case 'prerender-client': 760 case 'validation-client': 761 case 'prerender-ppr': 762 case 'prerender-legacy': 763 case 'cache': 764 case 'private-cache': 765 case 'unstable-cache': 766 case 'generate-static-params': 767 return null; 768 default: 769 return workUnitStore; 770 } 771} 772function getCacheSignal(workUnitStore) { 773 switch(workUnitStore.type){ 774 case 'prerender': 775 case 'prerender-client': 776 case 'validation-client': 777 case 'prerender-runtime': 778 return workUnitStore.cacheSignal; 779 case 'request': 780 { 781 // In dev, we might fill caches even during a dynamic request. 782 if (workUnitStore.cacheSignal) { 783 return workUnitStore.cacheSignal; 784 } 785 // fallthrough 786 } 787 case 'prerender-ppr': 788 case 'prerender-legacy': 789 case 'cache': 790 case 'private-cache': 791 case 'unstable-cache': 792 case 'generate-static-params': 793 return null; 794 default: 795 return workUnitStore; 796 } 797} 798}), 799242344, ((__turbopack_context__, module, exports) => { 800"use strict"; 801 802Object.defineProperty(exports, "__esModule", { 803 value: true 804}); 805Object.defineProperty(exports, "workAsyncStorageInstance", { 806 enumerable: true, 807 get: function() { 808 return workAsyncStorageInstance; 809 } 810}); 811const _asynclocalstorage = __turbopack_context__.r(90317); 812const workAsyncStorageInstance = (0, _asynclocalstorage.createAsyncLocalStorage)(); 813}), 814563599, ((__turbopack_context__, module, exports) => { 815"use strict"; 816 817Object.defineProperty(exports, "__esModule", { 818 value: true 819}); 820Object.defineProperty(exports, "workAsyncStorage", { 821 enumerable: true, 822 get: function() { 823 return _workasyncstorageinstance.workAsyncStorageInstance; 824 } 825}); 826const _workasyncstorageinstance = __turbopack_context__.r(242344); 827}), 828590373, ((__turbopack_context__, module, exports) => { 829"use strict"; 830 831Object.defineProperty(exports, "__esModule", { 832 value: true 833}); 834Object.defineProperty(exports, "useUntrackedPathname", { 835 enumerable: true, 836 get: function() { 837 return useUntrackedPathname; 838 } 839}); 840const _react = __turbopack_context__.r(271645); 841const _hooksclientcontextsharedruntime = __turbopack_context__.r(47790); 842/** 843 * This checks to see if the current render has any unknown route parameters that 844 * would cause the pathname to be dynamic. It's used to trigger a different 845 * render path in the error boundary. 846 * 847 * @returns true if there are any unknown route parameters, false otherwise 848 */ function hasFallbackRouteParams() { 849 if (typeof window === 'undefined') { 850 // AsyncLocalStorage should not be included in the client bundle. 851 const { workUnitAsyncStorage } = __turbopack_context__.r(662141); 852 const workUnitStore = workUnitAsyncStorage.getStore(); 853 if (!workUnitStore) return false;
854 switch(workUnitStore.type){ 855 case 'prerender': 856 case 'prerender-client': 857 case 'prerender-ppr': 858 case 'validation-client': 859 const fallbackParams = workUnitStore.fallbackRouteParams; 860 return fallbackParams ? fallbackParams.size > 0 : false; 861 case 'prerender-legacy': 862 case 'request': 863 case 'prerender-runtime': 864 case 'cache': 865 case 'private-cache': 866 case 'unstable-cache': 867 case 'generate-static-params': 868 break; 869 default: 870 workUnitStore; 871 } 872 return false; 873 } 874 return false; 875} 876function useUntrackedPathname() { 877 // If there are any unknown route parameters we would typically throw 878 // an error, but this internal method allows us to return a null value instead 879 // for components that do not propagate the pathname to the static shell (like 880 // the error boundary). 881 if (hasFallbackRouteParams()) { 882 return null; 883 } 884 // This shouldn't cause any issues related to conditional rendering because 885 // the environment will be consistent for the render. 886 // eslint-disable-next-line react-hooks/rules-of-hooks 887 return (0, _react.useContext)(_hooksclientcontextsharedruntime.PathnameContext); 888} 889if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') { 890 Object.defineProperty(exports.default, '__esModule', { 891 value: true 892 }); 893 Object.assign(exports.default, exports); 894 module.exports = exports.default; 895} 896}), 897178377, ((__turbopack_context__, module, exports) => { 898"use strict"; 899 900var __TURBOPACK__imported__module__247167__ = /*#__PURE__*/ __turbopack_context__.i(247167); 901"use strict"; 902Object.defineProperty(exports, "__esModule", { 903 value: true 904}); 9050 && (module.exports = { 906 handleHardNavError: null, 907 useNavFailureHandler: null 908}); 909function _export(target, all) { 910 for(var name in all)Object.defineProperty(target, name, { 911 enumerable: true, 912 get: all[name] 913 }); 914} 915_export(exports, { 916 handleHardNavError: function() { 917 return handleHardNavError; 918 }, 919 useNavFailureHandler: function() { 920 return useNavFailureHandler; 921 } 922}); 923const _react = __turbopack_context__.r(271645); 924const _createhreffromurl = __turbopack_context__.r(451191); 925function handleHardNavError(error) { 926 if (error && typeof window !== 'undefined' && window.next.__pendingUrl && (0, _createhreffromurl.createHrefFromUrl)(new URL(window.location.href)) !== (0, _createhreffromurl.createHrefFromUrl)(window.next.__pendingUrl)) { 927 console.error("Error occurred during navigation, falling back to hard navigation", error); 928 window.location.href = window.next.__pendingUrl.toString(); 929 return true; 930 } 931 return false; 932} 933function useNavFailureHandler() { 934 if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable 935 ; 936} 937if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') { 938 Object.defineProperty(exports.default, '__esModule', { 939 value: true 940 }); 941 Object.assign(exports.default, exports); 942 module.exports = exports.default; 943} 944}), 945912354, ((__turbopack_context__, module, exports) => { 946"use strict"; 947 948Object.defineProperty(exports, "__esModule", { 949 value: true 950}); 951Object.defineProperty(exports, "handleISRError", { 952 enumerable: true, 953 get: function() { 954 return handleISRError; 955 } 956}); 957const workAsyncStorage = typeof window === 'undefined' ? __turbopack_context__.r(563599).workAsyncStorage : undefined; 958function handleISRError(param) { 959 let { error } = param; 960 if (workAsyncStorage) { 961 const store = workAsyncStorage.getStore(); 962 if (store === null || store === void 0 ? void 0 : store.isStaticGeneration) { 963 if (error) { 964 console.error(error); 965 } 966 throw error; 967 } 968 } 969} 970if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') { 971 Object.defineProperty(exports.default, '__esModule', { 972 value: true 973 });
974 Object.assign(exports.default, exports); 975 module.exports = exports.default; 976} 977}), 978972383, ((__turbopack_context__, module, exports) => { 979"use strict"; 980 981var __TURBOPACK__imported__module__247167__ = /*#__PURE__*/ __turbopack_context__.i(247167); 982'use client'; 983"use strict"; 984Object.defineProperty(exports, "__esModule", { 985 value: true 986}); 9870 && (module.exports = { 988 ErrorBoundary: null, 989 ErrorBoundaryHandler: null 990}); 991function _export(target, all) { 992 for(var name in all)Object.defineProperty(target, name, { 993 enumerable: true, 994 get: all[name] 995 }); 996} 997_export(exports, { 998 ErrorBoundary: function() { 999 return ErrorBoundary; 1000 }, 1001 ErrorBoundaryHandler: function() { 1002 return ErrorBoundaryHandler; 1003 } 1004}); 1005const _interop_require_wildcard = __turbopack_context__.r(151836); 1006const _jsxruntime = __turbopack_context__.r(843476); 1007const _react = /*#__PURE__*/ _interop_require_wildcard._(__turbopack_context__.r(271645)); 1008const _navigationuntracked = __turbopack_context__.r(590373); 1009const _isnextroutererror = __turbopack_context__.r(265713); 1010const _navfailurehandler = __turbopack_context__.r(178377); 1011const _handleisrerror = __turbopack_context__.r(912354); 1012const _isbot = __turbopack_context__.r(82604); 1013const _approutercontextsharedruntime = __turbopack_context__.r(8372); 1014const isBotUserAgent = typeof window !== 'undefined' && (0, _isbot.isBot)(window.navigator.userAgent); 1015class ErrorBoundaryHandler extends _react.default.Component { 1016 static getDerivedStateFromError(error) { 1017 if ((0, _isnextroutererror.isNextRouterError)(error)) { 1018 // Re-throw if an expected internal Next.js router error occurs 1019 // this means it should be handled by a different boundary (such as a NotFound boundary in a parent segment) 1020 throw error; 1021 } 1022 return { 1023 error 1024 }; 1025 } 1026 static getDerivedStateFromProps(props, state) { 1027 const { error } = state; 1028 // if we encounter an error while 1029 // a navigation is pending we shouldn't render 1030 // the error boundary and instead should fallback 1031 // to a hard navigation to attempt recovering 1032 if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable 1033 ; 1034 /** 1035 * Handles reset of the error boundary when a navigation happens. 1036 * Ensures the error boundary does not stay enabled when navigating to a new page. 1037 * Approach of setState in render is safe as it checks the previous pathname and then overrides 1038 * it as outlined in https://react.dev/reference/react/useState#storing-information-from-previous-renders 1039 */ if (props.pathname !== state.previousPathname && state.error) { 1040 return { 1041 error: null, 1042 previousPathname: props.pathname 1043 }; 1044 } 1045 return { 1046 error: state.error, 1047 previousPathname: props.pathname 1048 }; 1049 } 1050 // Explicit type is needed to avoid the generated `.d.ts` having a wide return type that could be specific to the `@types/react` version. 1051 render() { 1052 //When it's bot request, segment level error boundary will keep rendering the children, 1053 // the final error will be caught by the root error boundary and determine wether need to apply graceful degrade. 1054 if (this.state.error && !isBotUserAgent) { 1055 (0, _handleisrerror.handleISRError)({ 1056 error: this.state.error 1057 }); 1058 return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, { 1059 children: [ 1060 this.props.errorStyles, 1061 this.props.errorScripts, 1062 /*#__PURE__*/ (0, _jsxruntime.jsx)(this.props.errorComponent, { 1063 error: this.state.error, 1064 reset: this.reset, 1065 unstable_retry: this.unstable_retry 1066 }) 1067 ] 1068 }); 1069 } 1070 return this.props.children; 1071 } 1072 constructor(props){ 1073 super(props), this.reset = ()=>{ 1074 this.setState({ 1075 error: null 1076 }); 1077 }, this.unstable_retry = ()=>{ 1078 (0, _react.startTransition)(()=>{ 1079 var _this_context; 1080 (_this_context = this.context) === null || _this_context === void 0 ? void 0 : _this_context.refresh(); 1081 this.reset(); 1082 }); 1083 }; 1084 this.state = { 1085 error: null, 1086 previousPathname: this.props.pathname 1087 }; 1088 } 1089} 1090ErrorBoundaryHandler.contextType = _approutercontextsharedruntime.AppRouterContext; 1091function ErrorBoundary(param) { 1092 let { errorComponent, errorStyles, errorScripts, children } = param; 1093 // When we're rendering the missing params shell, this will return null. This 1094 // is because we won't be rendering any not found boundaries or error 1095 // boundaries for the missing params shell. When this runs on the client 1096 // (where these errors can occur), we will get the correct pathname. 1097 const pathname = (0, _navigationuntracked.useUntrackedPathname)(); 1098 if (errorComponent) { 1099 return /*#__PURE__*/ (0, _jsxruntime.jsx)(ErrorBoundaryHandler, { 1100 pathname: pathname, 1101 errorComponent: errorComponent, 1102 errorStyles: errorStyles, 1103 errorScripts: errorScripts, 1104 children: children 1105 }); 1106 }
1107 return /*#__PURE__*/ (0, _jsxruntime.jsx)(_jsxruntime.Fragment, { 1108 children: children 1109 }); 1110} 1111if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') { 1112 Object.defineProperty(exports.default, '__esModule', { 1113 value: true 1114 }); 1115 Object.assign(exports.default, exports); 1116 module.exports = exports.default; 1117} 1118}), 1119358442, ((__turbopack_context__, module, exports) => { 1120"use strict"; 1121 1122Object.defineProperty(exports, "__esModule", { 1123 value: true 1124}); 11250 && (module.exports = { 1126 RedirectBoundary: null, 1127 RedirectErrorBoundary: null 1128}); 1129function _export(target, all) { 1130 for(var name in all)Object.defineProperty(target, name, { 1131 enumerable: true, 1132 get: all[name] 1133 }); 1134} 1135_export(exports, { 1136 RedirectBoundary: function() { 1137 return RedirectBoundary; 1138 }, 1139 RedirectErrorBoundary: function() { 1140 return RedirectErrorBoundary; 1141 } 1142}); 1143const _interop_require_wildcard = __turbopack_context__.r(151836); 1144const _jsxruntime = __turbopack_context__.r(843476); 1145const _react = /*#__PURE__*/ _interop_require_wildcard._(__turbopack_context__.r(271645)); 1146const _navigation = __turbopack_context__.r(976562); 1147const _redirect = __turbopack_context__.r(124063); 1148const _redirecterror = __turbopack_context__.r(968391); 1149function HandleRedirect(param) { 1150 let { redirect, reset, redirectType } = param; 1151 const router = (0, _navigation.useRouter)(); 1152 (0, _react.useEffect)(()=>{ 1153 _react.default.startTransition(()=>{ 1154 if (redirectType === 'push') { 1155 router.push(redirect, {}); 1156 } else { 1157 router.replace(redirect, {}); 1158 } 1159 reset(); 1160 }); 1161 }, [ 1162 redirect, 1163 redirectType, 1164 reset, 1165 router 1166 ]); 1167 return null; 1168} 1169class RedirectErrorBoundary extends _react.default.Component { 1170 static getDerivedStateFromError(error) { 1171 if ((0, _redirecterror.isRedirectError)(error)) { 1172 const url = (0, _redirect.getURLFromRedirectError)(error); 1173 const redirectType = (0, _redirect.getRedirectTypeFromError)(error); 1174 if ('handled' in error) { 1175 // The redirect was already handled. We'll still catch the redirect error 1176 // so that we can remount the subtree, but we don't actually need to trigger the 1177 // router.push. 1178 return { 1179 redirect: null, 1180 redirectType: null 1181 }; 1182 } 1183 return { 1184 redirect: url, 1185 redirectType 1186 }; 1187 } 1188 // Re-throw if error is not for redirect 1189 throw error; 1190 } 1191 // Explicit type is needed to avoid the generated `.d.ts` having a wide return type that could be specific to the `@types/react` version. 1192 render() { 1193 const { redirect, redirectType } = this.state; 1194 if (redirect !== null && redirectType !== null) { 1195 return /*#__PURE__*/ (0, _jsxruntime.jsx)(HandleRedirect, { 1196 redirect: redirect, 1197 redirectType: redirectType, 1198 reset: ()=>this.setState({ 1199 redirect: null 1200 }) 1201 }); 1202 } 1203 return this.props.children; 1204 } 1205 constructor(props){ 1206 super(props); 1207 this.state = { 1208 redirect: null, 1209 redirectType: null 1210 }; 1211 } 1212} 1213function RedirectBoundary(param) { 1214 let { children } = param; 1215 const router = (0, _navigation.useRouter)(); 1216 return /*#__PURE__*/ (0, _jsxruntime.jsx)(RedirectErrorBoundary, { 1217 router: router, 1218 children: children 1219 }); 1220} 1221if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') { 1222 Object.defineProperty(exports.default, '__esModule', { 1223 value: true 1224 }); 1225 Object.assign(exports.default, exports); 1226 module.exports = exports.default; 1227} 1228}),
1229270725, ((__turbopack_context__, module, exports) => { 1230"use strict"; 1231 1232Object.defineProperty(exports, "__esModule", { 1233 value: true 1234}); 1235Object.defineProperty(exports, "createRouterCacheKey", { 1236 enumerable: true, 1237 get: function() { 1238 return createRouterCacheKey; 1239 } 1240}); 1241const _segment = __turbopack_context__.r(813258); 1242function createRouterCacheKey(segment) { 1243 let withoutSearchParameters = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false; 1244 // if the segment is an array, it means it's a dynamic segment 1245 // for example, ['lang', 'en', 'd']. We need to convert it to a string to store it as a cache node key. 1246 if (Array.isArray(segment)) { 1247 return "".concat(segment[0], "|").concat(segment[1], "|").concat(segment[2]); 1248 } 1249 // Page segments might have search parameters, ie __PAGE__?foo=bar 1250 // When `withoutSearchParameters` is true, we only want to return the page segment 1251 if (withoutSearchParameters && segment.startsWith(_segment.PAGE_SEGMENT_KEY)) { 1252 return _segment.PAGE_SEGMENT_KEY; 1253 } 1254 return segment; 1255} 1256if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') { 1257 Object.defineProperty(exports.default, '__esModule', { 1258 value: true 1259 }); 1260 Object.assign(exports.default, exports); 1261 module.exports = exports.default; 1262} 1263}), 1264201244, ((__turbopack_context__, module, exports) => { 1265"use strict"; 1266 1267/** 1268 * Create a "Thenable" that does not resolve. This is used to suspend indefinitely when data is not available yet. 1269 */ Object.defineProperty(exports, "__esModule", { 1270 value: true 1271}); 1272Object.defineProperty(exports, "unresolvedThenable", { 1273 enumerable: true, 1274 get: function() { 1275 return unresolvedThenable; 1276 } 1277}); 1278const unresolvedThenable = { 1279 then: ()=>{} 1280}; 1281if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') { 1282 Object.defineProperty(exports.default, '__esModule', { 1283 value: true 1284 }); 1285 Object.assign(exports.default, exports); 1286 module.exports = exports.default; 1287} 1288}), 1289897367, ((__turbopack_context__, module, exports) => { 1290"use strict"; 1291 1292Object.defineProperty(exports, "__esModule", { 1293 value: true 1294}); 12950 && (module.exports = { 1296 MetadataBoundary: null, 1297 OutletBoundary: null, 1298 RootLayoutBoundary: null, 1299 ViewportBoundary: null 1300}); 1301function _export(target, all) { 1302 for(var name in all)Object.defineProperty(target, name, { 1303 enumerable: true, 1304 get: all[name] 1305 }); 1306} 1307_export(exports, { 1308 MetadataBoundary: function() { 1309 return MetadataBoundary; 1310 }, 1311 OutletBoundary: function() { 1312 return OutletBoundary; 1313 }, 1314 RootLayoutBoundary: function() { 1315 return RootLayoutBoundary; 1316 }, 1317 ViewportBoundary: function() { 1318 return ViewportBoundary; 1319 } 1320}); 1321const _boundaryconstants = __turbopack_context__.r(954839); 1322// We use a namespace object to allow us to recover the name of the function 1323// at runtime even when production bundling/minification is used. 1324const NameSpace = { 1325 [_boundaryconstants.METADATA_BOUNDARY_NAME]: function(param) { 1326 let { children } = param; 1327 return children; 1328 }, 1329 [_boundaryconstants.VIEWPORT_BOUNDARY_NAME]: function(param) { 1330 let { children } = param; 1331 return children; 1332 }, 1333 [_boundaryconstants.OUTLET_BOUNDARY_NAME]: function(param) { 1334 let { children } = param; 1335 return children; 1336 }, 1337 [_boundaryconstants.ROOT_LAYOUT_BOUNDARY_NAME]: function(param) { 1338 let { children } = param; 1339 return children; 1340 } 1341}; 1342const MetadataBoundary = // so it retains the name inferred from the namespace object 1343NameSpace[_boundaryconstants.METADATA_BOUNDARY_NAME.slice(0)]; 1344const ViewportBoundary = // so it retains the name inferred from the namespace object 1345NameSpace[_boundaryconstants.VIEWPORT_BOUNDARY_NAME.slice(0)]; 1346const OutletBoundary = // so it retains the name inferred from the namespace object 1347NameSpace[_boundaryconstants.OUTLET_BOUNDARY_NAME.slice(0)]; 1348const RootLayoutBoundary = // so it retains the name inferred from the namespace object 1349NameSpace[_boundaryconstants.ROOT_LAYOUT_BOUNDARY_NAME.slice(0)]; 1350}),
1351742732, ((__turbopack_context__, module, exports) => { 1352"use strict"; 1353 1354var __TURBOPACK__imported__module__247167__ = /*#__PURE__*/ __turbopack_context__.i(247167); 1355"use strict"; 1356Object.defineProperty(exports, "__esModule", { 1357 value: true 1358}); 1359Object.defineProperty(exports, "HeadManagerContext", { 1360 enumerable: true, 1361 get: function() { 1362 return HeadManagerContext; 1363 } 1364}); 1365const _interop_require_default = __turbopack_context__.r(563141); 1366const _react = /*#__PURE__*/ _interop_require_default._(__turbopack_context__.r(271645)); 1367const HeadManagerContext = _react.default.createContext({}); 1368if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable 1369; 1370}), 1371183330, ((__turbopack_context__) => { 1372"use strict"; 1373 1374var __TURBOPACK__imported__module__250804__ = __turbopack_context__.i(250804); 1375var __TURBOPACK__imported__module__272598__ = __turbopack_context__.i(272598); 1376var __TURBOPACK__imported__module__605394__ = __turbopack_context__.i(605394); 1377; 1378; 1379; 1380const DEFAULT_BREADCRUMBS = 100; 1381function addBreadcrumb(breadcrumb, hint) { 1382 const client = (0, __TURBOPACK__imported__module__250804__["getClient"])(); 1383 const isolationScope = (0, __TURBOPACK__imported__module__250804__["getIsolationScope"])(); 1384 if (!client) return; 1385 const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } = client.getOptions(); 1386 if (maxBreadcrumbs <= 0) return; 1387 const timestamp = (0, __TURBOPACK__imported__module__605394__["dateTimestampInSeconds"])(); 1388 const mergedBreadcrumb = { 1389 timestamp, 1390 ...breadcrumb 1391 }; 1392 const finalBreadcrumb = beforeBreadcrumb ? (0, __TURBOPACK__imported__module__272598__["consoleSandbox"])(()=>beforeBreadcrumb(mergedBreadcrumb, hint)) : mergedBreadcrumb; 1393 if (finalBreadcrumb === null) return; 1394 if (client.emit) { 1395 client.emit("beforeAddBreadcrumb", finalBreadcrumb, hint); 1396 } 1397 isolationScope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs); 1398} 1399; 1400__turbopack_context__.s([ 1401 "addBreadcrumb", 1402 0, 1403 addBreadcrumb 1404]); 1405}), 1406922737, ((__turbopack_context__, module, exports) => { 1407"use strict"; 1408 1409Object.defineProperty(exports, "__esModule", { 1410 value: true 1411}); 1412Object.defineProperty(exports, "setAttributesFromProps", { 1413 enumerable: true, 1414 get: function() { 1415 return setAttributesFromProps; 1416 } 1417}); 1418const DOMAttributeNames = { 1419 acceptCharset: 'accept-charset', 1420 className: 'class', 1421 htmlFor: 'for', 1422 httpEquiv: 'http-equiv', 1423 noModule: 'noModule' 1424}; 1425const ignoreProps = [ 1426 'onLoad', 1427 'onReady', 1428 'dangerouslySetInnerHTML', 1429 'children', 1430 'onError', 1431 'strategy', 1432 'stylesheets' 1433]; 1434function isBooleanScriptAttribute(attr) { 1435 return [ 1436 'async', 1437 'defer', 1438 'noModule' 1439 ].includes(attr); 1440} 1441function setAttributesFromProps(el, props) { 1442 for (const [p, value] of Object.entries(props)){ 1443 if (!props.hasOwnProperty(p)) continue; 1444 if (ignoreProps.includes(p)) continue; 1445 // we don't render undefined props to the DOM 1446 if (value === undefined) { 1447 continue; 1448 } 1449 const attr = DOMAttributeNames[p] || p.toLowerCase(); 1450 if (el.tagName === 'SCRIPT' && isBooleanScriptAttribute(attr)) { 1451 // Correctly assign boolean script attributes 1452 // https://github.com/vercel/next.js/pull/20748 1453 ; 1454 el[attr] = !!value; 1455 } else { 1456 el.setAttribute(attr, String(value)); 1457 } 1458 // Remove falsy non-zero boolean attributes so they are correctly interpreted 1459 // (e.g. if we set them to false, this coerces to the string "false", which the browser interprets as true) 1460 if (value === false || el.tagName === 'SCRIPT' && isBooleanScriptAttribute(attr) && (!value || value === 'false')) { 1461 // Call setAttribute before, as we need to set and unset the attribute to override force async: 1462 // https://html.spec.whatwg.org/multipage/scripting.html#script-force-async 1463 el.setAttribute(attr, ''); 1464 el.removeAttribute(attr); 1465 } 1466 } 1467} 1468if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') { 1469 Object.defineProperty(exports.default, '__esModule', { 1470 value: true 1471 });
1472 Object.assign(exports.default, exports); 1473 module.exports = exports.default; 1474} 1475}), 147667486, 858384, 1477901538, 1478((__turbopack_context__) => { 1479"use strict"; 1480 1481// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/envelope.js [app-client] (ecmascript) 1482; 1483var __TURBOPACK__imported__module__923288__ = __turbopack_context__.i(923288); 1484var __TURBOPACK__imported__module__339435__ = __turbopack_context__.i(339435); 1485var __TURBOPACK__imported__module__45968__ = __turbopack_context__.i(45968); 1486var __TURBOPACK__imported__module__111139__ = __turbopack_context__.i(111139); 1487var __TURBOPACK__imported__module__225304__ = __turbopack_context__.i(225304); 1488; 1489; 1490; 1491; 1492; 1493function createEnvelope(headers) { 1494 let items = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : []; 1495 return [ 1496 headers, 1497 items 1498 ]; 1499} 1500function addItemToEnvelope(envelope, newItem) { 1501 const [headers, items] = envelope; 1502 return [ 1503 headers, 1504 [ 1505 ...items, 1506 newItem 1507 ] 1508 ]; 1509} 1510function forEachEnvelopeItem(envelope, callback) { 1511 const envelopeItems = envelope[1]; 1512 for (const envelopeItem of envelopeItems){ 1513 const envelopeItemType = envelopeItem[0].type; 1514 const result = callback(envelopeItem, envelopeItemType); 1515 if (result) { 1516 return true; 1517 } 1518 } 1519 return false; 1520} 1521function envelopeContainsItemType(envelope, types) { 1522 return forEachEnvelopeItem(envelope, (_, type)=>types.includes(type)); 1523} 1524function encodeUTF8(input) { 1525 const carrier = (0, __TURBOPACK__imported__module__923288__["getSentryCarrier"])(__TURBOPACK__imported__module__225304__["GLOBAL_OBJ"]); 1526 return carrier.encodePolyfill ? carrier.encodePolyfill(input) : new TextEncoder().encode(input); 1527} 1528function decodeUTF8(input) { 1529 const carrier = (0, __TURBOPACK__imported__module__923288__["getSentryCarrier"])(__TURBOPACK__imported__module__225304__["GLOBAL_OBJ"]); 1530 return carrier.decodePolyfill ? carrier.decodePolyfill(input) : new TextDecoder().decode(input); 1531} 1532function serializeEnvelope(envelope) { 1533 const [envHeaders, items] = envelope; 1534 let parts = JSON.stringify(envHeaders); 1535 function append(next) { 1536 if (typeof parts === "string") { 1537 parts = typeof next === "string" ? parts + next : [ 1538 encodeUTF8(parts), 1539 next 1540 ]; 1541 } else { 1542 parts.push(typeof next === "string" ? encodeUTF8(next) : next); 1543 } 1544 } 1545 for (const item of items){ 1546 const [itemHeaders, payload] = item; 1547 append("\n".concat(JSON.stringify(itemHeaders), "\n")); 1548 if (typeof payload === "string" || payload instanceof Uint8Array) { 1549 append(payload); 1550 } else { 1551 let stringifiedPayload; 1552 try { 1553 stringifiedPayload = JSON.stringify(payload); 1554 } catch (unused) { 1555 stringifiedPayload = JSON.stringify((0, __TURBOPACK__imported__module__45968__["normalize"])(payload)); 1556 } 1557 append(stringifiedPayload); 1558 } 1559 } 1560 return typeof parts === "string" ? parts : concatBuffers(parts); 1561} 1562function concatBuffers(buffers) { 1563 const totalLength = buffers.reduce((acc, buf)=>acc + buf.length, 0); 1564 const merged = new Uint8Array(totalLength); 1565 let offset = 0; 1566 for (const buffer of buffers){ 1567 merged.set(buffer, offset); 1568 offset += buffer.length; 1569 } 1570 return merged; 1571} 1572function parseEnvelope(env) { 1573 let buffer = typeof env === "string" ? encodeUTF8(env) : env; 1574 function readBinary(length) { 1575 const bin = buffer.subarray(0, length); 1576 buffer = buffer.subarray(length + 1); 1577 return bin; 1578 } 1579 function readJson() { 1580 let i = buffer.indexOf(10); 1581 if (i < 0) { 1582 i = buffer.length; 1583 } 1584 return JSON.parse(decodeUTF8(readBinary(i))); 1585 } 1586 const envelopeHeader = readJson(); 1587 const items = []; 1588 while(buffer.length){ 1589 const itemHeader = readJson(); 1590 const binaryLength = typeof itemHeader.length === "number" ? itemHeader.length : void 0; 1591 items.push([ 1592 itemHeader, 1593 binaryLength ? readBinary(binaryLength) : readJson() 1594 ]); 1595 } 1596 return [ 1597 envelopeHeader, 1598 items 1599 ]; 1600}
1601function createSpanEnvelopeItem(spanJson) { 1602 const spanHeaders = { 1603 type: "span" 1604 }; 1605 return [ 1606 spanHeaders, 1607 spanJson 1608 ]; 1609} 1610function createAttachmentEnvelopeItem(attachment) { 1611 const buffer = typeof attachment.data === "string" ? encodeUTF8(attachment.data) : attachment.data; 1612 return [ 1613 { 1614 type: "attachment", 1615 length: buffer.length, 1616 filename: attachment.filename, 1617 content_type: attachment.contentType, 1618 attachment_type: attachment.attachmentType 1619 }, 1620 buffer 1621 ]; 1622} 1623const DATA_CATEGORY_OVERRIDES = { 1624 sessions: "session", 1625 event: "error", 1626 client_report: "internal", 1627 user_report: "default", 1628 profile_chunk: "profile", 1629 replay_event: "replay", 1630 replay_recording: "replay", 1631 check_in: "monitor", 1632 raw_security: "security", 1633 log: "log_item", 1634 trace_metric: "metric" 1635}; 1636function _isOverriddenType(type) { 1637 return type in DATA_CATEGORY_OVERRIDES; 1638} 1639function envelopeItemTypeToDataCategory(type) { 1640 return _isOverriddenType(type) ? DATA_CATEGORY_OVERRIDES[type] : type; 1641} 1642function getSdkMetadataForEnvelopeHeader(metadataOrEvent) { 1643 if (!(metadataOrEvent === null || metadataOrEvent === void 0 ? void 0 : metadataOrEvent.sdk)) { 1644 return; 1645 } 1646 const { name, version } = metadataOrEvent.sdk; 1647 return { 1648 name, 1649 version 1650 }; 1651} 1652function createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn) { 1653 var _event_sdkProcessingMetadata; 1654 const dynamicSamplingContext = (_event_sdkProcessingMetadata = event.sdkProcessingMetadata) === null || _event_sdkProcessingMetadata === void 0 ? void 0 : _event_sdkProcessingMetadata.dynamicSamplingContext; 1655 return { 1656 event_id: event.event_id, 1657 sent_at: new Date((0, __TURBOPACK__imported__module__111139__["safeDateNow"])()).toISOString(), 1658 ...sdkInfo && { 1659 sdk: sdkInfo 1660 }, 1661 ...!!tunnel && dsn && { 1662 dsn: (0, __TURBOPACK__imported__module__339435__["dsnToString"])(dsn) 1663 }, 1664 ...dynamicSamplingContext && { 1665 trace: dynamicSamplingContext 1666 } 1667 }; 1668} 1669; 1670__turbopack_context__.s([ 1671 "addItemToEnvelope", 1672 0, 1673 addItemToEnvelope, 1674 "createAttachmentEnvelopeItem", 1675 0, 1676 createAttachmentEnvelopeItem, 1677 "createEnvelope", 1678 0, 1679 createEnvelope, 1680 "createEventEnvelopeHeaders", 1681 0, 1682 createEventEnvelopeHeaders, 1683 "createSpanEnvelopeItem", 1684 0, 1685 createSpanEnvelopeItem, 1686 "envelopeContainsItemType", 1687 0, 1688 envelopeContainsItemType, 1689 "envelopeItemTypeToDataCategory", 1690 0, 1691 envelopeItemTypeToDataCategory, 1692 "forEachEnvelopeItem", 1693 0, 1694 forEachEnvelopeItem, 1695 "getSdkMetadataForEnvelopeHeader", 1696 0, 1697 getSdkMetadataForEnvelopeHeader, 1698 "serializeEnvelope", 1699 0, 1700 serializeEnvelope 1701], 67486); 1702// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/isBrowser.js [app-client] (ecmascript) 1703; 1704// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/node.js [app-client] (ecmascript) 1705; 1706var __TURBOPACK__imported__module__247167__ = __turbopack_context__.i(247167); 1707// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/env.js [app-client] (ecmascript) 1708; 1709function isBrowserBundle() { 1710 return typeof __SENTRY_BROWSER_BUNDLE__ !== "undefined" && !!__SENTRY_BROWSER_BUNDLE__; 1711} 1712function getSDKSource() { 1713 /*! __SENTRY_SDK_SOURCE__ */ return "npm"; 1714} 1715; 1716__turbopack_context__.s([ 1717 "getSDKSource", 1718 0, 1719 getSDKSource, 1720 "isBrowserBundle", 1721 0, 1722 isBrowserBundle 1723], 858384); 1724; 1725function isNodeEnv() { 1726 return !isBrowserBundle() && Object.prototype.toString.call(typeof __TURBOPACK__imported__module__247167__["default"] !== "undefined" ? __TURBOPACK__imported__module__247167__["default"] : 0) === "[object process]"; 1727} 1728function dynamicRequire(mod, request) { 1729 return mod.require(request); 1730} 1731function loadModule(moduleName) { 1732 let existingModule = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ("TURBOPACK compile-time falsy", 0) ? "TURBOPACK unreachable" : void 0; 1733 let mod; 1734 try { 1735 mod = dynamicRequire(existingModule, moduleName); 1736 } catch (unused) {} 1737 if (!mod) { 1738 try { 1739 const { cwd } = dynamicRequire(existingModule, "process"); 1740 mod = dynamicRequire(existingModule, "".concat(cwd(), "/node_modules/").concat(moduleName)); 1741 } catch (unused) {} 1742 } 1743 return mod; 1744} 1745; 1746var __TURBOPACK__imported__module__225304__1 = __TURBOPACK__imported__module__225304__; 1747; 1748; 1749function isBrowser() { 1750 return typeof window !== "undefined" && (!isNodeEnv() || isElectronNodeRenderer()); 1751} 1752function isElectronNodeRenderer() { 1753 const process = __TURBOPACK__imported__module__225304__1["GLOBAL_OBJ"].process; 1754 return (process === null || process === void 0 ? void 0 : process.type) === "renderer"; 1755} 1756; 1757__turbopack_context__.s([ 1758 "isBrowser", 1759 0, 1760 isBrowser 1761], 901538); 1762}), 1763948826, 805107, 1764766193, 1765((__turbopack_context__) => { 1766"use strict"; 1767 1768// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/timestampSequence.js [app-client] (ecmascript) 1769; 1770const SEQUENCE_ATTR_KEY = "sentry.timestamp.sequence"; 1771let _sequenceNumber = 0; 1772let _previousTimestampMs; 1773function getSequenceAttribute(timestampInSeconds) { 1774 const nowMs = Math.floor(timestampInSeconds * 1e3); 1775 if (_previousTimestampMs !== void 0 && nowMs !== _previousTimestampMs) { 1776 _sequenceNumber = 0; 1777 } 1778 const value = _sequenceNumber; 1779 _sequenceNumber++; 1780 _previousTimestampMs = nowMs; 1781 return { 1782 key: SEQUENCE_ATTR_KEY, 1783 value: { 1784 value, 1785 type: "integer" 1786 } 1787 }; 1788} 1789; 1790__turbopack_context__.s([ 1791 "getSequenceAttribute", 1792 0, 1793 getSequenceAttribute 1794], 948826); 1795// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/trace-info.js [app-client] (ecmascript) 1796; 1797var __TURBOPACK__imported__module__250804__ = __turbopack_context__.i(250804); 1798var __TURBOPACK__imported__module__473753__ = __turbopack_context__.i(473753); 1799var __TURBOPACK__imported__module__304661__ = __turbopack_context__.i(304661); 1800; 1801; 1802; 1803function _getTraceInfoFromScope(client, scope) { 1804 if (!scope) { 1805 return [ 1806 void 0, 1807 void 0 1808 ]; 1809 } 1810 return (0, __TURBOPACK__imported__module__250804__["withScope"])(scope, ()=>{ 1811 const span = (0, __TURBOPACK__imported__module__304661__["getActiveSpan"])(); 1812 const traceContext = span ? (0, __TURBOPACK__imported__module__304661__["spanToTraceContext"])(span) : (0, __TURBOPACK__imported__module__250804__["getTraceContextFromScope"])(scope); 1813 const dynamicSamplingContext = span ? (0, __TURBOPACK__imported__module__473753__["getDynamicSamplingContextFromSpan"])(span) : (0, __TURBOPACK__imported__module__473753__["getDynamicSamplingContextFromScope"])(client, scope); 1814 return [ 1815 dynamicSamplingContext, 1816 traceContext 1817 ]; 1818 }); 1819} 1820; 1821__turbopack_context__.s([ 1822 "_getTraceInfoFromScope", 1823 0, 1824 _getTraceInfoFromScope 1825], 805107); 1826// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/logs/constants.js [app-client] (ecmascript) 1827; 1828const SEVERITY_TEXT_TO_SEVERITY_NUMBER = { 1829 trace: 1, 1830 debug: 5, 1831 info: 9, 1832 warn: 13, 1833 error: 17, 1834 fatal: 21 1835}; 1836; 1837__turbopack_context__.s([ 1838 "SEVERITY_TEXT_TO_SEVERITY_NUMBER", 1839 0, 1840 SEVERITY_TEXT_TO_SEVERITY_NUMBER 1841], 766193); 1842}), 1843224339, ((__turbopack_context__) => { 1844"use strict"; 1845 1846// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/logs/internal.js [app-client] (ecmascript) 1847; 1848var __TURBOPACK__imported__module__759075__ = __turbopack_context__.i(759075); 1849var __TURBOPACK__imported__module__923288__ = __turbopack_context__.i(923288); 1850var __TURBOPACK__imported__module__250804__ = __turbopack_context__.i(250804); 1851var __TURBOPACK__imported__module__901020__ = __turbopack_context__.i(901020
1851); 1852var __TURBOPACK__imported__module__272598__ = __turbopack_context__.i(272598); 1853var __TURBOPACK__imported__module__453288__ = __turbopack_context__.i(453288); 1854var __TURBOPACK__imported__module__571993__ = __turbopack_context__.i(571993); 1855var __TURBOPACK__imported__module__821061__ = __turbopack_context__.i(821061); 1856var __TURBOPACK__imported__module__605394__ = __turbopack_context__.i(605394); 1857var __TURBOPACK__imported__module__948826__ = __turbopack_context__.i(948826); 1858var __TURBOPACK__imported__module__805107__ = __turbopack_context__.i(805107); 1859var __TURBOPACK__imported__module__766193__ = __turbopack_context__.i(766193); 1860// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/logs/envelope.js [app-client] (ecmascript) 1861; 1862var __TURBOPACK__imported__module__339435__ = __turbopack_context__.i(339435); 1863var __TURBOPACK__imported__module__67486__ = __turbopack_context__.i(67486); 1864var __TURBOPACK__imported__module__901538__ = __turbopack_context__.i(901538); 1865; 1866; 1867; 1868function createLogContainerEnvelopeItem(items, inferUserData) { 1869 const inferSetting = inferUserData ? "auto" : "never"; 1870 return [ 1871 { 1872 type: "log", 1873 item_count: items.length, 1874 content_type: "application/vnd.sentry.items.log+json" 1875 }, 1876 { 1877 version: 2, 1878 ...(0, __TURBOPACK__imported__module__901538__["isBrowser"])() && { 1879 ingest_settings: { 1880 infer_ip: inferSetting, 1881 infer_user_agent: inferSetting 1882 } 1883 }, 1884 items 1885 } 1886 ]; 1887} 1888function createLogEnvelope(logs, metadata, tunnel, dsn, inferUserData) { 1889 const headers = {}; 1890 if (metadata === null || metadata === void 0 ? void 0 : metadata.sdk) { 1891 headers.sdk = { 1892 name: metadata.sdk.name, 1893 version: metadata.sdk.version 1894 }; 1895 } 1896 if (!!tunnel && !!dsn) { 1897 headers.dsn = (0, __TURBOPACK__imported__module__339435__["dsnToString"])(dsn); 1898 } 1899 return (0, __TURBOPACK__imported__module__67486__["createEnvelope"])(headers, [ 1900 createLogContainerEnvelopeItem(logs, inferUserData) 1901 ]); 1902} 1903; 1904; 1905; 1906; 1907; 1908; 1909; 1910; 1911; 1912; 1913; 1914; 1915; 1916; 1917const MAX_LOG_BUFFER_SIZE = 100; 1918function setLogAttribute(logAttributes, key, value) { 1919 let setEvenIfPresent = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : true; 1920 if (value && (!logAttributes[key] || setEvenIfPresent)) { 1921 logAttributes[key] = value; 1922 } 1923} 1924function _INTERNAL_captureSerializedLog(client, serializedLog) { 1925 const bufferMap = _getBufferMap(); 1926 const logBuffer = _INTERNAL_getLogBuffer(client); 1927 if (logBuffer === void 0) { 1928 bufferMap.set(client, [ 1929 serializedLog 1930 ]); 1931 } else { 1932 if (logBuffer.length >= MAX_LOG_BUFFER_SIZE) { 1933 _INTERNAL_flushLogsBuffer(client, logBuffer); 1934 bufferMap.set(client, [ 1935 serializedLog 1936 ]); 1937 } else { 1938 bufferMap.set(client, [ 1939 ...logBuffer, 1940 serializedLog 1941 ]); 1942 } 1943 } 1944} 1945function _INTERNAL_captureLog(beforeLog) { 1946 let currentScope = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : (0, __TURBOPACK__imported__module__250804__["getCurrentScope"])(), captureSerializedLog = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : _INTERNAL_captureSerializedLog; 1947 var _ref, _ref1; 1948 var _client_getSdkMetadata; 1949 const client = (_ref = currentScope === null || currentScope === void 0 ? void 0 : currentScope.getClient()) !== null && _ref !== void 0 ? _ref : (0, __TURBOPACK__imported__module__250804__["getClient"])(); 1950 if (!client) { 1951 __TURBOPACK__imported__module__901020__["DEBUG_BUILD"] && __TURBOPACK__imported__module__272598__["debug"].warn("No client available to capture log."); 1952 return; 1953 } 1954 const { release, environment, enableLogs = true, beforeSendLog } = client.getOptions(); 1955 if (!enableLogs) { 1956 __TURBOPACK__imported__module__901020__["DEBUG_BUILD"] && __TURBOPACK__imported__module__272598__["debug"].warn("logging option not enabled, log will not be captured."); 1957 return; 1958 } 1959 const [, traceContext] = (0, __TURBOPACK__imported__module__805107__["_getTraceInfoFromScope"])(client, currentScope); 1960 const processedLogAttributes = { 1961 ...beforeLog.attributes 1962 }; 1963 const { user: { id, email, username }, attributes: scopeAttributes = {} } = (0, __TURBOPACK__imported__module__571993__["getCombinedScopeData"])((0, __TURBOPACK__imported__module__250804__["getIsolationScope"])(), currentScope);
1964 setLogAttribute(processedLogAttributes, "user.id", id, false); 1965 setLogAttribute(processedLogAttributes, "user.email", email, false); 1966 setLogAttribute(processedLogAttributes, "user.name", username, false); 1967 setLogAttribute(processedLogAttributes, "sentry.release", release); 1968 setLogAttribute(processedLogAttributes, "sentry.environment", environment); 1969 const { name, version } = (_ref1 = (_client_getSdkMetadata = client.getSdkMetadata()) === null || _client_getSdkMetadata === void 0 ? void 0 : _client_getSdkMetadata.sdk) !== null && _ref1 !== void 0 ? _ref1 : {}; 1970 setLogAttribute(processedLogAttributes, "sentry.sdk.name", name); 1971 setLogAttribute(processedLogAttributes, "sentry.sdk.version", version); 1972 const replay = client.getIntegrationByName("Replay"); 1973 const replayId = replay === null || replay === void 0 ? void 0 : replay.getReplayId(true); 1974 setLogAttribute(processedLogAttributes, "sentry.replay_id", replayId); 1975 if (replayId && (replay === null || replay === void 0 ? void 0 : replay.getRecordingMode()) === "buffer") { 1976 setLogAttribute(processedLogAttributes, "sentry._internal.replay_is_buffering", true); 1977 } 1978 const beforeLogMessage = beforeLog.message; 1979 if ((0, __TURBOPACK__imported__module__453288__["isParameterizedString"])(beforeLogMessage)) { 1980 const { __sentry_template_string__, __sentry_template_values__ = [] } = beforeLogMessage; 1981 if (__sentry_template_values__ === null || __sentry_template_values__ === void 0 ? void 0 : __sentry_template_values__.length) { 1982 processedLogAttributes["sentry.message.template"] = __sentry_template_string__; 1983 } 1984 __sentry_template_values__.forEach((param, index)=>{ 1985 processedLogAttributes["sentry.message.parameter.".concat(index)] = param; 1986 }); 1987 } 1988 const span = (0, __TURBOPACK__imported__module__821061__["_getSpanForScope"])(currentScope); 1989 setLogAttribute(processedLogAttributes, "sentry.trace.parent_span_id", span === null || span === void 0 ? void 0 : span.spanContext().spanId); 1990 const processedLog = { 1991 ...beforeLog, 1992 attributes: processedLogAttributes 1993 }; 1994 client.emit("beforeCaptureLog", processedLog); 1995 const log = beforeSendLog ? (0, __TURBOPACK__imported__module__272598__["consoleSandbox"])(()=>beforeSendLog(processedLog)) : processedLog; 1996 if (!log) { 1997 client.recordDroppedEvent("before_send", "log_item", 1); 1998 __TURBOPACK__imported__module__901020__["DEBUG_BUILD"] && __TURBOPACK__imported__module__272598__["debug"].warn("beforeSendLog returned null, log will not be captured."); 1999 return; 2000 } 2001 const { level, message, attributes: logAttributes = {}, severityNumber } = log; 2002 const timestamp = (0, __TURBOPACK__imported__module__605394__["timestampInSeconds"])(); 2003 const sequenceAttr = (0, __TURBOPACK__imported__module__948826__["getSequenceAttribute"])(timestamp); 2004 const serializedLog = { 2005 timestamp, 2006 level, 2007 body: _removeLoneSurrogates(String(message)), 2008 trace_id: traceContext === null || traceContext === void 0 ? void 0 : traceContext.trace_id, 2009 severity_number: severityNumber !== null && severityNumber !== void 0 ? severityNumber : __TURBOPACK__imported__module__766193__["SEVERITY_TEXT_TO_SEVERITY_NUMBER"][level], 2010 attributes: sanitizeLogAttributes({ 2011 ...(0, __TURBOPACK__imported__module__759075__["serializeAttributes"])(scopeAttributes), 2012 ...(0, __TURBOPACK__imported__module__759075__["serializeAttributes"])(logAttributes, true), 2013 [sequenceAttr.key]: sequenceAttr.value 2014 }) 2015 }; 2016 captureSerializedLog(client, serializedLog); 2017 client.emit("afterCaptureLog", log); 2018} 2019function _INTERNAL_flushLogsBuffer(client, maybeLogBuffer) { 2020 var _ref; 2021 const logBuffer = (_ref = maybeLogBuffer !== null && maybeLogBuffer !== void 0 ? maybeLogBuffer : _INTERNAL_getLogBuffer(client)) !== null && _ref !== void 0 ? _ref : []; 2022 if (logBuffer.length === 0) { 2023 return; 2024 } 2025 const clientOptions = client.getOptions(); 2026 const envelope = createLogEnvelope(logBuffer, clientOptions._metadata, clientOptions.tunnel, client.getDsn(), client.getDataCollectionOptions().userInfo); 2027 _getBufferMap().set(client, []); 2028 client.emit("flushLogs"); 2029 client.sendEnvelope(envelope); 2030} 2031function _INTERNAL_getLogBuffer(client) { 2032 return _getBufferMap().get(client); 2033} 2034function _getBufferMap() { 2035 return (0, __TURBOPACK__imported__module__923288__["getGlobalSingleton"])("clientToLogBufferMap", ()=>/* @__PURE__ */ new WeakMap()); 2036} 2037function sanitizeLogAttributes(attributes) { 2038 const sanitized = {}; 2039 for (const [key, attr] of Object.entries(attributes)){ 2040 const sanitizedKey = _removeLoneSurrogates(key); 2041 if (attr.type === "string") { 2042 sanitized[sanitizedKey] = { 2043 ...attr, 2044 value: _removeLoneSurrogates(attr.value) 2045 }; 2046 } else { 2047 sanitized[sanitizedKey] = attr; 2048 } 2049 } 2050 return sanitized; 2051} 2052function _removeLoneSurrogates(str) { 2053 const strObj = Object(str); 2054 const isWellFormed = strObj["isWellFormed"]; 2055 const toWellFormed = strObj["toWellFormed"]; 2056 if (typeof isWellFormed === "function" && typeof toWellFormed === "function") { 2057 return isWellFormed.call(str) ? str : toWellFormed.call(str); 2058 } 2059 return str; 2060} 2061; 2062__turbopack_context__.s([ 2063 "_INTERNAL_captureLog", 2064 0, 2065 _INTERNAL_captureLog, 2066 "_INTERNAL_flushLogsBuffer", 2067 0, 2068 _INTERNAL_flushLogsBuffer 2069], 224339); 2070}), 2071]); 2072 2073//# debugId=22cd0856-04f8-3811-85fb-8844725529e5
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.