miniflare
Version:
Fun, full-featured, fully-local simulator for Cloudflare Workers
1,137 lines (1,111 loc) • 439 kB
JavaScript
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from == "object" || typeof from == "function")
for (let key of __getOwnPropNames(from))
!__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
mod
));
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/is.js
var require_is = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/is.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var objectToString = Object.prototype.toString;
function isError(wat) {
switch (objectToString.call(wat)) {
case "[object Error]":
case "[object Exception]":
case "[object DOMException]":
return !0;
default:
return isInstanceOf(wat, Error);
}
}
function isBuiltin(wat, className) {
return objectToString.call(wat) === `[object ${className}]`;
}
function isErrorEvent(wat) {
return isBuiltin(wat, "ErrorEvent");
}
function isDOMError(wat) {
return isBuiltin(wat, "DOMError");
}
function isDOMException(wat) {
return isBuiltin(wat, "DOMException");
}
function isString(wat) {
return isBuiltin(wat, "String");
}
function isParameterizedString(wat) {
return typeof wat == "object" && wat !== null && "__sentry_template_string__" in wat && "__sentry_template_values__" in wat;
}
function isPrimitive(wat) {
return wat === null || isParameterizedString(wat) || typeof wat != "object" && typeof wat != "function";
}
function isPlainObject(wat) {
return isBuiltin(wat, "Object");
}
function isEvent(wat) {
return typeof Event < "u" && isInstanceOf(wat, Event);
}
function isElement(wat) {
return typeof Element < "u" && isInstanceOf(wat, Element);
}
function isRegExp(wat) {
return isBuiltin(wat, "RegExp");
}
function isThenable(wat) {
return !!(wat && wat.then && typeof wat.then == "function");
}
function isSyntheticEvent(wat) {
return isPlainObject(wat) && "nativeEvent" in wat && "preventDefault" in wat && "stopPropagation" in wat;
}
function isInstanceOf(wat, base) {
try {
return wat instanceof base;
} catch {
return !1;
}
}
function isVueViewModel(wat) {
return !!(typeof wat == "object" && wat !== null && (wat.__isVue || wat._isVue));
}
exports.isDOMError = isDOMError;
exports.isDOMException = isDOMException;
exports.isElement = isElement;
exports.isError = isError;
exports.isErrorEvent = isErrorEvent;
exports.isEvent = isEvent;
exports.isInstanceOf = isInstanceOf;
exports.isParameterizedString = isParameterizedString;
exports.isPlainObject = isPlainObject;
exports.isPrimitive = isPrimitive;
exports.isRegExp = isRegExp;
exports.isString = isString;
exports.isSyntheticEvent = isSyntheticEvent;
exports.isThenable = isThenable;
exports.isVueViewModel = isVueViewModel;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/string.js
var require_string = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/string.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var is = require_is();
function truncate(str, max = 0) {
return typeof str != "string" || max === 0 || str.length <= max ? str : `${str.slice(0, max)}...`;
}
function snipLine(line, colno) {
let newLine = line, lineLength = newLine.length;
if (lineLength <= 150)
return newLine;
colno > lineLength && (colno = lineLength);
let start = Math.max(colno - 60, 0);
start < 5 && (start = 0);
let end = Math.min(start + 140, lineLength);
return end > lineLength - 5 && (end = lineLength), end === lineLength && (start = Math.max(end - 140, 0)), newLine = newLine.slice(start, end), start > 0 && (newLine = `'{snip} ${newLine}`), end < lineLength && (newLine += " {snip}"), newLine;
}
function safeJoin(input, delimiter) {
if (!Array.isArray(input))
return "";
let output = [];
for (let i = 0; i < input.length; i++) {
let value = input[i];
try {
is.isVueViewModel(value) ? output.push("[VueViewModel]") : output.push(String(value));
} catch {
output.push("[value cannot be serialized]");
}
}
return output.join(delimiter);
}
function isMatchingPattern(value, pattern, requireExactStringMatch = !1) {
return is.isString(value) ? is.isRegExp(pattern) ? pattern.test(value) : is.isString(pattern) ? requireExactStringMatch ? value === pattern : value.includes(pattern) : !1 : !1;
}
function stringMatchesSomePattern(testString, patterns = [], requireExactStringMatch = !1) {
return patterns.some((pattern) => isMatchingPattern(testString, pattern, requireExactStringMatch));
}
exports.isMatchingPattern = isMatchingPattern;
exports.safeJoin = safeJoin;
exports.snipLine = snipLine;
exports.stringMatchesSomePattern = stringMatchesSomePattern;
exports.truncate = truncate;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/aggregate-errors.js
var require_aggregate_errors = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/aggregate-errors.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var is = require_is(), string = require_string();
function applyAggregateErrorsToEvent(exceptionFromErrorImplementation, parser, maxValueLimit = 250, key, limit, event, hint) {
if (!event.exception || !event.exception.values || !hint || !is.isInstanceOf(hint.originalException, Error))
return;
let originalException = event.exception.values.length > 0 ? event.exception.values[event.exception.values.length - 1] : void 0;
originalException && (event.exception.values = truncateAggregateExceptions(
aggregateExceptionsFromError(
exceptionFromErrorImplementation,
parser,
limit,
hint.originalException,
key,
event.exception.values,
originalException,
0
),
maxValueLimit
));
}
function aggregateExceptionsFromError(exceptionFromErrorImplementation, parser, limit, error, key, prevExceptions, exception, exceptionId) {
if (prevExceptions.length >= limit + 1)
return prevExceptions;
let newExceptions = [...prevExceptions];
if (is.isInstanceOf(error[key], Error)) {
applyExceptionGroupFieldsForParentException(exception, exceptionId);
let newException = exceptionFromErrorImplementation(parser, error[key]), newExceptionId = newExceptions.length;
applyExceptionGroupFieldsForChildException(newException, key, newExceptionId, exceptionId), newExceptions = aggregateExceptionsFromError(
exceptionFromErrorImplementation,
parser,
limit,
error[key],
key,
[newException, ...newExceptions],
newException,
newExceptionId
);
}
return Array.isArray(error.errors) && error.errors.forEach((childError, i) => {
if (is.isInstanceOf(childError, Error)) {
applyExceptionGroupFieldsForParentException(exception, exceptionId);
let newException = exceptionFromErrorImplementation(parser, childError), newExceptionId = newExceptions.length;
applyExceptionGroupFieldsForChildException(newException, `errors[${i}]`, newExceptionId, exceptionId), newExceptions = aggregateExceptionsFromError(
exceptionFromErrorImplementation,
parser,
limit,
childError,
key,
[newException, ...newExceptions],
newException,
newExceptionId
);
}
}), newExceptions;
}
function applyExceptionGroupFieldsForParentException(exception, exceptionId) {
exception.mechanism = exception.mechanism || { type: "generic", handled: !0 }, exception.mechanism = {
...exception.mechanism,
...exception.type === "AggregateError" && { is_exception_group: !0 },
exception_id: exceptionId
};
}
function applyExceptionGroupFieldsForChildException(exception, source, exceptionId, parentId) {
exception.mechanism = exception.mechanism || { type: "generic", handled: !0 }, exception.mechanism = {
...exception.mechanism,
type: "chained",
source,
exception_id: exceptionId,
parent_id: parentId
};
}
function truncateAggregateExceptions(exceptions, maxValueLength) {
return exceptions.map((exception) => (exception.value && (exception.value = string.truncate(exception.value, maxValueLength)), exception));
}
exports.applyAggregateErrorsToEvent = applyAggregateErrorsToEvent;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/array.js
var require_array = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/array.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
function flatten(input) {
let result = [], flattenHelper = (input2) => {
input2.forEach((el) => {
Array.isArray(el) ? flattenHelper(el) : result.push(el);
});
};
return flattenHelper(input), result;
}
exports.flatten = flatten;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/version.js
var require_version = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/version.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var SDK_VERSION = "8.9.2";
exports.SDK_VERSION = SDK_VERSION;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/worldwide.js
var require_worldwide = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/worldwide.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var version = require_version(), GLOBAL_OBJ = globalThis;
function getGlobalSingleton(name, creator, obj) {
let gbl = obj || GLOBAL_OBJ, __SENTRY__ = gbl.__SENTRY__ = gbl.__SENTRY__ || {}, versionedCarrier = __SENTRY__[version.SDK_VERSION] = __SENTRY__[version.SDK_VERSION] || {};
return versionedCarrier[name] || (versionedCarrier[name] = creator());
}
exports.GLOBAL_OBJ = GLOBAL_OBJ;
exports.getGlobalSingleton = getGlobalSingleton;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/browser.js
var require_browser = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/browser.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var is = require_is(), worldwide = require_worldwide(), WINDOW = worldwide.GLOBAL_OBJ, DEFAULT_MAX_STRING_LENGTH = 80;
function htmlTreeAsString(elem, options = {}) {
if (!elem)
return "<unknown>";
try {
let currentElem = elem, MAX_TRAVERSE_HEIGHT = 5, out = [], height = 0, len = 0, separator = " > ", sepLength = separator.length, nextStr, keyAttrs = Array.isArray(options) ? options : options.keyAttrs, maxStringLength = !Array.isArray(options) && options.maxStringLength || DEFAULT_MAX_STRING_LENGTH;
for (; currentElem && height++ < MAX_TRAVERSE_HEIGHT && (nextStr = _htmlElementAsString(currentElem, keyAttrs), !(nextStr === "html" || height > 1 && len + out.length * sepLength + nextStr.length >= maxStringLength)); )
out.push(nextStr), len += nextStr.length, currentElem = currentElem.parentNode;
return out.reverse().join(separator);
} catch {
return "<unknown>";
}
}
function _htmlElementAsString(el, keyAttrs) {
let elem = el, out = [], className, classes, key, attr, i;
if (!elem || !elem.tagName)
return "";
if (WINDOW.HTMLElement && elem instanceof HTMLElement && elem.dataset) {
if (elem.dataset.sentryComponent)
return elem.dataset.sentryComponent;
if (elem.dataset.sentryElement)
return elem.dataset.sentryElement;
}
out.push(elem.tagName.toLowerCase());
let keyAttrPairs = keyAttrs && keyAttrs.length ? keyAttrs.filter((keyAttr) => elem.getAttribute(keyAttr)).map((keyAttr) => [keyAttr, elem.getAttribute(keyAttr)]) : null;
if (keyAttrPairs && keyAttrPairs.length)
keyAttrPairs.forEach((keyAttrPair) => {
out.push(`[${keyAttrPair[0]}="${keyAttrPair[1]}"]`);
});
else if (elem.id && out.push(`#${elem.id}`), className = elem.className, className && is.isString(className))
for (classes = className.split(/\s+/), i = 0; i < classes.length; i++)
out.push(`.${classes[i]}`);
let allowedAttrs = ["aria-label", "type", "name", "title", "alt"];
for (i = 0; i < allowedAttrs.length; i++)
key = allowedAttrs[i], attr = elem.getAttribute(key), attr && out.push(`[${key}="${attr}"]`);
return out.join("");
}
function getLocationHref() {
try {
return WINDOW.document.location.href;
} catch {
return "";
}
}
function getDomElement(selector) {
return WINDOW.document && WINDOW.document.querySelector ? WINDOW.document.querySelector(selector) : null;
}
function getComponentName(elem) {
if (!WINDOW.HTMLElement)
return null;
let currentElem = elem, MAX_TRAVERSE_HEIGHT = 5;
for (let i = 0; i < MAX_TRAVERSE_HEIGHT; i++) {
if (!currentElem)
return null;
if (currentElem instanceof HTMLElement) {
if (currentElem.dataset.sentryComponent)
return currentElem.dataset.sentryComponent;
if (currentElem.dataset.sentryElement)
return currentElem.dataset.sentryElement;
}
currentElem = currentElem.parentNode;
}
return null;
}
exports.getComponentName = getComponentName;
exports.getDomElement = getDomElement;
exports.getLocationHref = getLocationHref;
exports.htmlTreeAsString = htmlTreeAsString;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/debug-build.js
var require_debug_build = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/debug-build.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var DEBUG_BUILD = typeof __SENTRY_DEBUG__ > "u" || __SENTRY_DEBUG__;
exports.DEBUG_BUILD = DEBUG_BUILD;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/logger.js
var require_logger = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/logger.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var debugBuild = require_debug_build(), worldwide = require_worldwide(), PREFIX = "Sentry Logger ", CONSOLE_LEVELS = [
"debug",
"info",
"warn",
"error",
"log",
"assert",
"trace"
], originalConsoleMethods = {};
function consoleSandbox(callback) {
if (!("console" in worldwide.GLOBAL_OBJ))
return callback();
let console2 = worldwide.GLOBAL_OBJ.console, wrappedFuncs = {}, wrappedLevels = Object.keys(originalConsoleMethods);
wrappedLevels.forEach((level) => {
let originalConsoleMethod = originalConsoleMethods[level];
wrappedFuncs[level] = console2[level], console2[level] = originalConsoleMethod;
});
try {
return callback();
} finally {
wrappedLevels.forEach((level) => {
console2[level] = wrappedFuncs[level];
});
}
}
function makeLogger() {
let enabled = !1, logger2 = {
enable: () => {
enabled = !0;
},
disable: () => {
enabled = !1;
},
isEnabled: () => enabled
};
return debugBuild.DEBUG_BUILD ? CONSOLE_LEVELS.forEach((name) => {
logger2[name] = (...args) => {
enabled && consoleSandbox(() => {
worldwide.GLOBAL_OBJ.console[name](`${PREFIX}[${name}]:`, ...args);
});
};
}) : CONSOLE_LEVELS.forEach((name) => {
logger2[name] = () => {
};
}), logger2;
}
var logger = makeLogger();
exports.CONSOLE_LEVELS = CONSOLE_LEVELS;
exports.consoleSandbox = consoleSandbox;
exports.logger = logger;
exports.originalConsoleMethods = originalConsoleMethods;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/dsn.js
var require_dsn = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/dsn.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var debugBuild = require_debug_build(), logger = require_logger(), DSN_REGEX = /^(?:(\w+):)\/\/(?:(\w+)(?::(\w+)?)?@)([\w.-]+)(?::(\d+))?\/(.+)/;
function isValidProtocol(protocol) {
return protocol === "http" || protocol === "https";
}
function dsnToString(dsn, withPassword = !1) {
let { host, path, pass, port, projectId, protocol, publicKey } = dsn;
return `${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ""}@${host}${port ? `:${port}` : ""}/${path && `${path}/`}${projectId}`;
}
function dsnFromString(str) {
let match = DSN_REGEX.exec(str);
if (!match) {
logger.consoleSandbox(() => {
console.error(`Invalid Sentry Dsn: ${str}`);
});
return;
}
let [protocol, publicKey, pass = "", host, port = "", lastPath] = match.slice(1), path = "", projectId = lastPath, split = projectId.split("/");
if (split.length > 1 && (path = split.slice(0, -1).join("/"), projectId = split.pop()), projectId) {
let projectMatch = projectId.match(/^\d+/);
projectMatch && (projectId = projectMatch[0]);
}
return dsnFromComponents({ host, pass, path, projectId, port, protocol, publicKey });
}
function dsnFromComponents(components) {
return {
protocol: components.protocol,
publicKey: components.publicKey || "",
pass: components.pass || "",
host: components.host,
port: components.port || "",
path: components.path || "",
projectId: components.projectId
};
}
function validateDsn(dsn) {
if (!debugBuild.DEBUG_BUILD)
return !0;
let { port, projectId, protocol } = dsn;
return ["protocol", "publicKey", "host", "projectId"].find((component) => dsn[component] ? !1 : (logger.logger.error(`Invalid Sentry Dsn: ${component} missing`), !0)) ? !1 : projectId.match(/^\d+$/) ? isValidProtocol(protocol) ? port && isNaN(parseInt(port, 10)) ? (logger.logger.error(`Invalid Sentry Dsn: Invalid port ${port}`), !1) : !0 : (logger.logger.error(`Invalid Sentry Dsn: Invalid protocol ${protocol}`), !1) : (logger.logger.error(`Invalid Sentry Dsn: Invalid projectId ${projectId}`), !1);
}
function makeDsn(from) {
let components = typeof from == "string" ? dsnFromString(from) : dsnFromComponents(from);
if (!(!components || !validateDsn(components)))
return components;
}
exports.dsnFromString = dsnFromString;
exports.dsnToString = dsnToString;
exports.makeDsn = makeDsn;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/error.js
var require_error = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/error.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var SentryError = class extends Error {
/** Display name of this error instance. */
constructor(message, logLevel = "warn") {
super(message), this.message = message, this.name = new.target.prototype.constructor.name, Object.setPrototypeOf(this, new.target.prototype), this.logLevel = logLevel;
}
};
exports.SentryError = SentryError;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/object.js
var require_object = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/object.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var browser = require_browser(), debugBuild = require_debug_build(), is = require_is(), logger = require_logger(), string = require_string();
function fill(source, name, replacementFactory) {
if (!(name in source))
return;
let original = source[name], wrapped = replacementFactory(original);
typeof wrapped == "function" && markFunctionWrapped(wrapped, original), source[name] = wrapped;
}
function addNonEnumerableProperty(obj, name, value) {
try {
Object.defineProperty(obj, name, {
// enumerable: false, // the default, so we can save on bundle size by not explicitly setting it
value,
writable: !0,
configurable: !0
});
} catch {
debugBuild.DEBUG_BUILD && logger.logger.log(`Failed to add non-enumerable property "${name}" to object`, obj);
}
}
function markFunctionWrapped(wrapped, original) {
try {
let proto = original.prototype || {};
wrapped.prototype = original.prototype = proto, addNonEnumerableProperty(wrapped, "__sentry_original__", original);
} catch {
}
}
function getOriginalFunction(func) {
return func.__sentry_original__;
}
function urlEncode(object) {
return Object.keys(object).map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(object[key])}`).join("&");
}
function convertToPlainObject(value) {
if (is.isError(value))
return {
message: value.message,
name: value.name,
stack: value.stack,
...getOwnProperties(value)
};
if (is.isEvent(value)) {
let newObj = {
type: value.type,
target: serializeEventTarget(value.target),
currentTarget: serializeEventTarget(value.currentTarget),
...getOwnProperties(value)
};
return typeof CustomEvent < "u" && is.isInstanceOf(value, CustomEvent) && (newObj.detail = value.detail), newObj;
} else
return value;
}
function serializeEventTarget(target) {
try {
return is.isElement(target) ? browser.htmlTreeAsString(target) : Object.prototype.toString.call(target);
} catch {
return "<unknown>";
}
}
function getOwnProperties(obj) {
if (typeof obj == "object" && obj !== null) {
let extractedProps = {};
for (let property in obj)
Object.prototype.hasOwnProperty.call(obj, property) && (extractedProps[property] = obj[property]);
return extractedProps;
} else
return {};
}
function extractExceptionKeysForMessage(exception, maxLength = 40) {
let keys = Object.keys(convertToPlainObject(exception));
if (keys.sort(), !keys.length)
return "[object has no keys]";
if (keys[0].length >= maxLength)
return string.truncate(keys[0], maxLength);
for (let includedKeys = keys.length; includedKeys > 0; includedKeys--) {
let serialized = keys.slice(0, includedKeys).join(", ");
if (!(serialized.length > maxLength))
return includedKeys === keys.length ? serialized : string.truncate(serialized, maxLength);
}
return "";
}
function dropUndefinedKeys(inputValue) {
return _dropUndefinedKeys(inputValue, /* @__PURE__ */ new Map());
}
function _dropUndefinedKeys(inputValue, memoizationMap) {
if (isPojo(inputValue)) {
let memoVal = memoizationMap.get(inputValue);
if (memoVal !== void 0)
return memoVal;
let returnValue = {};
memoizationMap.set(inputValue, returnValue);
for (let key of Object.keys(inputValue))
typeof inputValue[key] < "u" && (returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap));
return returnValue;
}
if (Array.isArray(inputValue)) {
let memoVal = memoizationMap.get(inputValue);
if (memoVal !== void 0)
return memoVal;
let returnValue = [];
return memoizationMap.set(inputValue, returnValue), inputValue.forEach((item) => {
returnValue.push(_dropUndefinedKeys(item, memoizationMap));
}), returnValue;
}
return inputValue;
}
function isPojo(input) {
if (!is.isPlainObject(input))
return !1;
try {
let name = Object.getPrototypeOf(input).constructor.name;
return !name || name === "Object";
} catch {
return !0;
}
}
function objectify(wat) {
let objectified;
switch (!0) {
case wat == null:
objectified = new String(wat);
break;
// Though symbols and bigints do have wrapper classes (`Symbol` and `BigInt`, respectively), for whatever reason
// those classes don't have constructors which can be used with the `new` keyword. We therefore need to cast each as
// an object in order to wrap it.
case (typeof wat == "symbol" || typeof wat == "bigint"):
objectified = Object(wat);
break;
// this will catch the remaining primitives: `String`, `Number`, and `Boolean`
case is.isPrimitive(wat):
objectified = new wat.constructor(wat);
break;
// by process of elimination, at this point we know that `wat` must already be an object
default:
objectified = wat;
break;
}
return objectified;
}
exports.addNonEnumerableProperty = addNonEnumerableProperty;
exports.convertToPlainObject = convertToPlainObject;
exports.dropUndefinedKeys = dropUndefinedKeys;
exports.extractExceptionKeysForMessage = extractExceptionKeysForMessage;
exports.fill = fill;
exports.getOriginalFunction = getOriginalFunction;
exports.markFunctionWrapped = markFunctionWrapped;
exports.objectify = objectify;
exports.urlEncode = urlEncode;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/stacktrace.js
var require_stacktrace = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/stacktrace.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var STACKTRACE_FRAME_LIMIT = 50, UNKNOWN_FUNCTION = "?", WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/, STRIP_FRAME_REGEXP = /captureMessage|captureException/;
function createStackParser(...parsers) {
let sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map((p) => p[1]);
return (stack, skipFirstLines = 0, framesToPop = 0) => {
let frames = [], lines = stack.split(`
`);
for (let i = skipFirstLines; i < lines.length; i++) {
let line = lines[i];
if (line.length > 1024)
continue;
let cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, "$1") : line;
if (!cleanedLine.match(/\S*Error: /)) {
for (let parser of sortedParsers) {
let frame = parser(cleanedLine);
if (frame) {
frames.push(frame);
break;
}
}
if (frames.length >= STACKTRACE_FRAME_LIMIT + framesToPop)
break;
}
}
return stripSentryFramesAndReverse(frames.slice(framesToPop));
};
}
function stackParserFromStackParserOptions(stackParser) {
return Array.isArray(stackParser) ? createStackParser(...stackParser) : stackParser;
}
function stripSentryFramesAndReverse(stack) {
if (!stack.length)
return [];
let localStack = Array.from(stack);
return /sentryWrapped/.test(localStack[localStack.length - 1].function || "") && localStack.pop(), localStack.reverse(), STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || "") && (localStack.pop(), STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || "") && localStack.pop()), localStack.slice(0, STACKTRACE_FRAME_LIMIT).map((frame) => ({
...frame,
filename: frame.filename || localStack[localStack.length - 1].filename,
function: frame.function || UNKNOWN_FUNCTION
}));
}
var defaultFunctionName = "<anonymous>";
function getFunctionName(fn) {
try {
return !fn || typeof fn != "function" ? defaultFunctionName : fn.name || defaultFunctionName;
} catch {
return defaultFunctionName;
}
}
function getFramesFromEvent(event) {
let exception = event.exception;
if (exception) {
let frames = [];
try {
return exception.values.forEach((value) => {
value.stacktrace.frames && frames.push(...value.stacktrace.frames);
}), frames;
} catch {
return;
}
}
}
exports.UNKNOWN_FUNCTION = UNKNOWN_FUNCTION;
exports.createStackParser = createStackParser;
exports.getFramesFromEvent = getFramesFromEvent;
exports.getFunctionName = getFunctionName;
exports.stackParserFromStackParserOptions = stackParserFromStackParserOptions;
exports.stripSentryFramesAndReverse = stripSentryFramesAndReverse;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/instrument/handlers.js
var require_handlers = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/instrument/handlers.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var debugBuild = require_debug_build(), logger = require_logger(), stacktrace = require_stacktrace(), handlers = {}, instrumented = {};
function addHandler(type, handler) {
handlers[type] = handlers[type] || [], handlers[type].push(handler);
}
function resetInstrumentationHandlers() {
Object.keys(handlers).forEach((key) => {
handlers[key] = void 0;
});
}
function maybeInstrument(type, instrumentFn) {
instrumented[type] || (instrumentFn(), instrumented[type] = !0);
}
function triggerHandlers(type, data) {
let typeHandlers = type && handlers[type];
if (typeHandlers)
for (let handler of typeHandlers)
try {
handler(data);
} catch (e) {
debugBuild.DEBUG_BUILD && logger.logger.error(
`Error while triggering instrumentation handler.
Type: ${type}
Name: ${stacktrace.getFunctionName(handler)}
Error:`,
e
);
}
}
exports.addHandler = addHandler;
exports.maybeInstrument = maybeInstrument;
exports.resetInstrumentationHandlers = resetInstrumentationHandlers;
exports.triggerHandlers = triggerHandlers;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/instrument/console.js
var require_console = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/instrument/console.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var logger = require_logger(), object = require_object(), worldwide = require_worldwide(), handlers = require_handlers();
function addConsoleInstrumentationHandler(handler) {
let type = "console";
handlers.addHandler(type, handler), handlers.maybeInstrument(type, instrumentConsole);
}
function instrumentConsole() {
"console" in worldwide.GLOBAL_OBJ && logger.CONSOLE_LEVELS.forEach(function(level) {
level in worldwide.GLOBAL_OBJ.console && object.fill(worldwide.GLOBAL_OBJ.console, level, function(originalConsoleMethod) {
return logger.originalConsoleMethods[level] = originalConsoleMethod, function(...args) {
let handlerData = { args, level };
handlers.triggerHandlers("console", handlerData);
let log = logger.originalConsoleMethods[level];
log && log.apply(worldwide.GLOBAL_OBJ.console, args);
};
});
});
}
exports.addConsoleInstrumentationHandler = addConsoleInstrumentationHandler;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/supports.js
var require_supports = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/supports.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var debugBuild = require_debug_build(), logger = require_logger(), worldwide = require_worldwide(), WINDOW = worldwide.GLOBAL_OBJ;
function supportsErrorEvent() {
try {
return new ErrorEvent(""), !0;
} catch {
return !1;
}
}
function supportsDOMError() {
try {
return new DOMError(""), !0;
} catch {
return !1;
}
}
function supportsDOMException() {
try {
return new DOMException(""), !0;
} catch {
return !1;
}
}
function supportsFetch() {
if (!("fetch" in WINDOW))
return !1;
try {
return new Headers(), new Request("http://www.example.com"), new Response(), !0;
} catch {
return !1;
}
}
function isNativeFunction(func) {
return func && /^function\s+\w+\(\)\s+\{\s+\[native code\]\s+\}$/.test(func.toString());
}
function supportsNativeFetch() {
if (typeof EdgeRuntime == "string")
return !0;
if (!supportsFetch())
return !1;
if (isNativeFunction(WINDOW.fetch))
return !0;
let result = !1, doc = WINDOW.document;
if (doc && typeof doc.createElement == "function")
try {
let sandbox = doc.createElement("iframe");
sandbox.hidden = !0, doc.head.appendChild(sandbox), sandbox.contentWindow && sandbox.contentWindow.fetch && (result = isNativeFunction(sandbox.contentWindow.fetch)), doc.head.removeChild(sandbox);
} catch (err) {
debugBuild.DEBUG_BUILD && logger.logger.warn("Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ", err);
}
return result;
}
function supportsReportingObserver() {
return "ReportingObserver" in WINDOW;
}
function supportsReferrerPolicy() {
if (!supportsFetch())
return !1;
try {
return new Request("_", {
referrerPolicy: "origin"
}), !0;
} catch {
return !1;
}
}
exports.isNativeFunction = isNativeFunction;
exports.supportsDOMError = supportsDOMError;
exports.supportsDOMException = supportsDOMException;
exports.supportsErrorEvent = supportsErrorEvent;
exports.supportsFetch = supportsFetch;
exports.supportsNativeFetch = supportsNativeFetch;
exports.supportsReferrerPolicy = supportsReferrerPolicy;
exports.supportsReportingObserver = supportsReportingObserver;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/time.js
var require_time = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/time.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var worldwide = require_worldwide(), ONE_SECOND_IN_MS = 1e3;
function dateTimestampInSeconds() {
return Date.now() / ONE_SECOND_IN_MS;
}
function createUnixTimestampInSecondsFunc() {
let { performance } = worldwide.GLOBAL_OBJ;
if (!performance || !performance.now)
return dateTimestampInSeconds;
let approxStartingTimeOrigin = Date.now() - performance.now(), timeOrigin = performance.timeOrigin == null ? approxStartingTimeOrigin : performance.timeOrigin;
return () => (timeOrigin + performance.now()) / ONE_SECOND_IN_MS;
}
var timestampInSeconds = createUnixTimestampInSecondsFunc();
exports._browserPerformanceTimeOriginMode = void 0;
var browserPerformanceTimeOrigin = (() => {
let { performance } = worldwide.GLOBAL_OBJ;
if (!performance || !performance.now) {
exports._browserPerformanceTimeOriginMode = "none";
return;
}
let threshold = 3600 * 1e3, performanceNow = performance.now(), dateNow = Date.now(), timeOriginDelta = performance.timeOrigin ? Math.abs(performance.timeOrigin + performanceNow - dateNow) : threshold, timeOriginIsReliable = timeOriginDelta < threshold, navigationStart = performance.timing && performance.timing.navigationStart, navigationStartDelta = typeof navigationStart == "number" ? Math.abs(navigationStart + performanceNow - dateNow) : threshold, navigationStartIsReliable = navigationStartDelta < threshold;
return timeOriginIsReliable || navigationStartIsReliable ? timeOriginDelta <= navigationStartDelta ? (exports._browserPerformanceTimeOriginMode = "timeOrigin", performance.timeOrigin) : (exports._browserPerformanceTimeOriginMode = "navigationStart", navigationStart) : (exports._browserPerformanceTimeOriginMode = "dateNow", dateNow);
})();
exports.browserPerformanceTimeOrigin = browserPerformanceTimeOrigin;
exports.dateTimestampInSeconds = dateTimestampInSeconds;
exports.timestampInSeconds = timestampInSeconds;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/instrument/fetch.js
var require_fetch = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/instrument/fetch.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var is = require_is(), object = require_object(), supports = require_supports(), time = require_time(), worldwide = require_worldwide(), handlers = require_handlers();
function addFetchInstrumentationHandler(handler) {
let type = "fetch";
handlers.addHandler(type, handler), handlers.maybeInstrument(type, instrumentFetch);
}
function instrumentFetch() {
supports.supportsNativeFetch() && object.fill(worldwide.GLOBAL_OBJ, "fetch", function(originalFetch) {
return function(...args) {
let { method, url } = parseFetchArgs(args), handlerData = {
args,
fetchData: {
method,
url
},
startTimestamp: time.timestampInSeconds() * 1e3
};
handlers.triggerHandlers("fetch", {
...handlerData
});
let virtualStackTrace = new Error().stack;
return originalFetch.apply(worldwide.GLOBAL_OBJ, args).then(
(response) => {
let finishedHandlerData = {
...handlerData,
endTimestamp: time.timestampInSeconds() * 1e3,
response
};
return handlers.triggerHandlers("fetch", finishedHandlerData), response;
},
(error) => {
let erroredHandlerData = {
...handlerData,
endTimestamp: time.timestampInSeconds() * 1e3,
error
};
throw handlers.triggerHandlers("fetch", erroredHandlerData), is.isError(error) && error.stack === void 0 && (error.stack = virtualStackTrace, object.addNonEnumerableProperty(error, "framesToPop", 1)), error;
}
);
};
});
}
function hasProp(obj, prop) {
return !!obj && typeof obj == "object" && !!obj[prop];
}
function getUrlFromResource(resource) {
return typeof resource == "string" ? resource : resource ? hasProp(resource, "url") ? resource.url : resource.toString ? resource.toString() : "" : "";
}
function parseFetchArgs(fetchArgs) {
if (fetchArgs.length === 0)
return { method: "GET", url: "" };
if (fetchArgs.length === 2) {
let [url, options] = fetchArgs;
return {
url: getUrlFromResource(url),
method: hasProp(options, "method") ? String(options.method).toUpperCase() : "GET"
};
}
let arg = fetchArgs[0];
return {
url: getUrlFromResource(arg),
method: hasProp(arg, "method") ? String(arg.method).toUpperCase() : "GET"
};
}
exports.addFetchInstrumentationHandler = addFetchInstrumentationHandler;
exports.parseFetchArgs = parseFetchArgs;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/instrument/globalError.js
var require_globalError = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/instrument/globalError.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var worldwide = require_worldwide(), handlers = require_handlers(), _oldOnErrorHandler = null;
function addGlobalErrorInstrumentationHandler(handler) {
let type = "error";
handlers.addHandler(type, handler), handlers.maybeInstrument(type, instrumentError);
}
function instrumentError() {
_oldOnErrorHandler = worldwide.GLOBAL_OBJ.onerror, worldwide.GLOBAL_OBJ.onerror = function(msg, url, line, column, error) {
let handlerData = {
column,
error,
line,
msg,
url
};
return handlers.triggerHandlers("error", handlerData), _oldOnErrorHandler && !_oldOnErrorHandler.__SENTRY_LOADER__ ? _oldOnErrorHandler.apply(this, arguments) : !1;
}, worldwide.GLOBAL_OBJ.onerror.__SENTRY_INSTRUMENTED__ = !0;
}
exports.addGlobalErrorInstrumentationHandler = addGlobalErrorInstrumentationHandler;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/instrument/globalUnhandledRejection.js
var require_globalUnhandledRejection = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/instrument/globalUnhandledRejection.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var worldwide = require_worldwide(), handlers = require_handlers(), _oldOnUnhandledRejectionHandler = null;
function addGlobalUnhandledRejectionInstrumentationHandler(handler) {
let type = "unhandledrejection";
handlers.addHandler(type, handler), handlers.maybeInstrument(type, instrumentUnhandledRejection);
}
function instrumentUnhandledRejection() {
_oldOnUnhandledRejectionHandler = worldwide.GLOBAL_OBJ.onunhandledrejection, worldwide.GLOBAL_OBJ.onunhandledrejection = function(e) {
let handlerData = e;
return handlers.triggerHandlers("unhandledrejection", handlerData), _oldOnUnhandledRejectionHandler && !_oldOnUnhandledRejectionHandler.__SENTRY_LOADER__ ? _oldOnUnhandledRejectionHandler.apply(this, arguments) : !0;
}, worldwide.GLOBAL_OBJ.onunhandledrejection.__SENTRY_INSTRUMENTED__ = !0;
}
exports.addGlobalUnhandledRejectionInstrumentationHandler = addGlobalUnhandledRejectionInstrumentationHandler;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/env.js
var require_env = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/env.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
function isBrowserBundle() {
return typeof __SENTRY_BROWSER_BUNDLE__ < "u" && !!__SENTRY_BROWSER_BUNDLE__;
}
function getSDKSource() {
return "npm";
}
exports.getSDKSource = getSDKSource;
exports.isBrowserBundle = isBrowserBundle;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/node.js
var require_node = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/node.js"(exports, module) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var env = require_env();
function isNodeEnv() {
return !env.isBrowserBundle() && Object.prototype.toString.call(typeof process < "u" ? process : 0) === "[object process]";
}
function dynamicRequire(mod, request) {
return mod.require(request);
}
function loadModule(moduleName) {
let mod;
try {
mod = dynamicRequire(module, moduleName);
} catch {
}
try {
let { cwd } = dynamicRequire(module, "process");
mod = dynamicRequire(module, `${cwd()}/node_modules/${moduleName}`);
} catch {
}
return mod;
}
exports.dynamicRequire = dynamicRequire;
exports.isNodeEnv = isNodeEnv;
exports.loadModule = loadModule;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/isBrowser.js
var require_isBrowser = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/isBrowser.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var node = require_node(), worldwide = require_worldwide();
function isBrowser() {
return typeof window < "u" && (!node.isNodeEnv() || isElectronNodeRenderer());
}
function isElectronNodeRenderer() {
return (
// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
worldwide.GLOBAL_OBJ.process !== void 0 && worldwide.GLOBAL_OBJ.process.type === "renderer"
);
}
exports.isBrowser = isBrowser;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/memo.js
var require_memo = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/memo.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
function memoBuilder() {
let hasWeakSet = typeof WeakSet == "function", inner = hasWeakSet ? /* @__PURE__ */ new WeakSet() : [];
function memoize(obj) {
if (hasWeakSet)
return inner.has(obj) ? !0 : (inner.add(obj), !1);
for (let i = 0; i < inner.length; i++)
if (inner[i] === obj)
return !0;
return inner.push(obj), !1;
}
function unmemoize(obj) {
if (hasWeakSet)
inner.delete(obj);
else
for (let i = 0; i < inner.length; i++)
if (inner[i] === obj) {
inner.splice(i, 1);
break;
}
}
return [memoize, unmemoize];
}
exports.memoBuilder = memoBuilder;
}
});
// ../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/misc.js
var require_misc = __commonJS({
"../../node_modules/.pnpm/@sentry+utils@8.9.2/node_modules/@sentry/utils/cjs/misc.js"(exports) {
Object.defineProperty(exports, "__esModule", { value: !0 });
var object = require_object(), string = require_string(), worldwide = require_worldwide();
function uuid4() {
let gbl = worldwide.GLOBAL_OBJ, crypto = gbl.crypto || gbl.msCrypto, getRandomByte = () => Math.random() * 16;
try {
if (crypto && crypto.randomUUID)
return crypto.randomUUID().replace(/-/g, "");
crypto && crypto.getRandomValues && (getRandomByte = () => {
let typedArray = new Uint8Array(1);
return crypto.getRandomValues(typedArray), typedArray[0];
});
} catch {
}
return ("10000000100040008000" + 1e11).replace(
/[018]/g,
(c) => (
// eslint-disable-next-line no-bitwise
(c ^ (getRandomByte() & 15) >> c / 4).toString(16)
)
);
}
function getFirstException(event) {
return event.exception && event.exception.values ? event.exception.values[0] : void 0;
}
function getEventDescription(event) {
let { message, event_id: eventId } = event;
if (message)
return message;
let firstException = getFirstException(event);
return firstException ? firstException.type && firstException.value ? `${firstException.type}: ${firstException.value}` : firstException.type || firstException.value || eventId || "<unknown>" : eventId || "<unknown>";
}
function addExceptionTypeValue(event, value, type) {
let exception = event.exception = event.exception || {}, values = exception.values = exception.values || [], firstException = values[0] = values[0] || {};
firstException.value || (firstException.value = value || ""), firstException.type || (firstException.type = type || "Error");
}
function addExceptionMechanism(event, newMechanism) {
let firstException = getFirstException(event);
if (!firstException)
return;