@fedify/fedify 1.6.1-dev.851 → 1.6.1-dev.856

package/dist/node_modules/.pnpm/fetch-mock@12.5.2/node_modules/fetch-mock/dist/esm/Route.js

@@ -0,0 +1,137 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { builtInMatchers } from "./Matchers.js";
+import { StatusTextMap_default } from "./StatusTextMap.js";
+
+//#region node_modules/.pnpm/fetch-mock@12.5.2/node_modules/fetch-mock/dist/esm/Route.js
+var __classPrivateFieldSet = void 0 && (void 0).__classPrivateFieldSet || function(receiver, state, value, kind, f) {
+	if (kind === "m") throw new TypeError("Private method is not writable");
+	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+	return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet = void 0 && (void 0).__classPrivateFieldGet || function(receiver, state, kind, f) {
+	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+	return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Route_instances, _a, _Route_responseSubscriptions, _Route_validate, _Route_sanitize, _Route_generateMatcher, _Route_limit, _Route_delayResponse;
+function isBodyInit(body) {
+	return body instanceof Blob || body instanceof ArrayBuffer || ArrayBuffer.isView(body) || body instanceof DataView || body instanceof FormData || body instanceof ReadableStream || body instanceof URLSearchParams || body instanceof String || typeof body === "string" || body === null;
+}
+function sanitizeStatus(status) {
+	if (status === 0) return 200;
+	if (!status) return 200;
+	if (typeof status === "number" && parseInt(String(status), 10) !== status && status >= 200 || status < 600) return status;
+	throw new TypeError(`fetch-mock: Invalid status ${status} passed on response object.
+To respond with a JSON object that has status as a property assign the object to body
+e.g. {"body": {"status: "registered"}}`);
+}
+var Route = class {
+	constructor(config) {
+		_Route_instances.add(this);
+		_Route_responseSubscriptions.set(this, void 0);
+		this.init(config);
+	}
+	init(config) {
+		this.config = config;
+		__classPrivateFieldSet(this, _Route_responseSubscriptions, [], "f");
+		__classPrivateFieldGet(this, _Route_instances, "m", _Route_sanitize).call(this);
+		__classPrivateFieldGet(this, _Route_instances, "m", _Route_validate).call(this);
+		__classPrivateFieldGet(this, _Route_instances, "m", _Route_generateMatcher).call(this);
+		__classPrivateFieldGet(this, _Route_instances, "m", _Route_limit).call(this);
+		__classPrivateFieldGet(this, _Route_instances, "m", _Route_delayResponse).call(this);
+	}
+	reset() {}
+	waitFor(awaitedRoutes) {
+		const { response } = this.config;
+		this.config.response = Promise.all(awaitedRoutes.map((awaitedRoute) => new Promise((res) => awaitedRoute.onRespond(() => {
+			res(void 0);
+		})))).then(() => response);
+	}
+	onRespond(func) {
+		__classPrivateFieldGet(this, _Route_responseSubscriptions, "f").push(func);
+	}
+	constructResponse(responseInput) {
+		const responseOptions = this.constructResponseOptions(responseInput);
+		const body = this.constructResponseBody(responseInput, responseOptions);
+		const responsePackage = {
+			response: new this.config.Response(body, responseOptions),
+			responseOptions,
+			responseInput
+		};
+		__classPrivateFieldGet(this, _Route_responseSubscriptions, "f").forEach((func) => func());
+		return responsePackage;
+	}
+	constructResponseOptions(responseInput) {
+		const options = responseInput.options || {};
+		options.status = sanitizeStatus(responseInput.status);
+		options.statusText = StatusTextMap_default[options.status];
+		options.headers = new this.config.Headers(responseInput.headers);
+		return options;
+	}
+	constructResponseBody(responseInput, responseOptions) {
+		let body = responseInput.body;
+		const bodyIsBodyInit = isBodyInit(body);
+		if (!bodyIsBodyInit) if (typeof body === "undefined") body = null;
+		else if (typeof body === "object") {
+			body = JSON.stringify(body);
+			if (!responseOptions.headers.has("Content-Type")) responseOptions.headers.set("Content-Type", "application/json");
+		} else throw new TypeError("Invalid body provided to construct response");
+		if (this.config.includeContentLength && !responseOptions.headers.has("Content-Length") && !(body instanceof ReadableStream) && !(body instanceof FormData)) {
+			let length = 0;
+			if (body instanceof Blob) length = body.size;
+			else if (body instanceof ArrayBuffer || ArrayBuffer.isView(body) || body instanceof DataView) length = body.byteLength;
+			else if (body instanceof URLSearchParams) length = body.toString().length;
+			else if (typeof body === "string" || body instanceof String) length = body.length;
+			responseOptions.headers.set("Content-Length", length.toString());
+		}
+		return body;
+	}
+	static defineMatcher(matcher) {
+		_a.registeredMatchers.push(matcher);
+	}
+};
+_a = Route, _Route_responseSubscriptions = new WeakMap(), _Route_instances = new WeakSet(), _Route_validate = function _Route_validate$1() {
+	if (["matched", "unmatched"].includes(this.config.name)) throw new Error(`fetch-mock: Routes cannot use the reserved name \`${this.config.name}\``);
+	if (!("response" in this.config)) throw new Error("fetch-mock: Each route must define a response");
+	if (!_a.registeredMatchers.some(({ name }) => name in this.config)) throw new Error("fetch-mock: Each route must specify some criteria for matching calls to fetch. To match all calls use '*'");
+}, _Route_sanitize = function _Route_sanitize$1() {
+	if (this.config.method) this.config.method = this.config.method.toLowerCase();
+}, _Route_generateMatcher = function _Route_generateMatcher$1() {
+	const activeMatchers = _a.registeredMatchers.filter(({ name }) => name in this.config).map(({ matcher, usesBody }) => ({
+		matcher: matcher(this.config),
+		usesBody
+	}));
+	this.config.usesBody = activeMatchers.some(({ usesBody }) => usesBody);
+	this.matcher = (normalizedRequest) => activeMatchers.every(({ matcher }) => matcher(normalizedRequest));
+}, _Route_limit = function _Route_limit$1() {
+	if (!this.config.repeat) return;
+	const originalMatcher = this.matcher;
+	let timesLeft = this.config.repeat;
+	this.matcher = (callLog) => {
+		const match = timesLeft && originalMatcher(callLog);
+		if (match) {
+			timesLeft--;
+			return true;
+		}
+	};
+	this.reset = () => {
+		timesLeft = this.config.repeat;
+	};
+}, _Route_delayResponse = function _Route_delayResponse$1() {
+	if (this.config.delay) {
+		const { response } = this.config;
+		this.config.response = () => {
+			return new Promise((res) => setTimeout(() => res(response), this.config.delay));
+		};
+	}
+};
+Route.registeredMatchers = [];
+builtInMatchers.forEach(Route.defineMatcher);
+var Route_default = Route;
+
+//#endregion
+export { Route_default };

package/dist/node_modules/.pnpm/fetch-mock@12.5.2/node_modules/fetch-mock/dist/esm/Router.js

@@ -0,0 +1,181 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { hasCredentialsInUrl } from "./RequestUtils.js";
+import { isFunctionMatcher, isUrlMatcher } from "./Matchers.js";
+import { Route_default } from "./Route.js";
+
+//#region node_modules/.pnpm/fetch-mock@12.5.2/node_modules/fetch-mock/dist/esm/Router.js
+const responseConfigProps = [
+	"body",
+	"headers",
+	"throws",
+	"status",
+	"redirectUrl"
+];
+function nameToOptions(options) {
+	return typeof options === "string" ? { name: options } : options;
+}
+function isPromise(response) {
+	return typeof response.then === "function";
+}
+function normalizeResponseInput(responseInput) {
+	if (typeof responseInput === "number") return { status: responseInput };
+	else if (typeof responseInput === "string" || shouldSendAsObject(responseInput)) return { body: responseInput };
+	return responseInput;
+}
+function shouldSendAsObject(responseInput) {
+	if (responseConfigProps.some((prop) => prop in responseInput)) {
+		if (Object.keys(responseInput).every((key) => responseConfigProps.includes(key))) return false;
+		return true;
+	}
+	return true;
+}
+function throwSpecExceptions({ url, options: { headers, method, body } }) {
+	if (headers) Object.entries(headers).forEach(([key]) => {
+		if (/\s/.test(key)) throw new TypeError("Invalid name");
+	});
+	if (hasCredentialsInUrl(url)) throw new TypeError(`Request cannot be constructed from a URL that includes credentials: ${url}`);
+	if (["get", "head"].includes(method) && body) throw new TypeError("Request with GET/HEAD method cannot have body.");
+}
+const resolveUntilResponseConfig = async (callLog) => {
+	let response = callLog.route.config.response;
+	while (true) if (typeof response === "function") response = response(callLog);
+	else if (isPromise(response)) response = await response;
+	else return response;
+};
+var Router = class {
+	constructor(fetchMockConfig, { routes, fallbackRoute } = {}) {
+		this.config = fetchMockConfig;
+		this.routes = routes || [];
+		this.fallbackRoute = fallbackRoute;
+	}
+	needsToReadBody(request) {
+		return Boolean(request && this.routes.some((route) => route.config.usesBody));
+	}
+	execute(callLog) {
+		throwSpecExceptions(callLog);
+		return new Promise(async (resolve, reject) => {
+			const { url, options, request, pendingPromises } = callLog;
+			if (callLog.signal) {
+				const abort = () => {
+					const error = new DOMException("The operation was aborted.", "AbortError");
+					const requestBody = request?.body || options?.body;
+					if (requestBody instanceof ReadableStream) if (requestBody.locked) requestBody.getReader().cancel(error);
+					else requestBody.cancel(error);
+					if (callLog?.response?.body) if (callLog.response.body.locked) callLog.response.body.getReader().cancel(error);
+					else callLog.response.body.cancel(error);
+					reject(error);
+				};
+				if (callLog.signal.aborted) abort();
+				callLog.signal.addEventListener("abort", abort);
+			}
+			if (this.needsToReadBody(request)) options.body = await options.body;
+			const routesToTry = this.fallbackRoute ? [...this.routes, this.fallbackRoute] : this.routes;
+			const route = routesToTry.find((route$1) => route$1.matcher(callLog));
+			if (route) try {
+				callLog.route = route;
+				const { response, responseOptions, responseInput } = await this.generateResponse(callLog);
+				const observableResponse = this.createObservableResponse(response, responseOptions, responseInput, url, pendingPromises);
+				callLog.response = response;
+				resolve(observableResponse);
+			} catch (err) {
+				reject(err);
+			}
+			else reject(new Error(`fetch-mock: No response or fallback rule to cover ${options && options.method || "GET"} to ${url}`));
+		});
+	}
+	async generateResponse(callLog) {
+		const responseInput = await resolveUntilResponseConfig(callLog);
+		if (responseInput instanceof Response) return {
+			response: responseInput.clone(),
+			responseOptions: {},
+			responseInput: {}
+		};
+		const responseConfig = normalizeResponseInput(responseInput);
+		if (responseConfig.throws) throw responseConfig.throws;
+		return callLog.route.constructResponse(responseConfig);
+	}
+	createObservableResponse(response, responseConfig, responseInput, responseUrl, pendingPromises) {
+		return new Proxy(response, { get: (originalResponse, name) => {
+			if (responseInput.redirectUrl) {
+				if (name === "url") return responseInput.redirectUrl;
+				if (name === "redirected") return true;
+			} else {
+				if (name === "url") return responseUrl;
+				if (name === "redirected") return false;
+			}
+			if (responseInput.status === 0) {
+				if (name === "status") return 0;
+				if (name === "statusText") return "";
+			}
+			if (typeof response[name] === "function") return new Proxy(response[name], { apply: (func, thisArg, args) => {
+				const result = func.apply(response, args);
+				if (result.then) pendingPromises.push(result.catch(() => void 0));
+				return result;
+			} });
+			return originalResponse[name];
+		} });
+	}
+	addRoute(matcher, response, nameOrOptions) {
+		const config = {};
+		if (isUrlMatcher(matcher)) config.url = matcher;
+		else if (isFunctionMatcher(matcher)) config.matcherFunction = matcher;
+		else Object.assign(config, matcher);
+		if (typeof response !== "undefined") config.response = response;
+		if (nameOrOptions) Object.assign(config, typeof nameOrOptions === "string" ? nameToOptions(nameOrOptions) : nameOrOptions);
+		const route = new Route_default({
+			...this.config,
+			...config
+		});
+		if (route.config.name && this.routes.some(({ config: { name: existingName } }) => route.config.name === existingName)) throw new Error("fetch-mock: Adding route with same name as existing route.");
+		if (route.config.waitFor) {
+			const routeNamesToWaitFor = Array.isArray(route.config.waitFor) ? route.config.waitFor : [route.config.waitFor];
+			const routesToAwait = [];
+			routeNamesToWaitFor.forEach((routeName) => {
+				const routeToAwait = this.routes.find(({ config: { name: existingName } }) => routeName === existingName);
+				if (routeToAwait) routesToAwait.push(routeToAwait);
+				else throw new Error(`Cannot wait for route \`${routeName}\`: route of that name does not exist`);
+			});
+			route.waitFor(routesToAwait);
+		}
+		this.routes.push(route);
+	}
+	setFallback(response) {
+		if (this.fallbackRoute) console.warn("calling fetchMock.catch() twice - are you sure you want to overwrite the previous fallback response");
+		this.fallbackRoute = new Route_default({
+			matcherFunction: () => true,
+			response: response || "ok",
+			...this.config
+		});
+		this.fallbackRoute.config.isFallback = true;
+	}
+	removeRoutes({ names, includeSticky, includeFallback } = {}) {
+		includeFallback = includeFallback ?? true;
+		this.routes = this.routes.filter(({ config: { sticky, name } }) => {
+			if (sticky && !includeSticky) return true;
+			if (!names) return false;
+			return !names.includes(name);
+		});
+		if (includeFallback) delete this.fallbackRoute;
+	}
+	modifyRoute(routeName, options) {
+		const route = this.routes.find(({ config: { name } }) => name === routeName);
+		if (!route) throw new Error(`Cannot call modifyRoute() on route \`${routeName}\`: route of that name not found`);
+		if (route.config.sticky) throw new Error(`Cannot call modifyRoute() on route \`${routeName}\`: route is sticky and cannot be modified`);
+		if ("name" in options) throw new Error(`Cannot rename the route \`${routeName}\` as \`${options.name}\`: renaming routes is not supported`);
+		if ("sticky" in options) throw new Error(`Altering the stickiness of route \`${routeName}\` is not supported`);
+		const newConfig = {
+			...route.config,
+			...options
+		};
+		Object.entries(options).forEach(([key, value]) => {
+			if (value === null) delete newConfig[key];
+		});
+		route.init(newConfig);
+	}
+};
+
+//#endregion
+export { Router as Router$2 };

package/dist/node_modules/.pnpm/fetch-mock@12.5.2/node_modules/fetch-mock/dist/esm/StatusTextMap.js

@@ -0,0 +1,73 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/fetch-mock@12.5.2/node_modules/fetch-mock/dist/esm/StatusTextMap.js
+const statusTextMap = {
+	100: "Continue",
+	101: "Switching Protocols",
+	102: "Processing",
+	200: "OK",
+	201: "Created",
+	202: "Accepted",
+	203: "Non-Authoritative Information",
+	204: "No Content",
+	205: "Reset Content",
+	206: "Partial Content",
+	207: "Multi-Status",
+	208: "Already Reported",
+	226: "IM Used",
+	300: "Multiple Choices",
+	301: "Moved Permanently",
+	302: "Found",
+	303: "See Other",
+	304: "Not Modified",
+	305: "Use Proxy",
+	307: "Temporary Redirect",
+	308: "Permanent Redirect",
+	400: "Bad Request",
+	401: "Unauthorized",
+	402: "Payment Required",
+	403: "Forbidden",
+	404: "Not Found",
+	405: "Method Not Allowed",
+	406: "Not Acceptable",
+	407: "Proxy Authentication Required",
+	408: "Request Timeout",
+	409: "Conflict",
+	410: "Gone",
+	411: "Length Required",
+	412: "Precondition Failed",
+	413: "Payload Too Large",
+	414: "URI Too Long",
+	415: "Unsupported Media Type",
+	416: "Range Not Satisfiable",
+	417: "Expectation Failed",
+	418: "I'm a teapot",
+	421: "Misdirected Request",
+	422: "Unprocessable Entity",
+	423: "Locked",
+	424: "Failed Dependency",
+	425: "Unordered Collection",
+	426: "Upgrade Required",
+	428: "Precondition Required",
+	429: "Too Many Requests",
+	431: "Request Header Fields Too Large",
+	451: "Unavailable For Legal Reasons",
+	500: "Internal Server Error",
+	501: "Not Implemented",
+	502: "Bad Gateway",
+	503: "Service Unavailable",
+	504: "Gateway Timeout",
+	505: "HTTP Version Not Supported",
+	506: "Variant Also Negotiates",
+	507: "Insufficient Storage",
+	508: "Loop Detected",
+	509: "Bandwidth Limit Exceeded",
+	510: "Not Extended",
+	511: "Network Authentication Required"
+};
+var StatusTextMap_default = statusTextMap;
+
+//#endregion
+export { StatusTextMap_default };

package/dist/node_modules/.pnpm/fetch-mock@12.5.2/node_modules/fetch-mock/dist/esm/TypeDescriptor.js

@@ -0,0 +1,97 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/fetch-mock@12.5.2/node_modules/fetch-mock/dist/esm/TypeDescriptor.js
+const valueTypes = new Set([
+	"boolean",
+	"number",
+	"null",
+	"string",
+	"undefined"
+]);
+const referenceTypes = new Set([
+	"array",
+	"function",
+	"object",
+	"symbol"
+]);
+const detectableTypes = new Set([
+	"boolean",
+	"function",
+	"number",
+	"string",
+	"symbol"
+]);
+const typeConstructors = new Set([
+	Boolean,
+	Number,
+	String
+]);
+var TypeDescriptor = class TypeDescriptor {
+	constructor(value) {
+		this.name = TypeDescriptor.of(value);
+		this.isValueType = TypeDescriptor.isValueType(value);
+		this.isReferenceType = TypeDescriptor.isReferenceType(value);
+		this.isArray = TypeDescriptor.isArray(value);
+		this.isBoolean = TypeDescriptor.isBoolean(value);
+		this.isFunction = TypeDescriptor.isFunction(value);
+		this.isNull = TypeDescriptor.isNull(value);
+		this.isNumber = TypeDescriptor.isNumber(value);
+		this.isObject = TypeDescriptor.isObject(value);
+		this.isString = TypeDescriptor.isString(value);
+		this.isSymbol = TypeDescriptor.isSymbol(value);
+		this.isUndefined = TypeDescriptor.isUndefined(value);
+	}
+	static of(value) {
+		if (value === null) return "null";
+		if (value === void 0) return "undefined";
+		const detectedType = typeof value;
+		if (detectableTypes.has(detectedType)) return detectedType;
+		if (detectedType === "object") {
+			if (Array.isArray(value)) return "array";
+			if (typeConstructors.has(value.constructor)) return value.constructor.name.toLowerCase();
+			return detectedType;
+		}
+		throw new Error("Failed due to an unknown type.");
+	}
+	static from(value) {
+		return new TypeDescriptor(value);
+	}
+	static isValueType(value) {
+		return valueTypes.has(TypeDescriptor.of(value));
+	}
+	static isReferenceType(value) {
+		return referenceTypes.has(TypeDescriptor.of(value));
+	}
+	static isArray(value) {
+		return TypeDescriptor.of(value) === "array";
+	}
+	static isBoolean(value) {
+		return TypeDescriptor.of(value) === "boolean";
+	}
+	static isFunction(value) {
+		return TypeDescriptor.of(value) === "function";
+	}
+	static isNull(value) {
+		return TypeDescriptor.of(value) === "null";
+	}
+	static isNumber(value) {
+		return TypeDescriptor.of(value) === "number";
+	}
+	static isObject(value) {
+		return TypeDescriptor.of(value) === "object";
+	}
+	static isString(value) {
+		return TypeDescriptor.of(value) === "string";
+	}
+	static isSymbol(value) {
+		return TypeDescriptor.of(value) === "symbol";
+	}
+	static isUndefined(value) {
+		return TypeDescriptor.of(value) === "undefined";
+	}
+};
+
+//#endregion
+export { TypeDescriptor };

package/dist/node_modules/.pnpm/fetch-mock@12.5.2/node_modules/fetch-mock/dist/esm/index.js

@@ -0,0 +1,11 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { FetchMock, FetchMock_default, defaultFetchMockConfig } from "./FetchMock.js";
+
+//#region node_modules/.pnpm/fetch-mock@12.5.2/node_modules/fetch-mock/dist/esm/index.js
+var esm_default = FetchMock_default;
+
+//#endregion
+export { esm_default };

package/dist/node_modules/.pnpm/glob-to-regexp@0.4.1/node_modules/glob-to-regexp/index.js

@@ -0,0 +1,87 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { __commonJS } from "../../../../../_virtual/rolldown_runtime.js";
+
+//#region node_modules/.pnpm/glob-to-regexp@0.4.1/node_modules/glob-to-regexp/index.js
+var require_glob_to_regexp = __commonJS({ "node_modules/.pnpm/glob-to-regexp@0.4.1/node_modules/glob-to-regexp/index.js"(exports, module) {
+	module.exports = function(glob, opts) {
+		if (typeof glob !== "string") throw new TypeError("Expected a string");
+		var str = String(glob);
+		var reStr = "";
+		var extended = opts ? !!opts.extended : false;
+		var globstar = opts ? !!opts.globstar : false;
+		var inGroup = false;
+		var flags = opts && typeof opts.flags === "string" ? opts.flags : "";
+		var c;
+		for (var i = 0, len = str.length; i < len; i++) {
+			c = str[i];
+			switch (c) {
+				case "/":
+				case "$":
+				case "^":
+				case "+":
+				case ".":
+				case "(":
+				case ")":
+				case "=":
+				case "!":
+				case "|":
+					reStr += "\\" + c;
+					break;
+				case "?": if (extended) {
+					reStr += ".";
+					break;
+				}
+				case "[":
+				case "]": if (extended) {
+					reStr += c;
+					break;
+				}
+				case "{": if (extended) {
+					inGroup = true;
+					reStr += "(";
+					break;
+				}
+				case "}": if (extended) {
+					inGroup = false;
+					reStr += ")";
+					break;
+				}
+				case ",":
+					if (inGroup) {
+						reStr += "|";
+						break;
+					}
+					reStr += "\\" + c;
+					break;
+				case "*":
+					var prevChar = str[i - 1];
+					var starCount = 1;
+					while (str[i + 1] === "*") {
+						starCount++;
+						i++;
+					}
+					var nextChar = str[i + 1];
+					if (!globstar) reStr += ".*";
+					else {
+						var isGlobstar = starCount > 1 && (prevChar === "/" || prevChar === void 0) && (nextChar === "/" || nextChar === void 0);
+						if (isGlobstar) {
+							reStr += "((?:[^/]*(?:/|$))*)";
+							i++;
+						} else reStr += "([^/]*)";
+					}
+					break;
+				default: reStr += c;
+			}
+		}
+		if (!flags || !~flags.indexOf("g")) reStr = "^" + reStr + "$";
+		return new RegExp(reStr, flags);
+	};
+} });
+
+//#endregion
+export default require_glob_to_regexp();
+
+export { require_glob_to_regexp };

package/dist/node_modules/.pnpm/regexparam@3.0.0/node_modules/regexparam/dist/index.js

@@ -0,0 +1,37 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/regexparam@3.0.0/node_modules/regexparam/dist/index.mjs
+/**
+* @param {string|RegExp} input The route pattern
+* @param {boolean} [loose] Allow open-ended matching. Ignored with `RegExp` input.
+*/
+function parse(input, loose) {
+	if (input instanceof RegExp) return {
+		keys: false,
+		pattern: input
+	};
+	var c, o, tmp, ext, keys = [], pattern = "", arr = input.split("/");
+	arr[0] || arr.shift();
+	while (tmp = arr.shift()) {
+		c = tmp[0];
+		if (c === "*") {
+			keys.push(c);
+			pattern += tmp[1] === "?" ? "(?:/(.*))?" : "/(.*)";
+		} else if (c === ":") {
+			o = tmp.indexOf("?", 1);
+			ext = tmp.indexOf(".", 1);
+			keys.push(tmp.substring(1, !!~o ? o : !!~ext ? ext : tmp.length));
+			pattern += !!~o && !~ext ? "(?:/([^/]+?))?" : "/([^/]+?)";
+			if (!!~ext) pattern += (!!~o ? "?" : "") + "\\" + tmp.substring(ext);
+		} else pattern += "/" + tmp;
+	}
+	return {
+		keys,
+		pattern: new RegExp("^" + pattern + (loose ? "(?=$|/)" : "/?$"), "i")
+	};
+}
+
+//#endregion
+export { parse as parse$1 };

package/dist/runtime/authdocloader.test.js

@@ -10,13 +10,13 @@ import { test } from "../testing/mod.js";
 import { assertRejects } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_rejects.js";
 import { mockDocumentLoader } from "../testing/docloader.js";
 import { rsaPrivateKey2 } from "../testing/keys.js";
-import { install, mock, uninstall } from "../node_modules/.pnpm/@jsr_hongminhee__deno-mock-fetch@0.3.2/node_modules/@jsr/hongminhee__deno-mock-fetch/mod.js";
+import { esm_default } from "../node_modules/.pnpm/fetch-mock@12.5.2/node_modules/fetch-mock/dist/esm/index.js";
 
 //#region runtime/authdocloader.test.ts
 test("getAuthenticatedDocumentLoader()", async (t) => {
-	install();
-	mock("GET@/object", async (req) => {
-		const v = await verifyRequest(req, {
+	esm_default.spyGlobal();
+	esm_default.get("begin:https://example.com/object", async (cl) => {
+		const v = await verifyRequest(cl.request, {
 			documentLoader: mockDocumentLoader,
 			contextLoader: mockDocumentLoader,
 			currentTime: Temporal.Now.instant()
@@ -34,7 +34,7 @@ test("getAuthenticatedDocumentLoader()", async (t) => {
 			document: true
 		});
 	});
-	uninstall();
+	esm_default.hardReset();
 	await t.step("deny non-HTTP/HTTPS", async () => {
 		const loader = await getAuthenticatedDocumentLoader({
 			keyId: new URL("https://example.com/key2"),

package/dist/runtime/docloader.js

@@ -279,7 +279,7 @@ function kvCache({ loader, kv, prefix, rules }) {
 */
 function getUserAgent({ software, url } = {}) {
 	const fedify = `Fedify/${deno_default.version}`;
-	const runtime = globalThis.Deno?.version?.deno != null ? `Deno/${Deno.version.deno}` : globalThis.process?.versions?.bun != null ? `Bun/${process.versions.bun}` : globalThis.process?.versions?.node != null ? `Node.js/${process.versions.node}` : null;
+	const runtime = globalThis.Deno?.version?.deno != null ? `Deno/${Deno.version.deno}` : globalThis.process?.versions?.bun != null ? `Bun/${process.versions.bun}` : "navigator" in globalThis && navigator.userAgent === "Cloudflare-Workers" ? navigator.userAgent : globalThis.process?.versions?.node != null ? `Node.js/${process.versions.node}` : null;
 	const userAgent = software == null ? [fedify] : [software, fedify];
 	if (runtime != null) userAgent.push(runtime);
 	if (url != null) userAgent.push(`+${url.toString()}`);

package/dist/runtime/docloader.test.js

@@ -414,6 +414,14 @@ test("getUserAgent()", () => {
 			software: "MyApp/1.0.0",
 			url: new URL("https://example.com/")
 		}), `MyApp/1.0.0 (Fedify/${deno_default.version}; Bun/${Bun.version}; +https://example.com/)`);
+	} else if (navigator.userAgent === "Cloudflare-Workers") {
+		assertEquals(getUserAgent(), `Fedify/${deno_default.version} (Cloudflare-Workers)`);
+		assertEquals(getUserAgent({ software: "MyApp/1.0.0" }), `MyApp/1.0.0 (Fedify/${deno_default.version}; Cloudflare-Workers)`);
+		assertEquals(getUserAgent({ url: "https://example.com/" }), `Fedify/${deno_default.version} (Cloudflare-Workers; +https://example.com/)`);
+		assertEquals(getUserAgent({
+			software: "MyApp/1.0.0",
+			url: new URL("https://example.com/")
+		}), `MyApp/1.0.0 (Fedify/${deno_default.version}; Cloudflare-Workers; +https://example.com/)`);
 	} else {
 		assertEquals(getUserAgent(), `Fedify/${deno_default.version} (Node.js/${process.versions.node})`);
 		assertEquals(getUserAgent({ software: "MyApp/1.0.0" }), `MyApp/1.0.0 (Fedify/${deno_default.version}; Node.js/${process.versions.node})`);