https://diks.net/_next/static/chunks/1isvqvyi1b7tp.js

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]="4df17d55-332a-da84-47de-88fee41930aa")}catch(e){}}();
2(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined,
3519988, ((__turbopack_context__) => {
4"use strict";
5
6const SEMANTIC_ATTRIBUTE_SENTRY_SOURCE = "sentry.source";
7const SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE = "sentry.sample_rate";
8const SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE = "sentry.previous_trace_sample_rate";
9const SEMANTIC_ATTRIBUTE_SENTRY_OP = "sentry.op";
10const SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN = "sentry.origin";
11const SEMANTIC_ATTRIBUTE_SENTRY_STATUS_MESSAGE = "sentry.status.message";
12const SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON = "sentry.idle_span_finish_reason";
13const SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT = "sentry.measurement_unit";
14const SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE = "sentry.measurement_value";
15const SEMANTIC_ATTRIBUTE_SENTRY_RELEASE = "sentry.release";
16const SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT = "sentry.environment";
17const SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME = "sentry.segment.name";
18const SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID = "sentry.segment.id";
19const SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME = "sentry.sdk.name";
20const SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION = "sentry.sdk.version";
21const SEMANTIC_ATTRIBUTE_SENTRY_SDK_INTEGRATIONS = "sentry.sdk.integrations";
22const SEMANTIC_ATTRIBUTE_USER_ID = "user.id";
23const SEMANTIC_ATTRIBUTE_USER_EMAIL = "user.email";
24const SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS = "user.ip_address";
25const SEMANTIC_ATTRIBUTE_USER_USERNAME = "user.name";
26const SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME = "sentry.custom_span_name";
27const SEMANTIC_ATTRIBUTE_PROFILE_ID = "sentry.profile_id";
28const SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME = "sentry.exclusive_time";
29const SEMANTIC_ATTRIBUTE_CACHE_HIT = "cache.hit";
30const SEMANTIC_ATTRIBUTE_CACHE_KEY = "cache.key";
31const SEMANTIC_ATTRIBUTE_CACHE_ITEM_SIZE = "cache.item_size";
32const SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD = "http.request.method";
33const SEMANTIC_ATTRIBUTE_URL_FULL = "url.full";
34const SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE = "sentry.link.type";
35const GEN_AI_CONVERSATION_ID_ATTRIBUTE = "gen_ai.conversation.id";
36;
37__turbopack_context__.s([
38    "GEN_AI_CONVERSATION_ID_ATTRIBUTE",
39    0,
40    GEN_AI_CONVERSATION_ID_ATTRIBUTE,
41    "SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME",
42    0,
43    SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME,
44    "SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD",
45    0,
46    SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD,
47    "SEMANTIC_ATTRIBUTE_PROFILE_ID",
48    0,
49    SEMANTIC_ATTRIBUTE_PROFILE_ID,
50    "SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME",
51    0,
52    SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME,
53    "SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT",
54    0,
55    SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT,
56    "SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON",
57    0,
58    SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON,
59    "SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT",
60    0,
61    SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT,
62    "SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE",
63    0,
64    SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE,
65    "SEMANTIC_ATTRIBUTE_SENTRY_OP",
66    0,
67    SEMANTIC_ATTRIBUTE_SENTRY_OP,
68    "SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN",
69    0,
70    SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
71    "SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE",
72    0,
73    SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE,
74    "SEMANTIC_ATTRIBUTE_SENTRY_RELEASE",
75    0,
76    SEMANTIC_ATTRIBUTE_SENTRY_RELEASE,
77    "SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE",
78    0,
79    SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE,
80    "SEMANTIC_ATTRIBUTE_SENTRY_SDK_INTEGRATIONS",
81    0,
82    SEMANTIC_ATTRIBUTE_SENTRY_SDK_INTEGRATIONS,
83    "SEMANTIC_ATTRIBUTE_SENTRY_SOURCE",
84    0,
85    SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
86    "SEMANTIC_ATTRIBUTE_SENTRY_STATUS_MESSAGE",
87    0,
88    SEMANTIC_ATTRIBUTE_SENTRY_STATUS_MESSAGE,
89    "SEMANTIC_ATTRIBUTE_USER_EMAIL",
90    0,
91    SEMANTIC_ATTRIBUTE_USER_EMAIL,
92    "SEMANTIC_ATTRIBUTE_USER_ID",
93    0,
94    SEMANTIC_ATTRIBUTE_USER_ID,
95    "SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS",
96    0,
97    SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS,
98    "SEMANTIC_ATTRIBUTE_USER_USERNAME",
99    0,
100    SEMANTIC_ATTRIBUTE_USER_USERNAME,
101    "SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE",
102    0,
103    SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE
104]);
105}),
106373250, ((__turbopack_context__) => {
107"use strict";
108
109const DEFAULT_ENVIRONMENT = "production";
110const DEV_ENVIRONMENT = "development";
111;
112__turbopack_context__.s([
113    "DEFAULT_ENVIRONMENT",
114    0,
115    DEFAULT_ENVIRONMENT
116]);
117}),
118602309, 339435, 
11910008, 
120((__turbopack_context__) => {
121"use strict";
122
123// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/baggage.js [a

123pp-client] (ecmascript)
124;
125var __TURBOPACK__imported__module__901020__ = __turbopack_context__.i(901020);
126var __TURBOPACK__imported__module__272598__ = __turbopack_context__.i(272598);
127var __TURBOPACK__imported__module__453288__ = __turbopack_context__.i(453288);
128;
129;
130;
131const SENTRY_BAGGAGE_KEY_PREFIX = "sentry-";
132const SENTRY_BAGGAGE_KEY_PREFIX_REGEX = /^sentry-/;
133const MAX_BAGGAGE_STRING_LENGTH = 8192;
134function baggageHeaderToDynamicSamplingContext(baggageHeader) {
135    const baggageObject = parseBaggageHeader(baggageHeader);
136    if (!baggageObject) {
137        return void 0;
138    }
139    const dynamicSamplingContext = Object.entries(baggageObject).reduce((acc, param)=>{
140        let [key, value] = param;
141        if (key.startsWith(SENTRY_BAGGAGE_KEY_PREFIX)) {
142            const nonPrefixedKey = key.slice(SENTRY_BAGGAGE_KEY_PREFIX.length);
143            acc[nonPrefixedKey] = value;
144        }
145        return acc;
146    }, {});
147    if (Object.keys(dynamicSamplingContext).length > 0) {
148        return dynamicSamplingContext;
149    } else {
150        return void 0;
151    }
152}
153function dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext) {
154    if (!dynamicSamplingContext) {
155        return void 0;
156    }
157    const sentryPrefixedDSC = Object.entries(dynamicSamplingContext).reduce((acc, param)=>{
158        let [dscKey, dscValue] = param;
159        if (dscValue) {
160            acc["".concat(SENTRY_BAGGAGE_KEY_PREFIX).concat(dscKey)] = dscValue;
161        }
162        return acc;
163    }, {});
164    return objectToBaggageHeader(sentryPrefixedDSC);
165}
166function parseBaggageHeader(baggageHeader) {
167    if (!baggageHeader || !(0, __TURBOPACK__imported__module__453288__["isString"])(baggageHeader) && !Array.isArray(baggageHeader)) {
168        return void 0;
169    }
170    if (Array.isArray(baggageHeader)) {
171        return baggageHeader.reduce((acc, curr)=>{
172            const currBaggageObject = baggageHeaderToObject(curr);
173            Object.entries(currBaggageObject).forEach((param)=>{
174                let [key, value] = param;
175                acc[key] = value;
176            });
177            return acc;
178        }, {});
179    }
180    return baggageHeaderToObject(baggageHeader);
181}
182function baggageHeaderToObject(baggageHeader) {
183    return baggageHeader.split(",").map((baggageEntry)=>{
184        const eqIdx = baggageEntry.indexOf("=");
185        if (eqIdx === -1) {
186            return [];
187        }
188        const key = baggageEntry.slice(0, eqIdx);
189        const value = baggageEntry.slice(eqIdx + 1);
190        return [
191            key,
192            value
193        ].map((keyOrValue)=>{
194            try {
195                return decodeURIComponent(keyOrValue.trim());
196            } catch (unused) {
197                return;
198            }
199        });
200    }).reduce((acc, param)=>{
201        let [key, value] = param;
202        if (key && value) {
203            acc[key] = value;
204        }
205        return acc;
206    }, {});
207}
208function objectToBaggageHeader(object) {
209    if (Object.keys(object).length === 0) {
210        return void 0;
211    }
212    return Object.entries(object).reduce((baggageHeader, param, currentIndex)=>{
213        let [objectKey, objectValue] = param;
214        const baggageEntry = "".concat(encodeURIComponent(objectKey), "=").concat(encodeURIComponent(objectValue));
215        const newBaggageHeader = currentIndex === 0 ? baggageEntry : "".concat(baggageHeader, ",").concat(baggageEntry);
216        if (newBaggageHeader.length > MAX_BAGGAGE_STRING_LENGTH) {
217            __TURBOPACK__imported__module__901020__["DEBUG_BUILD"] && __TURBOPACK__imported__module__272598__["debug"].warn("Not adding key: ".concat(objectKey, " with val: ").concat(objectValue, " to baggage header due to exceeding baggage size limits."));
218            return baggageHeader;
219        } else {
220            return newBaggageHeader;
221        }
222    }, "");
223}
224function mergeBaggageHeaders(existing, incoming) {
225    if (!existing) {
226        return incoming;
227    }
228    const existingEntries = parseBaggageHeader(existing);
229    const incomingEntries = parseBaggageHeader(incoming);
230    if (!incomingEntries) {
231        return existing;
232    }
233    const merged = {};
234    let hasNewSentryEntries = false;

235    const newSentryEntries = {};
236    const newNonSentryEntries = {};
237    for (const [key, value] of Object.entries(incomingEntries)){
238        if (key.startsWith(SENTRY_BAGGAGE_KEY_PREFIX)) {
239            newSentryEntries[key] = value;
240            hasNewSentryEntries = true;
241        } else {
242            newNonSentryEntries[key] = value;
243        }
244    }
245    if (existingEntries) {
246        for (const [key, value] of Object.entries(existingEntries)){
247            if (!hasNewSentryEntries || !key.startsWith(SENTRY_BAGGAGE_KEY_PREFIX)) {
248                merged[key] = value;
249            }
250        }
251    }
252    if (hasNewSentryEntries) {
253        Object.assign(merged, newSentryEntries);
254    }
255    for (const [key, value] of Object.entries(newNonSentryEntries)){
256        var _merged_key;
257        (_merged_key = merged[key]) !== null && _merged_key !== void 0 ? _merged_key : merged[key] = value;
258    }
259    return objectToBaggageHeader(merged);
260}
261;
262__turbopack_context__.s([
263    "SENTRY_BAGGAGE_KEY_PREFIX",
264    0,
265    SENTRY_BAGGAGE_KEY_PREFIX,
266    "baggageHeaderToDynamicSamplingContext",
267    0,
268    baggageHeaderToDynamicSamplingContext,
269    "dynamicSamplingContextToSentryBaggageHeader",
270    0,
271    dynamicSamplingContextToSentryBaggageHeader,
272    "parseBaggageHeader",
273    0,
274    parseBaggageHeader
275], 602309);
276// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/dsn.js [app-client] (ecmascript)
277;
278var __TURBOPACK__imported__module__901020__1 = __TURBOPACK__imported__module__901020__;
279var __TURBOPACK__imported__module__272598__1 = __TURBOPACK__imported__module__272598__;
280;
281;
282const ORG_ID_REGEX = /^o(\d+)\./;
283const DSN_REGEX = /^(?:(\w+):)\/\/(?:(\w+)(?::(\w+)?)?@)((?:\[[:.%\w]+\]|[\w.-]+))(?::(\d+))?\/(.+)/;
284function isValidProtocol(protocol) {
285    return protocol === "http" || protocol === "https";
286}
287function dsnToString(dsn) {
288    let withPassword = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
289    const { host, path, pass, port, projectId, protocol, publicKey } = dsn;
290    return "".concat(protocol, "://").concat(publicKey).concat(withPassword && pass ? ":".concat(pass) : "", "@").concat(host).concat(port ? ":".concat(port) : "", "/").concat(path ? "".concat(path, "/") : path).concat(projectId);
291}
292function dsnFromString(str) {
293    const match = DSN_REGEX.exec(str);
294    if (!match) {
295        (0, __TURBOPACK__imported__module__272598__1["consoleSandbox"])(()=>{
296            console.error("Invalid Sentry Dsn: ".concat(str));
297        });
298        return void 0;
299    }
300    const [protocol, publicKey, pass = "", host = "", port = "", lastPath = ""] = match.slice(1);
301    let path = "";
302    let projectId = lastPath;
303    const split = projectId.split("/");
304    if (split.length > 1) {
305        path = split.slice(0, -1).join("/");
306        projectId = split.pop();
307    }
308    if (projectId) {
309        const projectMatch = projectId.match(/^\d+/);
310        if (projectMatch) {
311            projectId = projectMatch[0];
312        }
313    }
314    return dsnFromComponents({
315        host,
316        pass,
317        path,
318        projectId,
319        port,
320        protocol,
321        publicKey
322    });
323}
324function dsnFromComponents(components) {
325    return {
326        protocol: components.protocol,
327        publicKey: components.publicKey || "",
328        pass: components.pass || "",
329        host: components.host,
330        port: components.port || "",
331        path: components.path || "",
332        projectId: components.projectId
333    };
334}
335function validateDsn(dsn) {
336    if (!__TURBOPACK__imported__module__901020__1["DEBUG_BUILD"]) {
337        return true;
338    }
339    const { port, projectId, protocol } = dsn;
340    const requiredComponents = [
341        "protocol",
342        "publicKey",
343        "host",
344        "projectId"
345    ];
346    const hasMissingRequiredComponent = requiredComponents.find((component)=>{
347        if (!dsn[component]) {
348            __TURBOPACK__imported__module__272598__1["debug"].error("Invalid Sentry Dsn: ".concat(component, " missing"));
349            return true;
350        }
351        return false;
352    });
353    if (hasMissingRequiredComponent) {
354        return false;

355    }
356    if (!projectId.match(/^\d+$/)) {
357        __TURBOPACK__imported__module__272598__1["debug"].error("Invalid Sentry Dsn: Invalid projectId ".concat(projectId));
358        return false;
359    }
360    if (!isValidProtocol(protocol)) {
361        __TURBOPACK__imported__module__272598__1["debug"].error("Invalid Sentry Dsn: Invalid protocol ".concat(protocol));
362        return false;
363    }
364    if (port && isNaN(parseInt(port, 10))) {
365        __TURBOPACK__imported__module__272598__1["debug"].error("Invalid Sentry Dsn: Invalid port ".concat(port));
366        return false;
367    }
368    return true;
369}
370function extractOrgIdFromDsnHost(host) {
371    const match = host.match(ORG_ID_REGEX);
372    return match === null || match === void 0 ? void 0 : match[1];
373}
374function extractOrgIdFromClient(client) {
375    const options = client.getOptions();
376    const { host } = client.getDsn() || {};
377    let org_id;
378    if (options.orgId) {
379        org_id = String(options.orgId);
380    } else if (host) {
381        org_id = extractOrgIdFromDsnHost(host);
382    }
383    return org_id;
384}
385function makeDsn(from) {
386    const components = typeof from === "string" ? dsnFromString(from) : dsnFromComponents(from);
387    if (!components || !validateDsn(components)) {
388        return void 0;
389    }
390    return components;
391}
392;
393__turbopack_context__.s([
394    "dsnFromString",
395    0,
396    dsnFromString,
397    "dsnToString",
398    0,
399    dsnToString,
400    "extractOrgIdFromClient",
401    0,
402    extractOrgIdFromClient,
403    "makeDsn",
404    0,
405    makeDsn
406], 339435);
407// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/hasSpansEnabled.js [app-client] (ecmascript)
408;
409var __TURBOPACK__imported__module__250804__ = __turbopack_context__.i(250804);
410;
411function hasSpansEnabled(maybeOptions) {
412    var _getClient;
413    if (typeof __SENTRY_TRACING__ === "boolean" && !__SENTRY_TRACING__) {
414        return false;
415    }
416    const options = maybeOptions || ((_getClient = (0, __TURBOPACK__imported__module__250804__["getClient"])()) === null || _getClient === void 0 ? void 0 : _getClient.getOptions());
417    return !!options && // Note: This check is `!= null`, meaning "nullish". `0` is not "nullish", `undefined` and `null` are. (This comment was brought to you by 15 minutes of questioning life)
418    (options.tracesSampleRate != null || !!options.tracesSampler);
419}
420;
421__turbopack_context__.s([
422    "hasSpansEnabled",
423    0,
424    hasSpansEnabled
425], 10008);
426}),
427759075, ((__turbopack_context__) => {
428"use strict";
429
430var __TURBOPACK__imported__module__453288__ = __turbopack_context__.i(453288);
431;
432function isAttributeObject(maybeObj) {
433    return typeof maybeObj === "object" && maybeObj != null && !Array.isArray(maybeObj) && Object.keys(maybeObj).includes("value");
434}
435function attributeValueToTypedAttributeValue(rawValue, useFallback) {
436    const { value, unit } = isAttributeObject(rawValue) ? rawValue : {
437        value: rawValue,
438        unit: void 0
439    };
440    const attributeValue = getTypedAttributeValue(value);
441    const checkedUnit = unit && typeof unit === "string" ? {
442        unit
443    } : {};
444    if (attributeValue) {
445        return {
446            ...attributeValue,
447            ...checkedUnit
448        };
449    }
450    if (!useFallback || useFallback === "skip-undefined" && value === void 0) {
451        return;
452    }
453    let stringValue = "";
454    try {
455        var _JSON_stringify;
456        stringValue = (_JSON_stringify = JSON.stringify(value)) !== null && _JSON_stringify !== void 0 ? _JSON_stringify : "";
457    } catch (unused) {}
458    return {
459        value: stringValue,
460        type: "string",
461        ...checkedUnit
462    };
463}
464function serializeAttributes(attributes) {
465    let fallback = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
466    const serializedAttributes = {};
467    for (const [key, value] of Object.entries(attributes !== null && attributes !== void 0 ? attributes : {})){
468        const typedValue = attributeValueToTypedAttributeValue(value, fallback);
469        if (typedValue) {
470            serializedAttributes[key] = typedValue;
471        }
472    }
473    return serializedAttributes;
474}
475function estimateTypedAttributesSizeInBytes(attributes) {
476    if (!attributes) {
477        return 0;
478    }
479    let weight = 0;
480    for (const [key, attr] of Object.entries(attributes)){
481        var _ref;
482        var _attr_unit;
483        weight += key.length * 2;
484        weight += attr.type.length * 2;
485        weight += ((_ref = (_attr_unit = attr.unit) === null || _attr_unit === void 0 ? void 0 : _attr_unit.length) !== null && _ref !== void 0 ? _ref : 0) * 2;
486        const val = attr.value;
487        if (Array.isArray(val)) {
488            weight += estimatePrimitiveSizeInBytes(val[0]) * val.length;
489        } else if ((0, __TURBOPACK__imported__module__453288__["isPrimitive"])(val)) {
490            weight += estimatePrimitiveSizeInBytes(val);
491        } else {
492            weight += 100;
493        }
494    }
495    return weight;
496}
497function estimatePrimitiveSizeInBytes(value) {
498    if (typeof value === "string") {
499        return value.length * 2;
500    } else if (typeof value === "boolean") {
501        return 4;
502    } else if (typeof value === "number") {
503        return 8;
504    }
505    return 0;
506}
507function getTypedAttributeValue(value) {
508    if (Array.isArray(value)) {
509        return {
510            value,
511            type: "array"
512        };
513    }
514    const primitiveType = typeof value === "string" ? "string" : typeof value === "boolean" ? "boolean" : typeof value === "number" && !Number.isNaN(value) ? Number.isInteger(value) ? "integer" : "double" : null;
515    if (primitiveType) {
516        return {
517            value,
518            type: primitiveType
519        };
520    }
521}
522;
523__turbopack_context__.s([
524    "serializeAttributes",
525    0,
526    serializeAttributes
527]);
528}),
529571993, 776710, 
530242222, 
531170637, 
532132584, 
533304661, 
534728469, 
535473753, 
536((__turbopack_context__) => {
537"use strict";
538
539// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/scopeData.js [app-client] (ecmascript)
540;
541var __TURBOPACK__imported__module__250804__ = __turbopack_context__.i(250804);
542// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/tracing/dynamicSamplingContext.js [a

542pp-client] (ecmascript)
543;
544var __TURBOPACK__imported__module__373250__ = __turbopack_context__.i(373250);
545var __TURBOPACK__imported__module__250804__1 = __TURBOPACK__imported__module__250804__;
546var __TURBOPACK__imported__module__519988__ = __turbopack_context__.i(519988);
547var __TURBOPACK__imported__module__602309__ = __turbopack_context__.i(602309);
548var __TURBOPACK__imported__module__339435__ = __turbopack_context__.i(339435);
549var __TURBOPACK__imported__module__10008__ = __turbopack_context__.i(10008);
550var __TURBOPACK__imported__module__951497__ = __turbopack_context__.i(951497);
551// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/spanUtils.js [app-client] (ecmascript)
552;
553var __TURBOPACK__imported__module__301263__ = __turbopack_context__.i(301263);
554var __TURBOPACK__imported__module__759075__ = __turbopack_context__.i(759075);
555var __TURBOPACK__imported__module__923288__ = __turbopack_context__.i(923288);
556var __TURBOPACK__imported__module__250804__2 = __TURBOPACK__imported__module__250804__;
557var __TURBOPACK__imported__module__519988__1 = __TURBOPACK__imported__module__519988__;
558// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/tracing/spanstatus.js [app-client] (ecmascript)
559;
560const SPAN_STATUS_UNSET = 0;
561const SPAN_STATUS_OK = 1;
562const SPAN_STATUS_ERROR = 2;
563function getSpanStatusFromHttpCode(httpStatus) {
564    if (httpStatus < 400 && httpStatus >= 100) {
565        return {
566            code: SPAN_STATUS_OK
567        };
568    }
569    if (httpStatus >= 400 && httpStatus < 500) {
570        switch(httpStatus){
571            case 401:
572                return {
573                    code: SPAN_STATUS_ERROR,
574                    message: "unauthenticated"
575                };
576            case 403:
577                return {
578                    code: SPAN_STATUS_ERROR,
579                    message: "permission_denied"
580                };
581            case 404:
582                return {
583                    code: SPAN_STATUS_ERROR,
584                    message: "not_found"
585                };
586            case 409:
587                return {
588                    code: SPAN_STATUS_ERROR,
589                    message: "already_exists"
590                };
591            case 413:
592                return {
593                    code: SPAN_STATUS_ERROR,
594                    message: "failed_precondition"
595                };
596            case 429:
597                return {
598                    code: SPAN_STATUS_ERROR,
599                    message: "resource_exhausted"
600                };
601            case 499:
602                return {
603                    code: SPAN_STATUS_ERROR,
604                    message: "cancelled"
605                };
606            default:
607                return {
608                    code: SPAN_STATUS_ERROR,
609                    message: "invalid_argument"
610                };
611        }
612    }
613    if (httpStatus >= 500 && httpStatus < 600) {
614        switch(httpStatus){
615            case 501:
616                return {
617                    code: SPAN_STATUS_ERROR,
618                    message: "unimplemented"
619                };
620            case 503:
621                return {
622                    code: SPAN_STATUS_ERROR,
623                    message: "unavailable"
624                };
625            case 504:
626                return {
627                    code: SPAN_STATUS_ERROR,
628                    message: "deadline_exceeded"
629                };
630            default:
631                return {
632                    code: SPAN_STATUS_ERROR,
633                    message: "internal_error"
634                };
635        }
636    }
637    return {
638        code: SPAN_STATUS_ERROR,
639        message: "internal_error"
640    };
641}
642function setHttpStatus(span, httpStatus) {
643    span.setAttribute("http.response.status_code", httpStatus);
644    const spanStatus = getSpanStatusFromHttpCode(httpStatus);
645    if (spanStatus.message !== "unknown_error") {
646        span.setStatus(spanStatus);
647    }
648}
649;
650__turbopack_context__.s([
651    "SPAN_STATUS_ERROR",
652    0,
653    SPAN_STATUS_ERROR,
654    "SPAN_STATUS_OK",
655    0,
656    SPAN_STATUS_OK,
657    "SPAN_STATUS_UNSET",
658    0,
659    SPAN_STATUS_UNSET,
660    "setHttpStatus",
661    0,
662    setHttpStatus
663], 776710);
664// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/tracing/utils.js [app-client] (ecmascript)
665;
666var __TURBOPACK__imported__module__951497__1 = __TURBOPACK__imported__module__951497__;
667var __TURBOPACK__imported__module__960224__ = __turbopack_context__.i(960224);
668;
669;
670const SCOPE_ON_START_SPAN_FIELD = "_sentryScope";
671const ISOLATION_SCOPE_ON_START_SPAN_FIELD = "_sentryIsolationScope";
672const OTEL_SOURCE_INFERENCE_SPAN_FIELD = /* @__PURE__ */ Symbol.for("sentry.otelSourceInference");
673const OTEL_SOURCE_EXPLICITLY_SET_SPAN_FIELD = /* @__PURE__ */ Symbol.for("sentry.otelSourceExplicitlySet");
674const TRACER_PROVIDER_SPAN_FIELD = /* @__PURE__ */ Symbol.for("sentry.tracerProviderSpan");
675function setCapturedScopesOnSpan(span, scope, isolationScope) {
676    if (span) {
677        (0, __TURBOPACK__imported__module__951497__1["addNonEnumerableProperty"])(span, ISOLATION_SCOPE_ON_START_SPAN_FIELD, (0, __TURBOPACK__imported__module__960224__["makeWeakRef"])(isolationScope));
678        (0, __TURBOPACK__imported__module__951497__1["addNonEnumerableProperty"])(span, SCOPE_ON_START_SPAN_FIELD, scope);
679    }
680}
681function getCapturedScopesOnSpan(span) {
682    const spanWithScopes = span;
683    return {
684        scope: spanWithScopes[SCOPE_ON_START_SPAN_FIELD],
685        isolationScope: (0, __TURBOPACK__imported__module__960224__["derefWeakRef"])(spanWithScopes[ISOLATION_SCOPE_ON_START_SPAN_FIELD])
686    };
687}
688function markSpanForOtelSourceInference(span) {
689    (0, __TURBOPACK__imported__module__951497__1["addNonEnumerableProperty"])(span, OTEL_SOURCE_INFERENCE_SPAN_FIELD, true);
690}
691function spanShouldInferOtelSource(span) {
692    return span[OTEL_SOURCE_INFERENCE_SPAN_FIELD] === true;
693}
694function markSpanSourceAsExplicit(span) {
695    (0, __TURBOPACK__imported__module__951497__1["addNonEnumerableProperty"])(span, OTEL_SOURCE_EXPLICITLY_SET_SPAN_FIELD, true);
696}
697function spanSourceWasExplicitlySet(span) {
698    return span[OTEL_SOURCE_EXPLICITLY_SET_SPAN_FIELD] === true;
699}
700function markSpanAsTracerProviderSpan(span) {
701    (0, __TURBOPACK__imported__module__951497__1["addNonEnumerableProperty"])(span, TRACER_PROVIDER_SPAN_FIELD, true);
702}
703function spanIsTracerProviderSpan(span) {
704    return span[TRACER_PROVIDER_SPAN_FIELD] === true;
705}
706;
707__turbopack_context__.s([
708    "getCapturedScopesOnSpan",
709    0,
710    getCapturedScopesOnSpan,
711    "markSpanSourceAsExplicit",
712    0,
713    markSpanSourceAsExplicit,
714    "setCapturedScopesOnSpan",
715    0,
716    setCapturedScopesOnSpan,
717    "spanIsTracerProviderSpan",
718    0,
719    spanIsTracerProviderSpan,
720    "spanShouldInferOtelSource",
721    0,
722    spanShouldInferOtelSource
723], 242222);
724var __TURBOPACK__imported__module__951497__2 = __TURBOPACK__imported__module__951497__;
725var __TURBOPACK__imported__module__373382__ = __turbopack_context__.i(373382);
726var __TURBOPACK__imported__module__605394__ = __turbopack_context__.i(605394);
727// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/tracing.js [a

727pp-client] (ecmascript)
728;
729var __TURBOPACK__imported__module__272598__ = __turbopack_context__.i(272598);
730var __TURBOPACK__imported__module__602309__1 = __TURBOPACK__imported__module__602309__;
731var __TURBOPACK__imported__module__339435__1 = __TURBOPACK__imported__module__339435__;
732// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/parseSampleRate.js [app-client] (ecmascript)
733;
734function parseSampleRate(sampleRate) {
735    if (typeof sampleRate === "boolean") {
736        return Number(sampleRate);
737    }
738    const rate = typeof sampleRate === "string" ? parseFloat(sampleRate) : sampleRate;
739    if (typeof rate !== "number" || isNaN(rate) || rate < 0 || rate > 1) {
740        return void 0;
741    }
742    return rate;
743}
744;
745__turbopack_context__.s([
746    "parseSampleRate",
747    0,
748    parseSampleRate
749], 170637);
750var __TURBOPACK__imported__module__373382__1 = __TURBOPACK__imported__module__373382__;
751var __TURBOPACK__imported__module__111139__ = __turbopack_context__.i(111139);
752;
753;
754;
755;
756;
757;
758const TRACEPARENT_REGEXP = new RegExp("^[ \\t]*([0-9a-f]{32})?-?([0-9a-f]{16})?-?([01])?[ \\t]*$");
759function extractTraceparentData(traceparent) {
760    if (!traceparent) {
761        return void 0;
762    }
763    const matches = traceparent.match(TRACEPARENT_REGEXP);
764    if (!matches) {
765        return void 0;
766    }
767    let parentSampled;
768    if (matches[3] === "1") {
769        parentSampled = true;
770    } else if (matches[3] === "0") {
771        parentSampled = false;
772    }
773    return {
774        traceId: matches[1],
775        parentSampled,
776        parentSpanId: matches[2]
777    };
778}
779function isContinuingTrace(propagationContext) {
780    return !!propagationContext.parentSpanId || !!propagationContext.dsc;
781}
782function propagationContextFromHeaders(sentryTrace, baggage) {
783    const traceparentData = extractTraceparentData(sentryTrace);
784    const dynamicSamplingContext = (0, __TURBOPACK__imported__module__602309__1["baggageHeaderToDynamicSamplingContext"])(baggage);
785    if (!(traceparentData === null || traceparentData === void 0 ? void 0 : traceparentData.traceId)) {
786        return {
787            traceId: (0, __TURBOPACK__imported__module__373382__1["generateTraceId"])(),
788            sampleRand: (0, __TURBOPACK__imported__module__111139__["safeMathRandom"])()
789        };
790    }
791    const sampleRand = getSampleRandFromTraceparentAndDsc(traceparentData, dynamicSamplingContext);
792    if (dynamicSamplingContext) {
793        dynamicSamplingContext.sample_rand = sampleRand.toString();
794    }
795    const { traceId, parentSpanId, parentSampled } = traceparentData;
796    return {
797        traceId,
798        parentSpanId,
799        sampled: parentSampled,
800        dsc: dynamicSamplingContext || {},
801        // If we have traceparent data but no DSC it means we are not head of trace and we must freeze it
802        sampleRand
803    };
804}
805function generateSentryTraceHeader() {
806    let traceId = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : (0, __TURBOPACK__imported__module__373382__1["generateTraceId"])(), spanId = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : (0, __TURBOPACK__imported__module__373382__1["generateSpanId"])(), sampled = arguments.length > 2 ? arguments[2] : void 0;
807    let sampledString = "";
808    if (sampled !== void 0) {
809        sampledString = sampled ? "-1" : "-0";
810    }
811    return "".concat(traceId, "-").concat(spanId).concat(sampledString);
812}
813function generateTraceparentHeader() {
814    let traceId = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : (0, __TURBOPACK__imported__module__373382__1["generateTraceId"])(), spanId = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : (0, __TURBOPACK__imported__module__373382__1["generateSpanId"])(), sampled = arguments.length > 2 ? arguments[2] : void 0;
815    return "00-".concat(traceId, "-").concat(spanId, "-").concat(sampled ? "01" : "00");
816}
817function getSampleRandFromTraceparentAndDsc(traceparentData, dsc) {
818    const parsedSampleRand = parseSampleRate(dsc === null || dsc === void 0 ? void 0 : dsc.sample_rand);
819    if (parsedSampleRand !== void 0) {
820        return parsedSampleRand;
821    }
822    const parsedSampleRate = parseSampleRate(dsc === null || dsc === void 0 ? void 0 : dsc.sample_rate);
823    if (parsedSampleRate && (traceparentData === null || traceparentData === void 0 ? void 0 : traceparentData.parentSampled) !== void 0) {
824        return traceparentData.parentSampled ? // Returns a sample rand with positive sampling decision [0, sampleRate)
825        (0, __TURBOPACK__imported__module__111139__["safeMathRandom"])() * parsedSampleRate : // Returns a sample rand with negative sampling decision [sampleRate, 1)
826        parsedSampleRate + (0, __TURBOPACK__imported__module__111139__["safeMathRandom"])() * (1 - parsedSampleRate);
827    } else {
828        return (0, __TURBOPACK__imported__module__111139__["safeMathRandom"])();
829    }
830}
831function shouldContinueTrace(client, baggageOrgId) {
832    const clientOrgId = (0, __TURBOPACK__imported__module__339435__1["extractOrgIdFromClient"])(client);
833    if (baggageOrgId && clientOrgId && baggageOrgId !== clientOrgId) {
834        __TURBOPACK__imported__module__272598__["debug"].log("Won't continue trace because org IDs don't match (incoming baggage: ".concat(baggageOrgId, ", SDK options: ").concat(clientOrgId, ")"));
835        return false;

836    }
837    const strictTraceContinuation = client.getOptions().strictTraceContinuation || false;
838    if (strictTraceContinuation) {
839        if (baggageOrgId && !clientOrgId || !baggageOrgId && clientOrgId) {
840            __TURBOPACK__imported__module__272598__["debug"].log("Starting a new trace because strict trace continuation is enabled but one org ID is missing (incoming baggage: ".concat(baggageOrgId, ", Sentry client: ").concat(clientOrgId, ")"));
841            return false;
842        }
843    }
844    return true;
845}
846;
847__turbopack_context__.s([
848    "TRACEPARENT_REGEXP",
849    0,
850    TRACEPARENT_REGEXP,
851    "generateSentryTraceHeader",
852    0,
853    generateSentryTraceHeader,
854    "generateTraceparentHeader",
855    0,
856    generateTraceparentHeader,
857    "propagationContextFromHeaders",
858    0,
859    propagationContextFromHeaders,
860    "shouldContinueTrace",
861    0,
862    shouldContinueTrace
863], 132584);
864var __TURBOPACK__imported__module__272598__1 = __TURBOPACK__imported__module__272598__;
865var __TURBOPACK__imported__module__821061__ = __turbopack_context__.i(821061);
866;
867;
868;
869;
870;
871;
872;
873;
874;
875;
876;
877;
878;
879const TRACE_FLAG_NONE = 0;
880const TRACE_FLAG_SAMPLED = 1;
881let hasShownSpanDropWarning = false;
882function spanToTransactionTraceContext(span) {
883    const { spanId: span_id, traceId: trace_id } = span.spanContext();
884    const { data, op, parent_span_id, status, origin, links } = spanToJSON(span);
885    return {
886        parent_span_id,
887        span_id,
888        trace_id,
889        data,
890        op,
891        status,
892        origin,
893        links
894    };
895}
896function spanToTraceContext(span) {
897    const { spanId, traceId: trace_id, isRemote } = span.spanContext();
898    const parent_span_id = isRemote ? spanId : spanToJSON(span).parent_span_id;
899    const scope = getCapturedScopesOnSpan(span).scope;
900    const span_id = isRemote ? (scope === null || scope === void 0 ? void 0 : scope.getPropagationContext().propagationSpanId) || (0, __TURBOPACK__imported__module__373382__["generateSpanId"])() : spanId;
901    return {
902        parent_span_id,
903        span_id,
904        trace_id
905    };
906}
907function spanToTraceHeader(span) {
908    const { traceId, spanId } = span.spanContext();
909    const sampled = spanIsSampled(span);
910    return generateSentryTraceHeader(traceId, spanId, sampled);
911}
912function spanToTraceparentHeader(span) {
913    const { traceId, spanId } = span.spanContext();
914    const sampled = spanIsSampled(span);
915    return generateTraceparentHeader(traceId, spanId, sampled);
916}
917function convertSpanLinksForEnvelope(links) {
918    if (links && links.length > 0) {
919        return links.map((param)=>{
920            let { context: { spanId, traceId, traceFlags, ...restContext }, attributes } = param;
921            return {
922                span_id: spanId,
923                trace_id: traceId,
924                sampled: traceFlags === TRACE_FLAG_SAMPLED,
925                attributes,
926                ...restContext
927            };
928        });
929    } else {
930        return void 0;
931    }
932}
933function getStreamedSpanLinks(links) {
934    if (links === null || links === void 0 ? void 0 : links.length) {
935        return links.map((param)=>{
936            let { context: { spanId, traceId, traceFlags }, attributes } = param;
937            return {
938                span_id: spanId,
939                trace_id: traceId,
940                sampled: traceFlags === TRACE_FLAG_SAMPLED,
941                attributes
942            };
943        });
944    } else {
945        return void 0;
946    }
947}
948function spanTimeInputToSeconds(input) {
949    if (typeof input === "number") {
950        return ensureTimestampInSeconds(input);
951    }
952    if (Array.isArray(input)) {
953        return input[0] + input[1] / 1e9;
954    }
955    if (input instanceof Date) {
956        return ensureTimestampInSeconds(input.getTime());
957    }
958    return (0, __TURBOPACK__imported__module__605394__["timestampInSeconds"])();
959}
960function ensureTimestampInSeconds(timestamp) {
961    const isMs = timestamp > 9999999999;
962    return isMs ? timestamp / 1e3 : timestamp;
963}
964function spanToJSON(span) {
965    if (spanIsSentrySpan(span)) {
966        return span.getSpanJSON();
967    }
968    const { spanId: span_id, traceId: trace_id } = span.spanContext();
969    if (spanIsOpenTelemetrySdkTraceBaseSpan(span)) {
970        const { attributes, startTime, name, endTime, status, links } = span;
971        return {
972            span_id,
973            trace_id,
974            data: attributes,
975            description: name,
976            parent_span_id: getOtelParentSpanId(span),
977            start_timestamp: spanTimeInputToSeconds(startTime),
978            // This is [0,0] by default in OTEL, in which case we want to interpret this as no end time
979            timestamp: spanTimeInputToSeconds(endTime) || void 0,
980            status: getStatusMessage(status),
981            op: attributes[__TURBOPACK__imported__module__519988__1["SEMANTIC_ATTRIBUTE_SENTRY_OP"]],
982            origin: attributes[__TURBOPACK__imported__module__519988__1["SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN"]],
983            links: convertSpanLinksForEnvelope(links)
984        };
985    }
986    return {
987        span_id,
988        trace_id,
989        start_timestamp: 0,
990        data: {}
991    };
992}
993function spanToStreamedSpanJSON(span) {
994    if (spanIsSentrySpan(span)) {
995        return span.getStreamedSpanJSON();
996    }
997    const { spanId: span_id, traceId: trace_id } = span.spanContext();
998    if (spanIsOpenTelemetrySdkTraceBaseSpan(span)) {
999        const { attributes, startTime, name, endTime, status, links } = span;
1000        return {
1001            name,
1002            span_id,
1003            trace_id,
1004            parent_span_id: getOtelParentSpanId(span),
1005            start_timestamp: spanTimeInputToSeconds(startTime),
1006            end_timestamp: spanTimeInputToSeconds(endTime),
1007            is_segment: span === INTERNAL_getSegmentSpan(span),
1008            status: getSimpleStatus(status),
1009            attributes: addStatusMessageAttribute(attributes, status),
1010            links: getStreamedSpanLinks(links)
1011        };
1012    }
1013    return {
1014        span_id,
1015        trace_id,
1016        start_timestamp: 0,
1017        name: "",
1018        end_timestamp: 0,
1019        status: "ok",
1020        is_segment: span === INTERNAL_getSegmentSpan(span)
1021    };
1022}
1023function getOtelParentSpanId(span) {
1024    var _span_parentSpanContext;
1025    return "parentSpanId" in span ? span.parentSpanId : "parentSpanContext" in span ? (_span_parentSpanContext = span.parentSpanContext) === null || _span_parentSpanContext === void 0 ? void 0 : _span_parentSpanContext.spanId : void 0;
1026}
1027function streamedSpanJsonToSerializedSpan(spanJson) {
1028    var _spanJson_links;
1029    return {

1030        ...spanJson,
1031        attributes: (0, __TURBOPACK__imported__module__759075__["serializeAttributes"])(spanJson.attributes),
1032        links: (_spanJson_links = spanJson.links) === null || _spanJson_links === void 0 ? void 0 : _spanJson_links.map((link)=>({
1033                ...link,
1034                attributes: (0, __TURBOPACK__imported__module__759075__["serializeAttributes"])(link.attributes)
1035            }))
1036    };
1037}
1038function spanIsOpenTelemetrySdkTraceBaseSpan(span) {
1039    const castSpan = span;
1040    return !!castSpan.attributes && !!castSpan.startTime && !!castSpan.name && !!castSpan.endTime && !!castSpan.status;
1041}
1042function spanIsSentrySpan(span) {
1043    return typeof span.getSpanJSON === "function";
1044}
1045function spanIsSampled(span) {
1046    const { traceFlags } = span.spanContext();
1047    return traceFlags === TRACE_FLAG_SAMPLED;
1048}
1049function getStatusMessage(status) {
1050    if (!status || status.code === SPAN_STATUS_UNSET) {
1051        return void 0;
1052    }
1053    if (status.code === SPAN_STATUS_OK) {
1054        return "ok";
1055    }
1056    return status.message || "internal_error";
1057}
1058function getSimpleStatus(status) {
1059    return !status || status.code === SPAN_STATUS_OK || status.code === SPAN_STATUS_UNSET || status.message === "cancelled" ? "ok" : "error";
1060}
1061function addStatusMessageAttribute(attributes, status) {
1062    const statusMessage = getSimpleStatus(status) === "error" ? status === null || status === void 0 ? void 0 : status.message : void 0;
1063    return {
1064        ...statusMessage && {
1065            [__TURBOPACK__imported__module__519988__1["SEMANTIC_ATTRIBUTE_SENTRY_STATUS_MESSAGE"]]: statusMessage
1066        },
1067        ...attributes
1068    };
1069}
1070const CHILD_SPANS_FIELD = "_sentryChildSpans";
1071const ROOT_SPAN_FIELD = "_sentryRootSpan";
1072function addChildSpanToSpan(span, childSpan) {
1073    const rootSpan = span[ROOT_SPAN_FIELD] || span;
1074    (0, __TURBOPACK__imported__module__951497__2["addNonEnumerableProperty"])(childSpan, ROOT_SPAN_FIELD, rootSpan);
1075    if (!spanIsSampled(span)) {
1076        return;
1077    }
1078    if (!span.isRecording() && !rootSpan.isRecording()) {
1079        return;
1080    }
1081    if (span[CHILD_SPANS_FIELD]) {
1082        span[CHILD_SPANS_FIELD].add(childSpan);
1083    } else {
1084        (0, __TURBOPACK__imported__module__951497__2["addNonEnumerableProperty"])(span, CHILD_SPANS_FIELD, /* @__P

1084URE__ */ new Set([
1085            childSpan
1086        ]));
1087    }
1088}
1089function removeChildSpanFromSpan(span, childSpan) {
1090    if (span[CHILD_SPANS_FIELD]) {
1091        span[CHILD_SPANS_FIELD].delete(childSpan);
1092    }
1093}
1094function getSpanDescendants(span) {
1095    const resultSet = /* @__PURE__ */ new Set();
1096    function addSpanChildren(span2) {
1097        if (resultSet.has(span2)) {
1098            return;
1099        } else if (spanIsSampled(span2)) {
1100            resultSet.add(span2);
1101            const childSpans = span2[CHILD_SPANS_FIELD] ? Array.from(span2[CHILD_SPANS_FIELD]) : [];
1102            for (const childSpan of childSpans){
1103                addSpanChildren(childSpan);
1104            }
1105        }
1106    }
1107    addSpanChildren(span);
1108    return Array.from(resultSet);
1109}
1110const getRootSpan = INTERNAL_getSegmentSpan;
1111function INTERNAL_getSegmentSpan(span) {
1112    return span[ROOT_SPAN_FIELD] || span;
1113}
1114function getActiveSpan() {
1115    const carrier = (0, __TURBOPACK__imported__module__923288__["getMainCarrier"])();
1116    const acs = (0, __TURBOPACK__imported__module__301263__["getAsyncContextStrategy"])(carrier);
1117    if (acs.getActiveSpan) {
1118        return acs.getActiveSpan();
1119    }
1120    return (0, __TURBOPACK__imported__module__821061__["_getSpanForScope"])((0, __TURBOPACK__imported__module__250804__2["getCurrentScope"])());
1121}
1122function showSpanDropWarning() {
1123    if (!hasShownSpanDropWarning) {
1124        (0, __TURBOPACK__imported__module__272598__1["consoleSandbox"])(()=>{
1125            console.warn("[Sentry] Returning null from `beforeSendSpan` is disallowed. To drop certain spans, configure the respective integrations directly or use `ignoreSpans`.");
1126        });
1127        hasShownSpanDropWarning = true;
1128    }
1129}
1130function updateSpanName(span, name) {
1131    span.updateName(name);
1132    span.setAttributes({
1133        [__TURBOPACK__imported__module__519988__1["SEMANTIC_ATTRIBUTE_SENTRY_SOURCE"]]: "custom",
1134        [__TURBOPACK__imported__module__519988__1["SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME"]]: name
1135    });
1136}
1137;
1138__turbopack_context__.s([
1139    "INTERNAL_getSegmentSpan",
1140    0,
1141    INTERNAL_getSegmentSpan,
1142    "TRACE_FLAG_NONE",
1143    0,
1144    TRACE_FLAG_NONE,
1145    "TRACE_FLAG_SAMPLED",
1146    0,
1147    TRACE_FLAG_SAMPLED,
1148    "addChildSpanToSpan",
1149    0,
1150    addChildSpanToSpan,
1151    "addStatusMessageAttribute",
1152    0,
1153    addStatusMessageAttribute,
1154    "convertSpanLinksForEnvelope",
1155    0,
1156    convertSpanLinksForEnvelope,
1157    "getActiveSpan",
1158    0,
1159    getActiveSpan,
1160    "getRootSpan",
1161    0,
1162    getRootSpan,
1163    "getSimpleStatus",
1164    0,
1165    getSimpleStatus,
1166    "getSpanDescendants",
1167    0,
1168    getSpanDescendants,
1169    "getStatusMessage",
1170    0,
1171    getStatusMessage,
1172    "getStreamedSpanLinks",
1173    0,
1174    getStreamedSpanLinks,
1175    "removeChildSpanFromSpan",
1176    0,
1177    removeChildSpanFromSpan,
1178    "showSpanDropWarning",
1179    0,
1180    showSpanDropWarning,
1181    "spanIsSampled",
1182    0,
1183    spanIsSampled,
1184    "spanTimeInputToSeconds",
1185    0,
1186    spanTimeInputToSeconds,
1187    "spanToJSON",
1188    0,
1189    spanToJSON,
1190    "spanToStreamedSpanJSON",
1191    0,
1192    spanToStreamedSpanJSON,
1193    "spanToTraceContext",
1194    0,
1195    spanToTraceContext,
1196    "spanToTraceHeader",
1197    0,
1198    spanToTraceHeader,
1199    "spanToTraceparentHeader",
1200    0,
1201    spanToTraceparentHeader,
1202    "spanToTransactionTraceContext",
1203    0,
1204    spanToTransactionTraceContext,
1205    "streamedSpanJsonToSerializedSpan",
1206    0,
1207    streamedSpanJsonToSerializedSpan
1208], 304661);
1209// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/tracing/sentryNonRecordingSpan.js [app-client] (ecmascript)
1210;
1211var __TURBOPACK__imported__module__951497__3 = __TURBOPACK__imported__module__951497__;
1212var __TURBOPACK__imported__module__373382__2 = __TURBOPACK__imported__module__373382__;
1213;
1214;
1215;
1216const NON_RECORDING_SPAN_FIELD = /* @__PURE__ */ Symbol.for("sentry.nonRecordingSpan");
1217class SentryNonRecordingSpan {
1218    /** @inheritdoc */ spanContext() {
1219        return {
1220            spanId: this._spanId,
1221            traceId: this._traceId,
1222            traceFlags: TRACE_FLAG_NONE
1223        };
1224    }
1225    /** @inheritdoc */ end(_timestamp) {}
1226    /** @inheritdoc */ setAttribute(_key, _value) {
1227        return this;
1228    }
1229    /** @inheritdoc */ setAttributes(_values) {
1230        return this;
1231    }
1232    /** @inheritdoc */ setStatus(_status) {
1233        return this;
1234    }
1235    /** @inheritdoc */ updateName(_name) {
1236        return this;
1237    }
1238    /** @inheritdoc */ isRecording() {
1239        return false;

1240    }
1241    /** @inheritdoc */ addEvent(_name, _attributesOrStartTime, _startTime) {
1242        return this;
1243    }
1244    /** @inheritDoc */ addLink(_link) {
1245        return this;
1246    }
1247    /** @inheritDoc */ addLinks(_links) {
1248        return this;
1249    }
1250    /**
1251   * This should generally not be used,
1252   * but we need it for being compliant with the OTEL Span interface.
1253   *
1254   * @hidden
1255   * @internal
1256   */ recordException(_exception, _time) {}
1257    constructor(spanContext = {}){
1258        this._traceId = spanContext.traceId || (0, __TURBOPACK__imported__module__373382__2["generateTraceId"])();
1259        this._spanId = spanContext.spanId || (0, __TURBOPACK__imported__module__373382__2["generateSpanId"])();
1260        this.dropReason = spanContext.dropReason;
1261        (0, __TURBOPACK__imported__module__951497__3["addNonEnumerableProperty"])(this, NON_RECORDING_SPAN_FIELD, true);
1262    }
1263}
1264function spanIsNonRecordingSpan(span) {
1265    return !!span && span[NON_RECORDING_SPAN_FIELD] === true;
1266}
1267;
1268__turbopack_context__.s([
1269    "SentryNonRecordingSpan",
1270    0,
1271    SentryNonRecordingSpan,
1272    "spanIsNonRecordingSpan",
1273    0,
1274    spanIsNonRecordingSpan
1275], 728469);
1276;
1277;
1278;
1279;
1280;
1281;
1282;
1283;
1284;
1285;
1286const FROZEN_DSC_FIELD = "_frozenDsc";
1287function freezeDscOnSpan(span, dsc) {
1288    const spanWithMaybeDsc = span;
1289    (0, __TURBOPACK__imported__module__951497__["addNonEnumerableProperty"])(spanWithMaybeDsc, FROZEN_DSC_FIELD, dsc);
1290}
1291function getDynamicSamplingContextFromClient(trace_id, client) {
1292    const options = client.getOptions();
1293    const { publicKey: public_key } = client.getDsn() || {};
1294    const dsc = {
1295        environment: options.environment || __TURBOPACK__imported__module__373250__["DEFAULT_ENVIRONMENT"],
1296        release: options.release,
1297        public_key,
1298        trace_id,
1299        org_id: (0, __TURBOPACK__imported__module__339435__["extractOrgIdFromClient"])(client)
1300    };
1301    client.emit("createDsc", dsc);
1302    return dsc;
1303}
1304function getDynamicSamplingContextFromScope(client, scope) {
1305    const propagationContext = scope.getPropagationContext();
1306    return propagationContext.dsc || getDynamicSamplingContextFromClient(propagationContext.traceId, client);
1307}
1308function getDynamicSamplingContextFromSpan(span) {
1309    var _ref, _ref1, _rootSpanAttributes_SEMANTIC_ATTRIBUTE_SENTRY_SOURCE;
1310    const client = (0, __TURBOPACK__imported__module__250804__1["getClient"])();
1311    if (!client) {
1312        return {};
1313    }
1314    const rootSpan = getRootSpan(span);
1315    const rootSpanJson = spanToJSON(rootSpan);
1316    const rootSpanAttributes = rootSpanJson.data;
1317    const traceState = rootSpan.spanContext().traceState;
1318    const rootSpanSampleRate = (_ref = (_ref1 = traceState === null || traceState === void 0 ? void 0 : traceState.get("sentry.sample_rate")) !== null && _ref1 !== void 0 ? _ref1 : rootSpanAttributes[__TURBOPACK__imported__module__519988__["SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE"]]) !== null && _ref !== void 0 ? _ref : rootSpanAttributes[__TURBOPACK__imported__module__519988__["SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE"]];
1319    function applyLocalSampleRateToDsc(dsc2) {
1320        if (typeof rootSpanSampleRate === "number" || typeof rootSpanSampleRate === "string") {
1321            dsc2.sample_rate = "".concat(rootSpanSampleRate);
1322        }
1323        return dsc2;
1324    }
1325    const frozenDsc = rootSpan[FROZEN_DSC_FIELD];
1326    if (frozenDsc) {
1327        return applyLocalSampleRateToDsc(frozenDsc);
1328    }
1329    const isNonRecordingRoot = spanIsNonRecordingSpan(rootSpan);
1330    const isIgnoredRoot = isNonRecordingRoot && rootSpan.dropReason === "ignored";
1331    if (isNonRecordingRoot && (!(0, __TURBOPACK__imported__module__10008__["hasSpansEnabled"])(client.getOptions()) || isIgnoredRoot)) {
1332        const capturedScope = getCapturedScopesOnSpan(rootSpan).scope;
1333        if (capturedScope) {
1334            const dsc2 = {
1335                ...getDynamicSamplingContextFromScope(client, capturedScope)
1336            };
1337            if (isIgnoredRoot) {
1338                dsc2.sampled = "false";
1339            }
1340            return applyLocalSampleRateToDsc(dsc2);
1341        }
1342    }
1343    const traceStateDsc = traceState === null || traceState === void 0 ? void 0 : traceState.get("sentry.dsc");
1344    const dscOnTraceState = traceStateDsc && (0, __TURBOPACK__imported__module__602309__["baggageHeaderToDynamicSamplingContext"])(traceStateDsc);
1345    if (dscOnTraceState) {

1346        return applyLocalSampleRateToDsc(dscOnTraceState);
1347    }
1348    const dsc = getDynamicSamplingContextFromClient(span.spanContext().traceId, client);
1349    const source = (_rootSpanAttributes_SEMANTIC_ATTRIBUTE_SENTRY_SOURCE = rootSpanAttributes[__TURBOPACK__imported__module__519988__["SEMANTIC_ATTRIBUTE_SENTRY_SOURCE"]]) !== null && _rootSpanAttributes_SEMANTIC_ATTRIBUTE_SENTRY_SOURCE !== void 0 ? _rootSpanAttributes_SEMANTIC_ATTRIBUTE_SENTRY_SOURCE : rootSpanAttributes["sentry.segment.name.source"];
1350    const name = rootSpanJson.description;
1351    if (source !== "url" && name) {
1352        dsc.transaction = name;
1353    }
1354    if ((0, __TURBOPACK__imported__module__10008__["hasSpansEnabled"])()) {
1355        var _ref2;
1356        var // On all other platforms we can actually get the scopes from a root span (we use this as a fallback)
1357        _getCapturedScopesOnSpan_scope;
1358        dsc.sampled = String(spanIsSampled(rootSpan));
1359        dsc.sample_rand = (_ref2 = // The Sentry OTEL SpanSampler takes care of writing the sample rand on the root span
1360        traceState === null || traceState === void 0 ? void 0 : traceState.get("sentry.sample_rand")) !== null && _ref2 !== void 0 ? _ref2 : (_getCapturedScopesOnSpan_scope = getCapturedScopesOnSpan(rootSpan).scope) === null || _getCapturedScopesOnSpan_scope === void 0 ? void 0 : _getCapturedScopesOnSpan_scope.getPropagationContext().sampleRand.toString();
1361    }
1362    applyLocalSampleRateToDsc(dsc);
1363    client.emit("createDsc", dsc, rootSpan);
1364    return dsc;
1365}
1366function spanToBaggageHeader(span) {
1367    const dsc = getDynamicSamplingContextFromSpan(span);
1368    return (0, __TURBOPACK__imported__module__602309__["dynamicSamplingContextToSentryBaggageHeader"])(dsc);
1369}
1370;
1371__turbopack_context__.s([
1372    "freezeDscOnSpan",
1373    0,
1374    freezeDscOnSpan,
1375    "getDynamicSamplingContextFromScope",
1376    0,
1377    getDynamicSamplingContextFromScope,
1378    "getDynamicSamplingContextFromSpan",
1379    0,
1380    getDynamicSamplingContextFromSpan
1381], 473753);
1382var __TURBOPACK__imported__module__318746__ = __turbopack_context__.i(318746);
1383;
1384;
1385;
1386;
1387function applyScopeDataToEvent(event, data) {
1388    const { fingerprint, span, breadcrumbs, sdkProcessingMetadata } = data;
1389    applyDataToEvent(event, data);
1390    if (span) {
1391        applySpanToEvent(event, span);
1392    }
1393    applyFingerprintToEvent(event, fingerprint);
1394    applyBreadcrumbsToEvent(event, breadcrumbs);
1395    applySdkMetadataToEvent(event, sdkProcessingMetadata);
1396}
1397function mergeScopeData(data, mergeData) {
1398    const { extra, tags, attributes, user, contexts, level, sdkProcessingMetadata, breadcrumbs, fingerprint, eventProcessors, attachments, propagationContext, transactionName, span } = mergeData;
1399    mergeAndOverwriteScopeData(data, "extra", extra);
1400    mergeAndOverwriteScopeData(data, "tags", tags);
1401    mergeAndOverwriteScopeData(data, "attributes", attributes);
1402    mergeAndOverwriteScopeData(data, "user", user);
1403    mergeAndOverwriteScopeData(data, "contexts", contexts);
1404    data.sdkProcessingMetadata = (0, __TURBOPACK__imported__module__318746__["merge"])(data.sdkProcessingMetadata, sdkProcessingMetadata, 2);
1405    if (level) {
1406        data.level = level;
1407    }
1408    if (transactionName) {
1409        data.transactionName = transactionName;
1410    }
1411    if (span) {
1412        data.span = span;
1413    }
1414    if (breadcrumbs.length) {
1415        data.breadcrumbs = [
1416            ...data.breadcrumbs,
1417            ...breadcrumbs
1418        ];
1419    }
1420    if (fingerprint.length) {
1421        data.fingerprint = [
1422            ...data.fingerprint,
1423            ...fingerprint
1424        ];
1425    }
1426    if (eventProcessors.length) {
1427        data.eventProcessors = [
1428            ...data.eventProcessors,
1429            ...eventProcessors
1430        ];
1431    }
1432    if (attachments.length) {
1433        data.attachments = [
1434            ...data.attachments,
1435            ...attachments
1436        ];
1437    }
1438    data.propagationContext = {
1439        ...data.propagationContext,
1440        ...propagationContext
1441    };
1442}
1443function mergeAndOverwriteScopeData(data, prop, mergeVal) {
1444    data[prop] = (0, __TURBOPACK__imported__module__318746__["merge"])(data[prop], mergeVal, 1);
1445}
1446function getCombinedScopeData(isolationScope, currentScope) {
1447    const scopeData = (0, __TURBOPACK__imported__module__250804__["getGlobalScope"])().getScopeData();
1448    isolationScope && mergeScopeData(scopeData, isolationScope.getScopeData());
1449    currentScope && mergeScopeData(scopeData, currentScope.getScopeData());
1450    return scopeData;
1451}
1452function applyDataToEvent(event, data) {
1453    const { extra, tags, user, contexts, level, transactionName } = data;
1454    if (Object.keys(extra).length) {
1455        event.extra = {
1456            ...extra,
1457            ...event.extra
1458        };
1459    }
1460    if (Object.keys(tags).length) {
1461        event.tags = {
1462            ...tags,
1463            ...event.tags
1464        };
1465    }
1466    if (Object.keys(user).length) {
1467        event.user = {
1468            ...user,
1469            ...event.user
1470        };
1471    }
1472    if (Object.keys(contexts).length) {
1473        event.contexts = {
1474            ...contexts,
1475            ...event.contexts
1476        };
1477    }
1478    if (level) {
1479        event.level = level;
1480    }
1481    if (transactionName && event.type !== "transaction") {
1482        event.transaction = transactionName;
1483    }
1484}
1485function applyBreadcrumbsToEvent(event, breadcrumbs) {
1486    const mergedBreadcrumbs = [
1487        ...event.breadcrumbs || [],
1488        ...breadcrumbs
1489    ];
1490    event.breadcrumbs = mergedBreadcrumbs.length ? mergedBreadcrumbs : void 0;
1491}
1492function applySdkMetadataToEvent(event, sdkProcessingMetadata) {
1493    event.sdkProcessingMetadata = {
1494        ...event.sdkProcessingMetadata,
1495        ...sdkProcessingMetadata
1496    };
1497}
1498function applySpanToEvent(event, span) {
1499    event.contexts = {
1500        trace: spanToTraceContext(span),
1501        ...event.contexts
1502    };
1503    event.sdkProcessingMetadata = {
1504        dynamicSamplingContext: getDynamicSamplingContextFromSpan(span),
1505        ...event.sdkProcessingMetadata
1506    };
1507    const rootSpan = getRootSpan(span);
1508    const transactionName = spanToJSON(rootSpan).description;
1509    if (transactionName && !event.transaction && event.type === "transaction") {
1510        event.transaction = transactionName;
1511    }
1512}
1513function applyFingerprintToEvent(event, fingerprint) {
1514    event.fingerprint = event.fingerprint ? Array.isArray(event.fingerprint) ? event.fingerprint : [
1515        event.fingerprint
1516    ] : [];
1517    if (fingerprint) {
1518        event.fingerprint = event.fingerprint.concat(fingerprint);
1519    }
1520    if (!event.fingerprint.length) {
1521        delete event.fingerprint;
1522    }
1523}
1524;
1525__turbopack_context__.s([
1526    "applyScopeDataToEvent",
1527    0,
1528    applyScopeDataToEvent,
1529    "getCombinedScopeData",
1530    0,
1531    getCombinedScopeData
1532], 571993);
1533}),
1534662537, 580611, 
1535213186, 
1536((__turbopack_context__) => {
1537"use strict";
1538
1539// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/exports.js [app-client] (ecmascript)
1540;
1541var __TURBOPACK__imported__module__250804__ = __turbopack_context__.i(250804);
1542var __TURBOPACK__imported__module__901020__ = __turbopack_context__.i(901020

1542);
1543var __TURBOPACK__imported__module__341041__ = __turbopack_context__.i(341041);
1544var __TURBOPACK__imported__module__272598__ = __turbopack_context__.i(272598);
1545// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/prepareEvent.js [app-client] (ecmascript)
1546;
1547var __TURBOPACK__imported__module__373250__ = __turbopack_context__.i(373250);
1548// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/eventProcessors.js [app-client] (ecmascript)
1549;
1550var __TURBOPACK__imported__module__901020__1 = __TURBOPACK__imported__module__901020__;
1551var __TURBOPACK__imported__module__272598__1 = __TURBOPACK__imported__module__272598__;
1552var __TURBOPACK__imported__module__453288__ = __turbopack_context__.i(453288);
1553// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/syncpromise.js [app-client] (ecmascript)
1554;
1555var __TURBOPACK__imported__module__453288__1 = __TURBOPACK__imported__module__453288__;
1556;
1557const STATE_PENDING = 0;
1558const STATE_RESOLVED = 1;
1559const STATE_REJECTED = 2;
1560function resolvedSyncPromise(value) {
1561    return new SyncPromise((resolve)=>{
1562        resolve(value);
1563    });
1564}
1565function rejectedSyncPromise(reason) {
1566    return new SyncPromise((_, reject)=>{
1567        reject(reason);
1568    });
1569}
1570class SyncPromise {
1571    /** @inheritdoc */ then(onfulfilled, onrejected) {
1572        return new SyncPromise((resolve, reject)=>{
1573            this._handlers.push([
1574                false,
1575                (result)=>{
1576                    if (!onfulfilled) {
1577                        resolve(result);
1578                    } else {
1579                        try {
1580                            resolve(onfulfilled(result));
1581                        } catch (e) {
1582                            reject(e);
1583                        }
1584                    }
1585                },
1586                (reason)=>{
1587                    if (!onrejected) {
1588                        reject(reason);
1589                    } else {
1590                        try {
1591                            resolve(onrejected(reason));
1592                        } catch (e) {
1593                            reject(e);
1594                        }
1595                    }
1596                }
1597            ]);
1598            this._executeHandlers();
1599        });
1600    }
1601    /** @inheritdoc */ catch(onrejected) {
1602        return this.then((val)=>val, onrejected);
1603    }
1604    /** @inheritdoc */ finally(onfinally) {
1605        return new SyncPromise((resolve, reject)=>{
1606            let val;
1607            let isRejected;
1608            return this.then((value)=>{
1609                isRejected = false;
1610                val = value;
1611                if (onfinally) {
1612                    onfinally();
1613                }
1614            }, (reason)=>{
1615                isRejected = true;
1616                val = reason;
1617                if (onfinally) {
1618                    onfinally();
1619                }
1620            }).then(()=>{
1621                if (isRejected) {
1622                    reject(val);
1623                    return;
1624                }
1625                resolve(val);
1626            });
1627        });
1628    }
1629    /** Excute the resolve/reject handlers. */ _executeHandlers() {
1630        if (this._state === STATE_PENDING) {
1631            return;
1632        }
1633        const cachedHandlers = this._handlers.slice();
1634        this._handlers = [];
1635        cachedHandlers.forEach((handler)=>{
1636            if (handler[0]) {
1637                return;
1638            }
1639            if (this._state === STATE_RESOLVED) {
1640                handler[1](this._value);
1641            }
1642            if (this._state === STATE_REJECTED) {
1643                handler[2](this._value);
1644            }
1645            handler[0] = true;
1646        });
1647    }
1648    /** Run the executor for the SyncPromise. */ _runExecutor(executor) {
1649        const setResult = (state, value)=>{
1650            if (this._state !== STATE_PENDING) {
1651                return;
1652            }
1653            if ((0, __TURBOPACK__imported__module__453288__1["isThenable"])(value)) {
1654                void value.then(resolve, reject);
1655                return;
1656            }
1657            this._state = state;
1658            this._value = value;
1659            this._executeHandlers();
1660        };
1661        const resolve = (value)=>{
1662            setResult(STATE_RESOLVED, value);
1663        };
1664        const reject = (reason)=>{
1665            setResult(STATE_REJECTED, reason);
1666        };
1667        try {
1668            executor(resolve, reject);
1669        } catch (e) {
1670            reject(e);
1671        }
1672    }
1673    constructor(executor){
1674        this._state = STATE_PENDING;
1675        this._handlers = [];
1676        this._runExecutor(executor);
1677    }
1678}
1679;
1680__turbopack_context__.s([
1681    "rejectedSyncPromise",
1682    0,
1683    rejectedSyncPromise,
1684    "resolvedSyncPromise",
1685    0,
1686    resolvedSyncPromise
1687], 580611);
1688;
1689;
1690;
1691;
1692function notifyEventProcessors(processors, event, hint) {
1693    let index = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0;
1694    try {
1695        const result = _notifyEventProcessors(event, hint, processors, index);
1696        return (0, __TURBOPACK__imported__module__453288__["isThenable"])(result) ? result : resolvedSyncPromise(result);
1697    } catch (error) {
1698        return rejectedSyncPromise(error);
1699    }
1700}
1701function _notifyEventProcessors(event, hint, processors, index) {
1702    const processor = processors[index];
1703    if (!event || !processor) {
1704        return event;
1705    }
1706    const result = processor({
1707        ...event
1708    }, hint);
1709    __TURBOPACK__imported__module__901020__1["DEBUG_BUILD"] && result === null && __TURBOPACK__imported__module__272598__1["debug"].log('Event processor "'.concat(processor.id || "?", '" dropped event'));
1710    if ((0, __TURBOPACK__imported__module__453288__["isThenable"])(result)) {
1711        return result.then((final)=>_notifyEventProcessors(final, hint, processors, index + 1));
1712    }
1713    return _notifyEventProcessors(result, hint, processors, index + 1);
1714}
1715;
1716var __TURBOPACK__imported__module__994218__ = __turbopack_context__.i(994218);
1717// MERGED MODULE: [project]/node_modules/@sentry/core/build/esm/utils/debug-ids.js [app-client] (ecmascript)
1718;
1719var __TURBOPACK__imported__module__936032__ = __turbopack_context__.i(936032);
1720var __TURBOPACK__imported__module__225304__ = __turbopack_context__.i(225304);
1721;
1722;
1723let parsedStackResults;
1724let lastSentryKeysCount;
1725let lastNativeKeysCount;
1726let cachedFilenameDebugIds;
1727function getFilenameToDebugIdMap(stackParser) {
1728    const sentryDebugIdMap = __TURBOPACK__imported__module__225304__["GLOBAL_OBJ"]._sentryDebugIds;
1729    const nativeDebugIdMap = __TURBOPACK__imported__module__225304__["GLOBAL_OBJ"]._debugIds;
1730    if (!sentryDebugIdMap && !nativeDebugIdMap) {
1731        return {};
1732    }
1733    const sentryDebugIdKeys = sentryDebugIdMap ? Object.keys(sentryDebugIdMap) : [];
1734    const nativeDebugIdKeys = nativeDebugIdMap ? Object.keys(nativeDebugIdMap) : [];
1735    if (cachedFilenameDebugIds && sentryDebugIdKeys.length === lastSentryKeysCount && nativeDebugIdKeys.length === lastNativeKeysCount) {
1736        return cachedFilenameDebugIds;
1737    }
1738    lastSentryKeysCount = sentryDebugIdKeys.length;
1739    lastNativeKeysCount = nativeDebugIdKeys.length;
1740    cachedFilenameDebugIds = {};
1741    if (!parsedStackResults) {
1742        parsedStackResults = {};
1743    }
1744    const processDebugIds = (debugIdKeys, debugIdMap)=>{
1745        for (const key of debugIdKeys){
1746            const debugId = debugIdMap[key];
1747            const result = parsedStackResults === null || parsedStackResults === void 0 ? void 0 : parsedStackResults[key];
1748            if (result && cachedFilenameDebugIds && debugId) {
1749                cachedFilenameDebugIds[result[0]] = debugId;
1750                if (parsedStackResults) {
1751                    parsedStackResults[key] = [
1752                        result[0],
1753                        debugId
1754                    ];
1755                }
1756            } else if (debugId) {
1757                const parsedStack = stackParser(key);
1758                for(let i = parsedStack.length - 1; i >= 0; i--){
1759                    const stackFrame = parsedStack[i];
1760                    const filename = stackFrame === null || stackFrame === void 0 ? void 0 : stackFrame.filename;
1761                    if (filename && cachedFilenameDebugIds && parsedStackResults) {
1762                        cachedFilenameDebugIds[filename] = debugId;
1763                        parsedStackResults[key] = [
1764                            filename,
1765                            debugId
1766                        ];
1767                        break;
1768                    }
1769                }
1770            }
1771        }
1772    };
1773    if (sentryDebugIdMap) {
1774        processDebugIds(sentryDebugIdKeys, sentryDebugIdMap);
1775    }
1776    if (nativeDebugIdMap) {
1777        processDebugIds(nativeDebugIdKeys, nativeDebugIdMap);
1778    }
1779    return cachedFilenameDebugIds;
1780}
1781function getDebugImagesForResources(stackParser, resource_paths) {
1782    const filenameDebugIdMap = getFilenameToDebugIdMap(stackParser);
1783    if (!filenameDebugIdMap) {
1784        return [];
1785    }
1786    const images = [];
1787    for (const path of resource_paths){
1788        const normalizedPath = (0, __TURBOPACK__imported__module__936032__["normalizeStackTracePath"])(path);
1789        if (normalizedPath && filenameDebugIdMap[normalizedPath]) {
1790            images.push({
1791                type: "sourcemap",
1792                code_file: path,
1793                debug_id: filenameDebugIdMap[normalizedPath]
1794            });
1795        }
1796    }
1797    return images;
1798}
1799;
1800var __TURBOPACK__imported__module__682564__ = __turbopack_context__.i(682564);
1801var __TURBOPACK__imported__module__45968__ = __turbopack_context__.i(45968);
1802var __TURBOPACK__imported__module__571993__ = __turbopack_context__.i(571993);
1803var __TURBOPACK__imported__module__821593__ = __turbopack_context__.i(821593);
1804var __TURBOPACK__imported__module__605394__ = __turbopack_context__.i(605394);
1805;
1806;
1807;
1808;
1809;
1810;
1811;
1812;
1813;
1814;
1815function prepareEvent(options, event, hint, scope, client, isolationScope) {
1816    const { normalizeDepth = 3, normalizeMaxBreadth = 1e3 } = options;
1817    const prepared = {
1818        ...event,
1819        event_id: event.event_id || hint.event_id || (0, __TURBOPACK__imported__module__682564__["uuid4"])(),
1820        timestamp: event.timestamp || (0, __TURBOPACK__imported__module__605394__["dateTimestampInSeconds"])()
1821    };
1822    const integrations = hint.integrations || options.integrations.map((i)=>i.name);
1823    applyClientOptions(prepared, options);
1824    applyIntegrationsMetadata(prepared, integrations);
1825    if (client) {
1826        client.emit("applyFrameMetadata", event);
1827    }
1828    if (event.type === void 0) {
1829        applyDebugIds(prepared, options.stackParser);
1830    }
1831    const finalScope = getFinalScope(scope, hint.captureContext);
1832    if (hint.mechanism) {
1833        (0, __TURBOPACK__imported__module__682564__["addExceptionMechanism"])(prepared, hint.mechanism);
1834    }
1835    const clientEventProcessors = client ? client.getEventProcessors() : [];
1836    const data = (0, __TURBOPACK__imported__module__571993__["getCombinedScopeData"])(isolationScope, finalScope);
1837    const attachments = [
1838        ...hint.attachments || [],
1839        ...data.attachments
1840    ];
1841    if (attachments.length) {
1842        hint.attachments = attachments;
1843    }
1844    (0, __TURBOPACK__imported__module__571993__["applyScopeDataToEvent"])(prepared, data);
1845    const eventProcessors = [
1846        ...clientEventProcessors,
1847        // Run scope event processors _after_ all other processors
1848        ...data.eventProcessors
1849    ];
1850    const isInternalException = hint.data && hint.data.__sentry__ === true;
1851    const result = isInternalException ? resolvedSyncPromise(prepared) : notifyEventProcessors(eventProcessors, prepared, hint);
1852    return result.then((evt)=>{
1853        if (evt) {
1854            applyDebugMeta(evt);
1855        }
1856        if (typeof normalizeDepth === "number" && normalizeDepth > 0) {
1857            return normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);
1858        }
1859        return evt;
1860    });
1861}
1862function applyClientOptions(event, options) {
1863    const { environment, release, dist, maxValueLength } = options;
1864    event.environment = event.environment || environment || __TURBOPACK__imported__module__373250__["DEFAULT_ENVIRONMENT"];
1865    if (!event.release && release) {
1866        event.release = release;
1867    }
1868    if (!event.dist && dist) {
1869        event.dist = dist;
1870    }
1871    const request = event.request;
1872    if ((request === null || request === void 0 ? void 0 : request.url) && maxValueLength) {
1873        request.url = (0, __TURBOPACK__imported__module__821593__["truncate"])(request.url, maxValueLength);
1874    }
1875    if (maxValueLength) {
1876        var _event_exception_values, _event_exception;
1877        (_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.forEac

1877h((exception)=>{
1878            if (exception.value) {
1879                exception.value = (0, __TURBOPACK__imported__module__821593__["truncate"])(exception.value, maxValueLength);
1880            }
1881        });
1882    }
1883}
1884function applyDebugIds(event, stackParser) {
1885    var _event_exception_values, _event_exception;
1886    const filenameDebugIdMap = getFilenameToDebugIdMap(stackParser);
1887    (_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.forEach((exception)=>{
1888        var _exception_stacktrace_frames, _exception_stacktrace;
1889        (_exception_stacktrace = exception.stacktrace) === null || _exception_stacktrace === void 0 ? void 0 : (_exception_stacktrace_frames = _exception_stacktrace.frames) === null || _exception_stacktrace_frames === void 0 ? void 0 : _exception_stacktrace_frames.forEach((frame)=>{
1890            if (frame.filename) {
1891                frame.debug_id = filenameDebugIdMap[frame.filename];
1892            }
1893        });
1894    });
1895}
1896function applyDebugMeta(event) {
1897    var _event_exception_values, _event_exception;
1898    const filenameDebugIdMap = {};
1899    (_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.forEach((exception)=>{
1900        var _exception_stacktrace_frames, _exception_stacktrace;
1901        (_exception_stacktrace = exception.stacktrace) === null || _exception_stacktrace === void 0 ? void 0 : (_exception_stacktrace_frames = _exception_stacktrace.frames) === null || _exception_stacktrace_frames === void 0 ? void 0 : _exception_stacktrace_frames.forEach((frame)=>{
1902            if (frame.debug_id) {
1903                if (frame.abs_path) {
1904                    filenameDebugIdMap[frame.abs_path] = frame.debug_id;
1905                } else if (frame.filename) {
1906                    filenameDebugIdMap[frame.filename] = frame.debug_id;
1907                }
1908                delete frame.debug_id;
1909            }
1910        });
1911    });
1912    if (Object.keys(filenameDebugIdMap).length === 0) {
1913        return;
1914    }
1915    event.debug_meta = event.debug_meta || {};
1916    event.debug_meta.images = event.debug_meta.images || [];
1917    const images = event.debug_meta.images;
1918    Object.entries(filenameDebugIdMap).forEach((param)=>{
1919        let [filename, debug_id] = param;
1920        images.push({
1921            type: "sourcemap",
1922            code_file: filename,
1923            debug_id
1924        });
1925    });
1926}
1927function applyIntegrationsMetadata(event, integrationNames) {
1928    if (integrationNames.length > 0) {
1929        event.sdk = event.sdk || {};
1930        event.sdk.integrations = [
1931            ...event.sdk.integrations || [],
1932            ...integrationNames
1933        ];
1934    }
1935}
1936function normalizeEvent(event, depth, maxBreadth) {
1937    var _event_contexts, _event_contexts1;
1938    if (!event) {
1939        return null;
1940    }
1941    const normalized = {
1942        ...event,
1943        ...event.breadcrumbs && {
1944            breadcrumbs: event.breadcrumbs.map((b)=>({
1945                    ...b,
1946                    ...b.data && {
1947                        data: (0, __TURBOPACK__imported__module__45968__["normalize"])(b.data, depth, maxBreadth)
1948                    }
1949                }))
1950        },
1951        ...event.user && {
1952            user: (0, __TURBOPACK__imported__module__45968__["normalize"])(event.user, depth, maxBreadth)
1953        },
1954        ...event.contexts && {
1955            contexts: (0, __TURBOPACK__imported__module__45968__["normalize"])(event.contexts, depth, maxBreadth)
1956        },
1957        ...event.extra && {
1958            extra: (0, __TURBOPACK__imported__module__45968__["normalize"])(event.extra, depth, maxBreadth)
1959        }
1960    };
1961    if (((_event_contexts = event.contexts) === null || _event_contexts === void 0 ? void 0 : _event_contexts.trace) && normalized.contexts) {
1962        normalized.contexts.trace = event.contexts.trace;
1963        if (event.contexts.trace.data) {
1964            normalized.contexts.trace.data = (0, __TURBOPACK__imported__module__45968__["normalize"])(event.contexts.trace.data, depth, maxBreadth);
1965        }
1966    }
1967    if (event.spans) {
1968        normalized.spans = event.spans.map((span)=>{
1969            return {
1970                ...span,
1971                ...span.data && {
1972                    data: (0, __TURBOPACK__imported__module__45968__["normalize"])(span.data, depth, maxBreadth)
1973                }
1974            };
1975        });
1976    }

1977    if (((_event_contexts1 = event.contexts) === null || _event_contexts1 === void 0 ? void 0 : _event_contexts1.flags) && normalized.contexts) {
1978        normalized.contexts.flags = (0, __TURBOPACK__imported__module__45968__["normalize"])(event.contexts.flags, 3, maxBreadth);
1979    }
1980    return normalized;
1981}
1982function getFinalScope(scope, captureContext) {
1983    if (!captureContext) {
1984        return scope;
1985    }
1986    const finalScope = scope ? scope.clone() : new __TURBOPACK__imported__module__994218__["Scope"]();
1987    finalScope.update(captureContext);
1988    return finalScope;
1989}
1990function parseEventHintOrCaptureContext(hint) {
1991    if (!hint) {
1992        return void 0;
1993    }
1994    if (hintIsScopeOrFunction(hint)) {
1995        return {
1996            captureContext: hint
1997        };
1998    }
1999    if (hintIsScopeContext(hint)) {
2000        return {
2001            captureContext: hint
2002        };
2003    }
2004    return hint;
2005}
2006function hintIsScopeOrFunction(hint) {
2007    return hint instanceof __TURBOPACK__imported__module__994218__["Scope"] || typeof hint === "function";
2008}
2009const captureContextKeys = [
2010    "user",
2011    "level",
2012    "extra",
2013    "contexts",
2014    "tags",
2015    "fingerprint",
2016    "propagationContext"
2017];
2018function hintIsScopeContext(hint) {
2019    return Object.keys(hint).some((key)=>captureContextKeys.includes(key));
2020}
2021;
2022__turbopack_context__.s([
2023    "parseEventHintOrCaptureContext",
2024    0,
2025    parseEventHintOrCaptureContext,
2026    "prepareEvent",
2027    0,
2028    prepareEvent
2029], 213186);
2030var __TURBOPACK__imported__module__571993__1 = __TURBOPACK__imported__module__571993__;
2031var __TURBOPACK__imported__module__225304__1 = __TURBOPACK__imported__module__225304__;
2032;
2033;
2034;
2035;
2036;
2037;
2038;
2039function captureException(exception, hint) {
2040    return (0, __TURBOPACK__imported__module__250804__["getCurrentScope"])().captureException(exception, parseEventHintOrCaptureContext(hint));
2041}
2042function captureMessage(message, captureContext) {
2043    const level = typeof captureContext === "string" ? captureContext : void 0;
2044    const hint = typeof captureContext !== "string" ? {
2045        captureContext
2046    } : void 0;
2047    return (0, __TURBOPACK__imported__module__250804__["getCurrentScope"])().captureMessage(message, level, hint);
2048}
2049function captureEvent(event, hint) {
2050    return (0, __TURBOPACK__imported__module__250804__["getCurrentScope"])().captureEvent(event, hint);
2051}
2052function setContext(name, context) {
2053    (0, __TURBOPACK__imported__module__250804__["getIsolationScope"])().setContext(name, context);
2054}
2055function setExtras(extras) {
2056    (0, __TURBOPACK__imported__module__250804__["getIsolationScope"])().setExtras(extras);
2057}
2058function setExtra(key, extra) {
2059    (0, __TURBOPACK__imported__module__250804__["getIsolationScope"])().setExtra(key, extra);
2060}
2061function setTags(tags) {
2062    (0, __TURBOPACK__imported__module__250804__["getIsolationScope"])().setTags(tags);
2063}
2064function setTag(key, value) {
2065    (0, __TURBOPACK__imported__module__250804__["getIsolationScope"])().setTag(key, value);
2066}
2067function setAttributes(attributes) {
2068    (0, __TURBOPACK__imported__module__250804__["getIsolationScope"])().setAttributes(attributes);
2069}
2070function setAttribute(key, value) {
2071    (0, __TURBOPACK__imported__module__250804__["getIsolationScope"])().setAttribute(key, value);
2072}
2073function setUser(user) {
2074    (0, __TURBOPACK__imported__module__250804__["getIsolationScope"])().setUser(user);
2075}
2076function setConversationId(conversationId) {
2077    (0, __TURBOPACK__imported__module__250804__["getIsolationScope"])().setConversationId(conversationId);
2078}
2079function lastEventId() {
2080    return (0, __TURBOPACK__imported__module__250804__["getIsolationScope"])().lastEventId();
2081}
2082async function flush(timeout) {
2083    const client = (0, __TURBOPACK__imported__module__250804__["getClient"])();
2084    if (client) {
2085        return client.flush(timeout);
2086    }
2087    __TURBOPACK__imported__module__901020__["DEBUG_BUILD"] && __TURBOPACK__imported__module__272598__["debug"].warn("Cannot flush events. No client defined.");
2088    return Promise.resolve(false);
2089}
2090async function close(timeout) {
2091    const client = (0, __TURBOPACK__imported__module__250804__["getClient"])();
2092    if (client) {
2093        return client.close(timeout);
2094    }
2095    __TURBOPACK__imported__module__901020__["DEBUG_BUILD"] && __TURBOPACK__imported__module__272598__["debug"].warn("Cannot flush events and disable SDK. No client defined.");
2096    return Promise.resolve(false);
2097}
2098function isInitialized() {
2099    return !!(0, __TURBOPACK__imported__module__250804__["getClient"])();
2100}
2101function isEnabled() {
2102    const client = (0, __TURBOPACK__imported__module__250804__["getClient"])();
2103    return (client === null || client === void 0 ? void 0 : client.getOptions().enabled) !== false && !!(client === null || client === void 0 ? void 0 : client.getTransport());
2104}
2105function addEventProcessor(callback) {
2106    (0, __TURBOPACK__imported__module__250804__["getIsolationScope"])().addEventProcessor(callback);
2107}
2108function startSession(context) {
2109    const isolationScope = (0, __TURBOPACK__imported__module__250804__["getIsolationScope"])();
2110    const { user } = (0, __TURBOPACK__imported__module__571993__1["getCombinedScopeData"])(isolationScope, (0, __TURBOPACK__imported__module__250804__["getCurrentScope"])());
2111    const { userAgent } = __TURBOPACK__imported__module__225304__1["GLOBAL_OBJ"].navigator || {};
2112    const session = (0, __TURBOPACK__imported__module__341041__["makeSession"])({
2113        user,
2114        ...userAgent && {
2115            userAgent
2116        },
2117        ...context
2118    });
2119    const currentSession = isolationScope.getSession();
2120    if ((currentSession === null || currentSession === void 0 ? void 0 : currentSession.status) === "ok") {
2121        (0, __TURBOPACK__imported__module__341041__["updateSession"])(currentSession, {
2122            status: "exited"
2123        });
2124    }
2125    endSession();
2126    isolationScope.setSession(session);
2127    return session;
2128}
2129function endSession() {
2130    const isolationScope = (0, __TURBOPACK__imported__module__250804__["getIsolationScope"])();
2131    const currentScope = (0, __TURBOPACK__imported__module__250804__["getCurrentScope"])();
2132    const session = currentScope.getSession() || isolationScope.getSession();
2133    if (session) {
2134        (0, __TURBOPACK__imported__module__341041__["closeSession"])(session);
2135    }
2136    _sendSessionUpdate();
2137    isolationScope.setSession();
2138}
2139function _sendSessionUpdate() {
2140    const isolationScope = (0, __TURBOPACK__imported__module__250804__["getIsolationScope"])();
2141    const client = (0, __TURBOPACK__imported__module__250804__["getClient"])();
2142    const session = isolationScope.getSession();
2143    if (session && client) {
2144        client.captureSession(session);
2145    }
2146}
2147function captureSession() {
2148    let end = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;

2149    if (end) {
2150        endSession();
2151        return;
2152    }
2153    _sendSessionUpdate();
2154}
2155;
2156__turbopack_context__.s([
2157    "addEventProcessor",
2158    0,
2159    addEventProcessor,
2160    "captureEvent",
2161    0,
2162    captureEvent,
2163    "captureException",
2164    0,
2165    captureException,
2166    "captureMessage",
2167    0,
2168    captureMessage,
2169    "captureSession",
2170    0,
2171    captureSession,
2172    "flush",
2173    0,
2174    flush,
2175    "isEnabled",
2176    0,
2177    isEnabled,
2178    "setContext",
2179    0,
2180    setContext,
2181    "setTag",
2182    0,
2183    setTag,
2184    "startSession",
2185    0,
2186    startSession
2187], 662537);
2188}),
2189]);
2190
2191//# debugId=4df17d55-332a-da84-47de-88fee41930aa