@fedify/vocab-runtime 2.5.0-dev.2448 → 2.5.0-dev.2492

package/dist/tests/docloader.test.cjs

@@ -1,1224 +1,15 @@
-const require_rolldown_runtime = require("./rolldown-runtime-emK7D4bc.cjs");
-const require_request = require("./request-B77_oZnk.cjs");
-const require_url = require("./url-BNakuZ8k.cjs");
+const require_request = require("./request-7q-Zfe1p.cjs");
+const require_url = require("./url-Bdj-rTcC.cjs");
 const require_contexts = require("./contexts-C9Lj11SC.cjs");
-const require_docloader = require("./docloader-CwxZguqN.cjs");
+const require_public_fetch = require("./public-fetch-BGj5pzUD.cjs");
+const require_docloader = require("./docloader-D1fNCGam.cjs");
+const require_esm = require("./esm-Q2tdh5f3.cjs");
 const require_jsonld = require("./jsonld-CmDhHNTx.cjs");
 let node_zlib = require("node:zlib");
 let _logtape_logtape = require("@logtape/logtape");
-let node_dns_promises = require("node:dns/promises");
-node_dns_promises = require_rolldown_runtime.__toESM(node_dns_promises, 1);
 let node_assert = require("node:assert");
 let _fedify_fixture = require("@fedify/fixture");
 let node_http = require("node:http");
-//#region ../../node_modules/.pnpm/glob-to-regexp@0.4.1/node_modules/glob-to-regexp/index.js
-var require_glob_to_regexp = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((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 if (starCount > 1 && (prevChar === "/" || prevChar === void 0) && (nextChar === "/" || nextChar === void 0)) {
-						reStr += "((?:[^/]*(?:/|$))*)";
-						i++;
-					} else reStr += "([^/]*)";
-					break;
-				default: reStr += c;
-			}
-		}
-		if (!flags || !~flags.indexOf("g")) reStr = "^" + reStr + "$";
-		return new RegExp(reStr, flags);
-	};
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/regexparam@3.0.0/node_modules/regexparam/dist/index.mjs
-var import_glob_to_regexp = /* @__PURE__ */ require_rolldown_runtime.__toESM(require_glob_to_regexp(), 1);
-/**
-* @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
-//#region ../../node_modules/.pnpm/fetch-mock@12.6.0/node_modules/fetch-mock/dist/esm/TypeDescriptor.js
-const valueTypes = /* @__PURE__ */ new Set([
-	"boolean",
-	"number",
-	"null",
-	"string",
-	"undefined"
-]);
-const referenceTypes = /* @__PURE__ */ new Set([
-	"array",
-	"function",
-	"object",
-	"symbol"
-]);
-const detectableTypes = /* @__PURE__ */ new Set([
-	"boolean",
-	"function",
-	"number",
-	"string",
-	"symbol"
-]);
-const typeConstructors = /* @__PURE__ */ 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
-//#region ../../node_modules/.pnpm/fetch-mock@12.6.0/node_modules/fetch-mock/dist/esm/IsSubsetOf.js
-const allowedTypes = /* @__PURE__ */ new Set([
-	"array",
-	"object",
-	"function",
-	"null"
-]);
-const isSubsetOf = function(subset, superset, visited = []) {
-	const subsetType = TypeDescriptor.of(subset);
-	const supersetType = TypeDescriptor.of(superset);
-	if (!allowedTypes.has(subsetType)) throw new Error(`Type '${subsetType}' is not supported.`);
-	if (!allowedTypes.has(supersetType)) throw new Error(`Type '${supersetType}' is not supported.`);
-	if (TypeDescriptor.isFunction(subset)) {
-		if (!TypeDescriptor.isFunction(superset)) throw new Error(`Types '${subsetType}' and '${supersetType}' do not match.`);
-		return subset.toString() === superset.toString();
-	}
-	if (TypeDescriptor.isArray(subset)) {
-		if (!TypeDescriptor.isArray(superset)) throw new Error(`Types '${subsetType}' and '${supersetType}' do not match.`);
-		if (subset.length > superset.length) return false;
-		for (const subsetItem of subset) {
-			const subsetItemType = TypeDescriptor.of(subsetItem);
-			let isItemInSuperset;
-			switch (subsetItemType) {
-				case "array":
-				case "object":
-				case "function":
-					if (visited.includes(subsetItem)) continue;
-					visited.push(subsetItem);
-					isItemInSuperset = superset.some((supersetItem) => {
-						try {
-							return isSubsetOf(subsetItem, supersetItem, visited);
-						} catch {
-							return false;
-						}
-					});
-					break;
-				default: isItemInSuperset = superset.includes(subsetItem);
-			}
-			if (!isItemInSuperset) return false;
-		}
-		return true;
-	}
-	if (TypeDescriptor.isObject(subset)) {
-		if (!TypeDescriptor.isObject(superset) || TypeDescriptor.isArray(superset)) throw new Error(`Types '${subsetType}' and '${supersetType}' do not match.`);
-		if (Object.keys(subset).length > Object.keys(superset).length) return false;
-		for (const [subsetKey, subsetValue] of Object.entries(subset)) {
-			const supersetValue = superset[subsetKey];
-			switch (TypeDescriptor.of(subsetValue)) {
-				case "array":
-				case "object":
-				case "function":
-					if (visited.includes(subsetValue)) continue;
-					visited.push(subsetValue);
-					try {
-						if (!isSubsetOf(subsetValue, supersetValue, visited)) return false;
-					} catch {
-						return false;
-					}
-					break;
-				default: if (subsetValue !== supersetValue) return false;
-			}
-		}
-		return true;
-	}
-	if (TypeDescriptor.isNull(subset)) {
-		if (!TypeDescriptor.isNull(superset)) throw new Error(`Types '${subsetType}' and '${supersetType}' do not match.`);
-		return true;
-	}
-	throw new Error("Invalid operation.");
-};
-isSubsetOf.structural = function(subset, superset, visited = []) {
-	if (!TypeDescriptor.isObject(subset)) throw new Error(`Type '${TypeDescriptor.of(subset)}' is not supported.`);
-	if (!TypeDescriptor.isObject(superset)) throw new Error(`Type '${TypeDescriptor.of(superset)}' is not supported.`);
-	for (const [subsetKey, subsetValue] of Object.entries(subset)) {
-		if (superset[subsetKey] === void 0) return false;
-		const subsetValueType = TypeDescriptor.of(subsetValue);
-		const supersetValue = superset[subsetKey];
-		if (subsetValueType === "object") {
-			if (visited.includes(subsetValue)) continue;
-			visited.push(subsetValue);
-			try {
-				if (!isSubsetOf.structural(subsetValue, supersetValue, visited)) return false;
-			} catch {
-				return false;
-			}
-		}
-	}
-	return true;
-};
-//#endregion
-//#region ../../node_modules/.pnpm/dequal@2.0.3/node_modules/dequal/dist/index.mjs
-var has = Object.prototype.hasOwnProperty;
-function find(iter, tar, key) {
-	for (key of iter.keys()) if (dequal(key, tar)) return key;
-}
-function dequal(foo, bar) {
-	var ctor, len, tmp;
-	if (foo === bar) return true;
-	if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
-		if (ctor === Date) return foo.getTime() === bar.getTime();
-		if (ctor === RegExp) return foo.toString() === bar.toString();
-		if (ctor === Array) {
-			if ((len = foo.length) === bar.length) while (len-- && dequal(foo[len], bar[len]));
-			return len === -1;
-		}
-		if (ctor === Set) {
-			if (foo.size !== bar.size) return false;
-			for (len of foo) {
-				tmp = len;
-				if (tmp && typeof tmp === "object") {
-					tmp = find(bar, tmp);
-					if (!tmp) return false;
-				}
-				if (!bar.has(tmp)) return false;
-			}
-			return true;
-		}
-		if (ctor === Map) {
-			if (foo.size !== bar.size) return false;
-			for (len of foo) {
-				tmp = len[0];
-				if (tmp && typeof tmp === "object") {
-					tmp = find(bar, tmp);
-					if (!tmp) return false;
-				}
-				if (!dequal(len[1], bar.get(tmp))) return false;
-			}
-			return true;
-		}
-		if (ctor === ArrayBuffer) {
-			foo = new Uint8Array(foo);
-			bar = new Uint8Array(bar);
-		} else if (ctor === DataView) {
-			if ((len = foo.byteLength) === bar.byteLength) while (len-- && foo.getInt8(len) === bar.getInt8(len));
-			return len === -1;
-		}
-		if (ArrayBuffer.isView(foo)) {
-			if ((len = foo.byteLength) === bar.byteLength) while (len-- && foo[len] === bar[len]);
-			return len === -1;
-		}
-		if (!ctor || typeof foo === "object") {
-			len = 0;
-			for (ctor in foo) {
-				if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
-				if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return false;
-			}
-			return Object.keys(bar).length === len;
-		}
-	}
-	return foo !== foo && bar !== bar;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/fetch-mock@12.6.0/node_modules/fetch-mock/dist/esm/RequestUtils.js
-const absoluteUrlRX = /* @__PURE__ */ new RegExp("^[a-z]+://|^data:", "i");
-const protocolRelativeUrlRX = /* @__PURE__ */ new RegExp("^//", "i");
-function hasCredentialsInUrl(url) {
-	const urlObject = new URL(url, !absoluteUrlRX.test(url) ? "http://dummy" : void 0);
-	return Boolean(urlObject.username || urlObject.password);
-}
-function normalizeUrl(url, allowRelativeUrls) {
-	if (url instanceof URL) return url.href;
-	const primitiveUrl = String(url).valueOf();
-	if (absoluteUrlRX.test(primitiveUrl)) return new URL(primitiveUrl).href;
-	if (protocolRelativeUrlRX.test(primitiveUrl)) return new URL(primitiveUrl, "http://dummy").href.replace(/^[a-z]+:/, "");
-	if ("location" in globalThis) if (primitiveUrl.startsWith("/")) return `${globalThis.location.origin}${primitiveUrl}`;
-	else return `${globalThis.location.href}/${primitiveUrl}`;
-	else if (allowRelativeUrls) {
-		const urlInstance = new URL(primitiveUrl, "http://dummy");
-		return urlInstance.pathname + urlInstance.search;
-	} else throw new Error("Relative urls are not support by default in node.js tests. Either use a utility such as jsdom to define globalThis.location or set `fetchMock.config.allowRelativeUrls = true`");
-}
-function createCallLogFromUrlAndOptions(url, options) {
-	const pendingPromises = [];
-	if (typeof url === "string" || url instanceof String || url instanceof URL) {
-		const normalizedUrl = normalizeUrl(url, true);
-		const derivedOptions = options ? { ...options } : {};
-		if (derivedOptions.headers) derivedOptions.headers = normalizeHeaders(derivedOptions.headers);
-		derivedOptions.method = derivedOptions.method ? derivedOptions.method.toLowerCase() : "get";
-		return {
-			args: [url, options],
-			url: normalizedUrl,
-			queryParams: new URLSearchParams(getQuery(normalizedUrl)),
-			options: derivedOptions,
-			signal: derivedOptions.signal,
-			pendingPromises
-		};
-	}
-	if (typeof url === "object") throw new TypeError("fetch-mock: Unrecognised Request object. Read the Config and Installation sections of the docs");
-	else throw new TypeError("fetch-mock: Invalid arguments passed to fetch");
-}
-async function createCallLogFromRequest(request, options) {
-	const pendingPromises = [];
-	const derivedOptions = { method: request.method };
-	try {
-		try {
-			derivedOptions.body = await request.clone().formData();
-		} catch {
-			derivedOptions.body = await request.clone().text();
-		}
-	} catch {}
-	if (request.headers) derivedOptions.headers = normalizeHeaders(request.headers);
-	const url = normalizeUrl(request.url, true);
-	return {
-		args: [request, options],
-		url,
-		queryParams: new URLSearchParams(getQuery(url)),
-		options: Object.assign(derivedOptions, options || {}),
-		request,
-		signal: options && options.signal || request.signal,
-		pendingPromises
-	};
-}
-function getPath(url) {
-	return (absoluteUrlRX.test(url) ? new URL(url) : new URL(url, "http://dummy")).pathname;
-}
-function getHost(url) {
-	if (absoluteUrlRX.test(url)) return new URL(url).host;
-	else if ("location" in globalThis) return globalThis.location.host;
-	return null;
-}
-function getQuery(url) {
-	const u = absoluteUrlRX.test(url) ? new URL(url) : new URL(url, "http://dummy");
-	return u.search ? u.search.substr(1) : "";
-}
-function normalizeHeaders(headers) {
-	let entries;
-	if (headers instanceof Headers) entries = [...headers.entries()];
-	else if (Array.isArray(headers)) entries = headers;
-	else entries = Object.entries(headers);
-	return Object.fromEntries(entries.map(([key, val]) => [key.toLowerCase(), String(val).valueOf()]));
-}
-//#endregion
-//#region ../../node_modules/.pnpm/fetch-mock@12.6.0/node_modules/fetch-mock/dist/esm/Matchers.js
-const isUrlMatcher = (matcher) => matcher instanceof RegExp || typeof matcher === "string" || typeof matcher === "object" && "href" in matcher;
-const isFunctionMatcher = (matcher) => typeof matcher === "function";
-const stringMatchers = {
-	begin: (targetString) => ({ url }) => url.startsWith(targetString),
-	end: (targetString) => ({ url }) => url.endsWith(targetString),
-	include: (targetString) => ({ url }) => url.includes(targetString),
-	glob: (targetString) => {
-		const urlRX = (0, import_glob_to_regexp.default)(targetString);
-		return ({ url }) => urlRX.test(url);
-	},
-	express: (targetString) => {
-		const urlRX = parse(targetString);
-		return (callLog) => {
-			const vals = urlRX.pattern.exec(getPath(callLog.url));
-			if (!vals) {
-				callLog.expressParams = {};
-				return false;
-			}
-			vals.shift();
-			callLog.expressParams = urlRX.keys.reduce((map, paramName, i) => vals[i] ? Object.assign(map, { [paramName]: vals[i] }) : map, {});
-			return true;
-		};
-	},
-	path: (targetString) => {
-		const dotlessTargetString = getPath(targetString);
-		return ({ url }) => {
-			const path = getPath(url);
-			return path === targetString || path === dotlessTargetString;
-		};
-	},
-	host: (targetString) => {
-		return ({ url }) => targetString === getHost(url);
-	}
-};
-const getHeaderMatcher = ({ headers: expectedHeaders }) => {
-	if (!expectedHeaders) return;
-	const expectation = normalizeHeaders(expectedHeaders);
-	return ({ options: { headers = {} } }) => {
-		const lowerCaseHeaders = normalizeHeaders(headers);
-		return Object.keys(expectation).every((headerName) => lowerCaseHeaders[headerName] === expectation[headerName]);
-	};
-};
-const getMissingHeaderMatcher = ({ missingHeaders: expectedMissingHeaders }) => {
-	if (!expectedMissingHeaders) return;
-	const expectation = expectedMissingHeaders.map((header) => header.toLowerCase());
-	return ({ options: { headers = {} } }) => {
-		const lowerCaseHeaders = normalizeHeaders(headers);
-		return expectation.every((headerName) => !(headerName in lowerCaseHeaders));
-	};
-};
-const getMethodMatcher = ({ method: expectedMethod }) => {
-	if (!expectedMethod) return;
-	return ({ options: { method } = {} }) => {
-		return expectedMethod === (method ? method.toLowerCase() : "get");
-	};
-};
-const getQueryParamsMatcher = ({ query: passedQuery }) => {
-	if (!passedQuery) return;
-	const expectedQuery = new URLSearchParams();
-	for (const [key, value] of Object.entries(passedQuery)) if (Array.isArray(value)) for (const item of value) expectedQuery.append(key, typeof item === "object" || typeof item === "undefined" ? "" : item.toString());
-	else expectedQuery.append(key, typeof value === "object" || typeof value === "undefined" ? "" : value.toString());
-	const keys = Array.from(expectedQuery.keys());
-	return ({ queryParams }) => {
-		return keys.every((key) => {
-			const expectedValues = expectedQuery.getAll(key).sort();
-			const actualValues = queryParams.getAll(key).sort();
-			if (expectedValues.length !== actualValues.length) return false;
-			if (Array.isArray(passedQuery[key])) return expectedValues.every((expected, index) => expected === actualValues[index]);
-			return dequal(actualValues, expectedValues);
-		});
-	};
-};
-const getExpressParamsMatcher = ({ params: expectedParams, url }) => {
-	if (!expectedParams) return;
-	if (!(typeof url === "string" && /express:/.test(url))) throw new Error("fetch-mock: matching on params is only possible when using an express: matcher");
-	const expectedKeys = Object.keys(expectedParams);
-	return ({ expressParams = {} }) => {
-		return expectedKeys.every((key) => expressParams[key] === expectedParams[key]);
-	};
-};
-const formDataToObject = (formData) => {
-	const fields = [...formData];
-	const result = {};
-	fields.forEach(([key, value]) => {
-		result[key] = result[key] || [];
-		result[key].push(value);
-	});
-	return result;
-};
-const getBodyMatcher = (route) => {
-	let { body: expectedBody } = route;
-	let expectedBodyType = "json";
-	if (!expectedBody) return;
-	if (expectedBody instanceof FormData) {
-		expectedBodyType = "formData";
-		expectedBody = formDataToObject(expectedBody);
-	}
-	return ({ options: { body, method = "get" } }) => {
-		if (["get", "head"].includes(method.toLowerCase())) return false;
-		let sentBody;
-		try {
-			if (typeof body === "string") {
-				sentBody = JSON.parse(body);
-				if (expectedBodyType !== "json") return false;
-			}
-		} catch {}
-		if (body instanceof FormData) {
-			if (expectedBodyType !== "formData") return false;
-			sentBody = formDataToObject(body);
-		}
-		return sentBody && (route.matchPartialBody ? isSubsetOf(expectedBody, sentBody) : dequal(expectedBody, sentBody));
-	};
-};
-const getFunctionMatcher = ({ matcherFunction }) => matcherFunction;
-const getRegexpMatcher = (regexp) => ({ url }) => regexp.test(url);
-const getFullUrlMatcher = (route, matcherUrl, query) => {
-	const expectedUrl = normalizeUrl(matcherUrl, route.allowRelativeUrls);
-	if (route.url === matcherUrl) route.url = expectedUrl;
-	return ({ url }) => {
-		if (query && expectedUrl.indexOf("?")) return getPath(url) === getPath(expectedUrl);
-		return normalizeUrl(url, true) === expectedUrl;
-	};
-};
-const getUrlMatcher = (route) => {
-	const { url: matcherUrl, query } = route;
-	if (matcherUrl === "*") return () => true;
-	if (matcherUrl instanceof RegExp) return getRegexpMatcher(matcherUrl);
-	if (matcherUrl instanceof URL) {
-		if (matcherUrl.href) return getFullUrlMatcher(route, matcherUrl.href, query);
-	}
-	if (typeof matcherUrl === "string") {
-		for (const shorthand in stringMatchers) if (matcherUrl.indexOf(`${shorthand}:`) === 0) {
-			const urlFragment = matcherUrl.replace(new RegExp(`^${shorthand}:`), "");
-			return stringMatchers[shorthand](urlFragment);
-		}
-		return getFullUrlMatcher(route, matcherUrl, query);
-	}
-	if (typeof matcherUrl === "object") {
-		const matchers = Object.entries(matcherUrl).map(([key, pattern]) => {
-			if (key === "regexp") return getRegexpMatcher(pattern);
-			else if (key in stringMatchers) return stringMatchers[key](pattern);
-			else throw new Error(`unrecognised url matching pattern: ${key}`);
-		});
-		return (route) => matchers.every((matcher) => matcher(route));
-	}
-};
-const builtInMatchers = [
-	{
-		name: "url",
-		matcher: getUrlMatcher
-	},
-	{
-		name: "query",
-		matcher: getQueryParamsMatcher
-	},
-	{
-		name: "method",
-		matcher: getMethodMatcher
-	},
-	{
-		name: "headers",
-		matcher: getHeaderMatcher
-	},
-	{
-		name: "missingHeaders",
-		matcher: getMissingHeaderMatcher
-	},
-	{
-		name: "params",
-		matcher: getExpressParamsMatcher
-	},
-	{
-		name: "body",
-		matcher: getBodyMatcher,
-		usesBody: true
-	},
-	{
-		name: "matcherFunction",
-		matcher: getFunctionMatcher
-	}
-];
-//#endregion
-//#region ../../node_modules/.pnpm/fetch-mock@12.6.0/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"
-};
-//#endregion
-//#region ../../node_modules/.pnpm/fetch-mock@12.6.0/node_modules/fetch-mock/dist/esm/Route.js
-var __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 = 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;
-var _a;
-var _Route_responseSubscriptions;
-var _Route_validate;
-var _Route_sanitize;
-var _Route_generateMatcher;
-var _Route_limit;
-var _Route_delayResponse;
-var RouteConfigWrapper = class {
-	constructor(config) {
-		Object.assign(this, config);
-	}
-};
-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[options.status];
-		options.headers = new this.config.Headers(responseInput.headers);
-		return options;
-	}
-	constructResponseBody(responseInput, responseOptions) {
-		let body = responseInput.body;
-		if (!isBodyInit(body)) 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 = /* @__PURE__ */ new WeakMap(), _Route_instances = /* @__PURE__ */ new WeakSet(), _Route_validate = function _Route_validate() {
-	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() {
-	if (this.config.method) this.config.method = this.config.method.toLowerCase();
-}, _Route_generateMatcher = function _Route_generateMatcher() {
-	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() {
-	if (!this.config.repeat) return;
-	const originalMatcher = this.matcher;
-	let timesLeft = this.config.repeat;
-	this.matcher = (callLog) => {
-		if (timesLeft && originalMatcher(callLog)) {
-			timesLeft--;
-			return true;
-		}
-	};
-	this.reset = () => {
-		timesLeft = this.config.repeat;
-	};
-}, _Route_delayResponse = function _Route_delayResponse() {
-	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);
-//#endregion
-//#region ../../node_modules/.pnpm/fetch-mock@12.6.0/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;
-			let eventListenerAbortController;
-			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) console.warn("fetch-mock: Locked request body can't be cancelled");
-					else requestBody.cancel(error);
-					if (callLog?.response?.body) if (callLog.response.body.locked) console.warn("fetch-mock: Locked response body can't be cancelled");
-					else callLog.response.body.cancel(error);
-					reject(error);
-				};
-				if (callLog.signal.aborted) abort();
-				eventListenerAbortController = new AbortController();
-				callLog.signal.addEventListener("abort", abort, {
-					once: true,
-					signal: eventListenerAbortController.signal
-				});
-			}
-			if (this.needsToReadBody(request)) options.body = await options.body;
-			const route = (this.fallbackRoute ? [...this.routes, this.fallbackRoute] : this.routes).find((route) => route.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);
-			} finally {
-				eventListenerAbortController?.abort();
-			}
-			else reject(/* @__PURE__ */ 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 (matcher instanceof RouteConfigWrapper) Object.assign(config, matcher);
-		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({
-			...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({
-			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
-//#region ../../node_modules/.pnpm/fetch-mock@12.6.0/node_modules/fetch-mock/dist/esm/CallHistory.js
-const isName = (filter) => typeof filter === "string" && /^[\da-zA-Z-]+$/.test(filter) && !["matched", "unmatched"].includes(filter);
-const isMatchedOrUnmatched = (filter) => typeof filter === "boolean" || ["matched", "unmatched"].includes(filter);
-var CallHistory = class {
-	constructor(config, router) {
-		this.callLogs = [];
-		this.config = config;
-		this.router = router;
-	}
-	recordCall(callLog) {
-		this.callLogs.push(callLog);
-	}
-	clear() {
-		this.callLogs.forEach(({ route }) => {
-			if (route) route.reset();
-		});
-		this.callLogs = [];
-	}
-	async flush(waitForResponseMethods) {
-		const queuedPromises = this.callLogs.flatMap((call) => call.pendingPromises);
-		await Promise.allSettled(queuedPromises);
-		if (waitForResponseMethods) {
-			await Promise.resolve();
-			await this.flush();
-		}
-	}
-	calls(filter, options) {
-		let calls = [...this.callLogs];
-		if (typeof filter === "undefined" && !options) return calls;
-		if (isMatchedOrUnmatched(filter)) {
-			if ([true, "matched"].includes(filter)) calls = calls.filter(({ route }) => !route?.config || !route.config.isFallback);
-			else if ([false, "unmatched"].includes(filter)) calls = calls.filter(({ route }) => Boolean(route?.config && route.config.isFallback));
-			if (!options) return calls;
-		} else if (isName(filter)) {
-			calls = calls.filter(({ route }) => route?.config?.name === filter);
-			if (!options) return calls;
-		} else if (isUrlMatcher(filter)) options = {
-			url: filter,
-			...options || {}
-		};
-		else options = {
-			...filter,
-			...options || {}
-		};
-		const { matcher } = new Route({
-			response: "ok",
-			...options
-		});
-		calls = calls.filter(({ url, options }) => {
-			return matcher(createCallLogFromUrlAndOptions(url, options));
-		});
-		return calls;
-	}
-	called(filter, options) {
-		return Boolean(this.calls(filter, options).length);
-	}
-	lastCall(filter, options) {
-		return this.calls(filter, options).pop();
-	}
-	done(routeNames) {
-		let routesToCheck = this.router.routes;
-		if (routeNames) {
-			routeNames = Array.isArray(routeNames) ? routeNames : [routeNames];
-			routesToCheck = this.router.routes.filter(({ config: { name } }) => routeNames.includes(name));
-		}
-		return routesToCheck.map((route) => {
-			const calls = this.callLogs.filter(({ route: routeApplied }) => routeApplied === route);
-			if (!calls.length) {
-				console.warn(`Warning: ${route.config.name} not called`);
-				return false;
-			}
-			const expectedTimes = route.config.repeat;
-			if (!expectedTimes) return true;
-			const actualTimes = calls.length;
-			if (expectedTimes > actualTimes) {
-				console.warn(`Warning: ${route.config.name} only called ${actualTimes} times, but ${expectedTimes} expected`);
-				return false;
-			}
-			return true;
-		}).every((isDone) => isDone);
-	}
-};
-//#endregion
-//#region ../../node_modules/.pnpm/fetch-mock@12.6.0/node_modules/fetch-mock/dist/esm/FetchMock.js
-const defaultFetchMockConfig = {
-	includeContentLength: true,
-	matchPartialBody: false,
-	Request: globalThis.Request,
-	Response: globalThis.Response,
-	Headers: globalThis.Headers,
-	fetch: globalThis.fetch
-};
-const defineShorthand = (shorthandOptions) => {
-	function shorthand(matcher, response, options) {
-		return this.route(matcher, response, Object.assign(options || {}, shorthandOptions));
-	}
-	return shorthand;
-};
-const defineGreedyShorthand = (shorthandOptions) => {
-	return function(response, options) {
-		return this.route("*", response, Object.assign(options || {}, shorthandOptions));
-	};
-};
-//#endregion
-//#region ../../node_modules/.pnpm/fetch-mock@12.6.0/node_modules/fetch-mock/dist/esm/index.js
-var esm_default = new class FetchMock {
-	constructor(config, router) {
-		this.sticky = defineShorthand({ sticky: true });
-		this.once = defineShorthand({ repeat: 1 });
-		this.any = defineGreedyShorthand({});
-		this.anyOnce = defineGreedyShorthand({ repeat: 1 });
-		this.get = defineShorthand({ method: "get" });
-		this.getOnce = defineShorthand({
-			method: "get",
-			repeat: 1
-		});
-		this.post = defineShorthand({ method: "post" });
-		this.postOnce = defineShorthand({
-			method: "post",
-			repeat: 1
-		});
-		this.put = defineShorthand({ method: "put" });
-		this.putOnce = defineShorthand({
-			method: "put",
-			repeat: 1
-		});
-		this.delete = defineShorthand({ method: "delete" });
-		this.deleteOnce = defineShorthand({
-			method: "delete",
-			repeat: 1
-		});
-		this.head = defineShorthand({ method: "head" });
-		this.headOnce = defineShorthand({
-			method: "head",
-			repeat: 1
-		});
-		this.patch = defineShorthand({ method: "patch" });
-		this.patchOnce = defineShorthand({
-			method: "patch",
-			repeat: 1
-		});
-		this.config = config;
-		this.router = new Router(this.config, {
-			routes: router ? [...router.routes] : [],
-			fallbackRoute: router ? router.fallbackRoute : null
-		});
-		this.callHistory = new CallHistory(this.config, this.router);
-		this.fetchHandler = this.fetchHandler.bind(this);
-		Object.assign(this.fetchHandler, { fetchMock: this });
-	}
-	createInstance() {
-		return new FetchMock({ ...this.config }, this.router);
-	}
-	async fetchHandler(requestInput, requestInit) {
-		let callLog;
-		if (requestInput instanceof this.config.Request) callLog = await createCallLogFromRequest(requestInput, requestInit);
-		else callLog = createCallLogFromUrlAndOptions(requestInput, requestInit);
-		this.callHistory.recordCall(callLog);
-		const responsePromise = this.router.execute(callLog);
-		callLog.pendingPromises.push(responsePromise);
-		return responsePromise;
-	}
-	route(matcher, response, options) {
-		this.router.addRoute(matcher, response, options);
-		return this;
-	}
-	catch(response) {
-		this.router.setFallback(response);
-		return this;
-	}
-	defineMatcher(matcher) {
-		Route.defineMatcher(matcher);
-	}
-	removeRoutes(options) {
-		this.router.removeRoutes(options);
-		return this;
-	}
-	removeRoute(routeName) {
-		this.router.removeRoutes({ names: [routeName] });
-		return this;
-	}
-	modifyRoute(routeName, options) {
-		this.router.modifyRoute(routeName, options);
-		return this;
-	}
-	clearHistory() {
-		this.callHistory.clear();
-		return this;
-	}
-	mockGlobal() {
-		globalThis.fetch = this.fetchHandler;
-		return this;
-	}
-	unmockGlobal() {
-		globalThis.fetch = this.config.fetch;
-		return this;
-	}
-	hardReset(options) {
-		this.clearHistory();
-		this.removeRoutes(options);
-		this.unmockGlobal();
-		return this;
-	}
-	spy(matcher, name) {
-		const boundFetch = this.config.fetch.bind(globalThis);
-		if (matcher) this.route(matcher, ({ args }) => boundFetch(...args), name);
-		else this.catch(({ args }) => boundFetch(...args));
-		return this;
-	}
-	spyGlobal() {
-		this.mockGlobal();
-		return this.spy();
-	}
-}({ ...defaultFetchMockConfig });
-//#endregion
 //#region src/docloader.test.ts
 (0, _fedify_fixture.test)("getRemoteDocument() forwards options to alternate documents", async () => {
 	const records = [];
@@ -1266,6 +57,24 @@ var esm_default = new class FetchMock {
 		await (0, _logtape_logtape.reset)();
 	}
 });
+const unpinnedPublicFetch = require_public_fetch.createPublicFetch({
+	pinner: () => Promise.resolve(null),
+	lookup: () => Promise.reject(/* @__PURE__ */ new Error("Unexpected default lookup"))
+});
+const PUBLIC_ADDRESS = {
+	address: "93.184.215.14",
+	family: 4
+};
+const PRIVATE_ADDRESS = {
+	address: "10.0.0.1",
+	family: 4
+};
+function lookupTestAddresses(hostname) {
+	return Promise.resolve([hostname === "private.example" ? PRIVATE_ADDRESS : PUBLIC_ADDRESS]);
+}
+function openUnpinnedHop(url) {
+	return unpinnedPublicFetch.openPublicFetch(url, { lookup: lookupTestAddresses });
+}
 (0, _fedify_fixture.test)("new FetchError()", () => {
 	const e = new require_request.FetchError("https://example.com/", "An error message.");
 	(0, node_assert.deepStrictEqual)(e.name, "FetchError");
@@ -1280,9 +89,9 @@ var esm_default = new class FetchMock {
 	(0, node_assert.deepStrictEqual)(e2.response.status, 410);
 });
 (0, _fedify_fixture.test)("getDocumentLoader()", async (t) => {
-	const fetchDocumentLoader = require_docloader.getDocumentLoader();
-	esm_default.spyGlobal();
-	esm_default.get("https://example.com/object", { body: {
+	const fetchDocumentLoader = require_docloader.createDocumentLoader({}, { openHop: openUnpinnedHop });
+	require_esm.esm_default.spyGlobal();
+	require_esm.esm_default.get("https://example.com/object", { body: {
 		"@context": "https://www.w3.org/ns/activitystreams",
 		id: "https://example.com/object",
 		name: "Fetched object",
@@ -1300,7 +109,7 @@ var esm_default = new class FetchMock {
 			}
 		});
 	});
-	esm_default.get("https://example.com/link-ctx", {
+	require_esm.esm_default.get("https://example.com/link-ctx", {
 		body: {
 			id: "https://example.com/link-ctx",
 			name: "Fetched object",
@@ -1311,15 +120,15 @@ var esm_default = new class FetchMock {
 			Link: "<https://www.w3.org/ns/activitystreams>; rel=\"http://www.w3.org/ns/json-ld#context\"; type=\"application/ld+json\""
 		}
 	});
-	esm_default.get("https://example.com/link-obj", { headers: {
+	require_esm.esm_default.get("https://example.com/link-obj", { headers: {
 		"Content-Type": "text/html; charset=utf-8",
 		Link: "<https://example.com/object>; rel=\"alternate\"; type=\"application/activity+json\""
 	} });
-	esm_default.get("https://example.com/link-obj-relative", { headers: {
+	require_esm.esm_default.get("https://example.com/link-obj-relative", { headers: {
 		"Content-Type": "text/html; charset=utf-8",
 		Link: "</object>; rel=\"alternate\"; type=\"application/activity+json\""
 	} });
-	esm_default.get("https://example.com/obj-w-wrong-link", {
+	require_esm.esm_default.get("https://example.com/obj-w-wrong-link", {
 		body: {
 			"@context": "https://www.w3.org/ns/activitystreams",
 			id: "https://example.com/obj-w-wrong-link",
@@ -1385,7 +194,7 @@ var esm_default = new class FetchMock {
 			}
 		});
 	});
-	esm_default.get("https://example.com/html-link", {
+	require_esm.esm_default.get("https://example.com/html-link", {
 		body: `<html>
         <head>
           <meta charset=utf-8>
@@ -1409,7 +218,7 @@ var esm_default = new class FetchMock {
 			}
 		});
 	});
-	esm_default.get("https://example.com/xhtml-link", {
+	require_esm.esm_default.get("https://example.com/xhtml-link", {
 		body: `<html>
         <head>
           <meta charset="utf-8" />
@@ -1433,7 +242,7 @@ var esm_default = new class FetchMock {
 			}
 		});
 	});
-	esm_default.get("https://example.com/html-a", {
+	require_esm.esm_default.get("https://example.com/html-a", {
 		body: `<html>
         <head>
           <meta charset=utf-8>
@@ -1459,7 +268,7 @@ var esm_default = new class FetchMock {
 			}
 		});
 	});
-	esm_default.get("https://example.com/html-no-alternate", {
+	require_esm.esm_default.get("https://example.com/html-no-alternate", {
 		body: `<!DOCTYPE html>
       <html>
         <head>
@@ -1480,7 +289,7 @@ var esm_default = new class FetchMock {
 			return true;
 		});
 	});
-	esm_default.get("https://example.com/wrong-content-type", {
+	require_esm.esm_default.get("https://example.com/wrong-content-type", {
 		body: {
 			"@context": "https://www.w3.org/ns/activitystreams",
 			id: "https://example.com/wrong-content-type",
@@ -1501,7 +310,7 @@ var esm_default = new class FetchMock {
 			}
 		});
 	});
-	esm_default.get("https://example.com/large-html", {
+	require_esm.esm_default.get("https://example.com/large-html", {
 		body: "<!DOCTYPE html>",
 		headers: {
 			"Content-Length": String(1048577),
@@ -1532,7 +341,7 @@ var esm_default = new class FetchMock {
 		}), require_request.FetchError);
 		(0, node_assert.deepStrictEqual)(canceled, true);
 	});
-	esm_default.get("https://example.com/404", { status: 404 });
+	require_esm.esm_default.get("https://example.com/404", { status: 404 });
 	await t.step("not ok", async () => {
 		await (0, node_assert.rejects)(() => fetchDocumentLoader("https://example.com/404"), require_request.FetchError, "HTTP 404: https://example.com/404");
 	});
@@ -1558,7 +367,7 @@ var esm_default = new class FetchMock {
 		}]);
 		(0, node_assert.deepStrictEqual)((await require_jsonld.jsonld_default.compact(expanded, context, { documentLoader: fetchDocumentLoader })).attributionDomains, ["blog.example"]);
 	});
-	esm_default.get("https://www.w3.org/ns/cid/v1", { status: 503 });
+	require_esm.esm_default.get("https://www.w3.org/ns/cid/v1", { status: 503 });
 	await t.step("preloaded CID v1 context", async () => {
 		const url = "https://www.w3.org/ns/cid/v1";
 		(0, node_assert.deepStrictEqual)(await fetchDocumentLoader(url), {
@@ -1583,7 +392,7 @@ var esm_default = new class FetchMock {
 			} }
 		});
 	});
-	esm_default.get("https://w3id.org/fep/7aa9", { status: 502 });
+	require_esm.esm_default.get("https://w3id.org/fep/7aa9", { status: 502 });
 	await t.step("preloaded FEP-7aa9 context", async () => {
 		const url = "https://w3id.org/fep/7aa9";
 		(0, node_assert.deepStrictEqual)(await fetchDocumentLoader(url), {
@@ -1612,9 +421,9 @@ var esm_default = new class FetchMock {
 				}
 			} }
 		});
-		(0, node_assert.deepStrictEqual)(esm_default.callHistory.calls(url).length, 0);
+		(0, node_assert.deepStrictEqual)(require_esm.esm_default.callHistory.calls(url).length, 0);
 	});
-	esm_default.get("https://w3id.org/fep/6757", { status: 502 });
+	require_esm.esm_default.get("https://w3id.org/fep/6757", { status: 502 });
 	await t.step("preloaded FEP-6757 context", async () => {
 		const url = "https://w3id.org/fep/6757";
 		(0, node_assert.deepStrictEqual)(await fetchDocumentLoader(url), {
@@ -1641,9 +450,9 @@ var esm_default = new class FetchMock {
 			"http://purl.org/dc/terms/license": [{ "@id": "https://creativecommons.org/licenses/by/4.0/" }],
 			"https://w3id.org/fep/6757#preferredLicense": [{ "@id": "https://creativecommons.org/licenses/by-nc/4.0/" }]
 		}]);
-		(0, node_assert.deepStrictEqual)(esm_default.callHistory.calls(url).length, 0);
+		(0, node_assert.deepStrictEqual)(require_esm.esm_default.callHistory.calls(url).length, 0);
 	});
-	esm_default.get("https://w3id.org/fep/22cd", { status: 502 });
+	require_esm.esm_default.get("https://w3id.org/fep/22cd", { status: 502 });
 	await t.step("preloaded FEP-22cd context", async () => {
 		const url = "https://w3id.org/fep/22cd";
 		const articleId = "https://example.com/articles/1";
@@ -1719,17 +528,17 @@ var esm_default = new class FetchMock {
 				"https://schema.org/isBasedOn": [{ "@id": revisionId }]
 			}]
 		}]);
-		(0, node_assert.deepStrictEqual)(esm_default.callHistory.calls(url).length, 0);
-		(0, node_assert.deepStrictEqual)(esm_default.callHistory.calls("https://www.w3.org/ns/activitystreams").length, 0);
+		(0, node_assert.deepStrictEqual)(require_esm.esm_default.callHistory.calls(url).length, 0);
+		(0, node_assert.deepStrictEqual)(require_esm.esm_default.callHistory.calls("https://www.w3.org/ns/activitystreams").length, 0);
 	});
 	await t.step("deny non-HTTP/HTTPS", async () => {
 		await (0, node_assert.rejects)(() => fetchDocumentLoader("ftp://localhost"), require_url.UrlError);
 	});
-	esm_default.get("https://example.com/localhost-redirect", {
+	require_esm.esm_default.get("https://example.com/localhost-redirect", {
 		status: 302,
 		headers: { Location: "https://localhost/object" }
 	});
-	esm_default.get("https://example.com/localhost-link", {
+	require_esm.esm_default.get("https://example.com/localhost-link", {
 		body: `<html>
         <head>
           <meta charset=utf-8>
@@ -1741,16 +550,32 @@ var esm_default = new class FetchMock {
       </html>`,
 		headers: { "Content-Type": "text/html; charset=utf-8" }
 	});
-	esm_default.get("https://localhost/object", { body: {
+	require_esm.esm_default.get("https://localhost/object", { body: {
 		"@context": "https://www.w3.org/ns/activitystreams",
 		id: "https://localhost/object",
 		name: "Fetched object",
 		type: "Object"
 	} });
+	require_esm.esm_default.get("https://example.com/private-redirect", {
+		status: 302,
+		headers: { Location: "https://private.example/object" }
+	});
+	require_esm.esm_default.get("https://private.example/object", { body: {
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: "https://private.example/object",
+		type: "Object"
+	} });
 	await t.step("allowPrivateAddress: false", async () => {
 		await (0, node_assert.rejects)(() => fetchDocumentLoader("https://localhost/object"), require_url.UrlError);
 		await (0, node_assert.rejects)(() => fetchDocumentLoader("https://example.com/localhost-redirect"), require_url.UrlError);
 		await (0, node_assert.rejects)(() => fetchDocumentLoader("https://example.com/localhost-link"), require_url.UrlError);
+		await (0, node_assert.rejects)(() => fetchDocumentLoader("https://private.example/object"), require_url.UrlError);
+		await (0, node_assert.rejects)(() => fetchDocumentLoader("https://example.com/private-redirect"), require_url.UrlError);
+		(0, node_assert.deepStrictEqual)(require_esm.esm_default.callHistory.calls("https://private.example/object").length, 0);
+		const defaultLoader = require_docloader.getDocumentLoader();
+		await (0, node_assert.rejects)(() => defaultLoader("https://localhost/object"), require_url.UrlError);
+		await (0, node_assert.rejects)(() => defaultLoader("https://127.0.0.1/object"), require_url.UrlError);
+		(0, node_assert.deepStrictEqual)(require_esm.esm_default.callHistory.calls("https://localhost/object").length, 0);
 	});
 	const fetchDocumentLoader2 = require_docloader.getDocumentLoader({ allowPrivateAddress: true });
 	await t.step("allowPrivateAddress: true", async () => {
@@ -1769,7 +594,7 @@ var esm_default = new class FetchMock {
 		(0, node_assert.deepStrictEqual)(await fetchDocumentLoader2("https://example.com/localhost-link"), expected);
 	});
 	let redirectAttempts = 0;
-	esm_default.get("begin:https://example.com/too-many-redirects/", (cl) => {
+	require_esm.esm_default.get("begin:https://example.com/too-many-redirects/", (cl) => {
 		redirectAttempts++;
 		return {
 			status: 302,
@@ -1783,19 +608,19 @@ var esm_default = new class FetchMock {
 	});
 	await t.step("custom max redirection", async () => {
 		redirectAttempts = 0;
-		const loader = require_docloader.getDocumentLoader({ maxRedirection: 1 });
+		const loader = require_docloader.createDocumentLoader({ maxRedirection: 1 }, { openHop: openUnpinnedHop });
 		await (0, node_assert.rejects)(() => loader("https://example.com/too-many-redirects/0"), require_request.FetchError, "Too many redirections");
 		(0, node_assert.deepStrictEqual)(redirectAttempts, 2);
 	});
 	let loopAttempts = 0;
-	esm_default.get("https://example.com/redirect-loop-a", () => {
+	require_esm.esm_default.get("https://example.com/redirect-loop-a", () => {
 		loopAttempts++;
 		return {
 			status: 302,
 			headers: { Location: "https://example.com/redirect-loop-b" }
 		};
 	});
-	esm_default.get("https://example.com/redirect-loop-b", () => {
+	require_esm.esm_default.get("https://example.com/redirect-loop-b", () => {
 		loopAttempts++;
 		return {
 			status: 302,
@@ -1808,7 +633,7 @@ var esm_default = new class FetchMock {
 		(0, node_assert.deepStrictEqual)(loopAttempts, 2);
 	});
 	let relativeLoopAttempts = 0;
-	esm_default.get("https://example.com/redirect-loop-relative", () => {
+	require_esm.esm_default.get("https://example.com/redirect-loop-relative", () => {
 		relativeLoopAttempts++;
 		return {
 			status: 302,
@@ -1821,7 +646,7 @@ var esm_default = new class FetchMock {
 		(0, node_assert.deepStrictEqual)(relativeLoopAttempts, 1);
 	});
 	const maliciousPayload = "<a" + " a=\"b\"".repeat(30) + " ";
-	esm_default.get("https://example.com/redos", {
+	require_esm.esm_default.get("https://example.com/redos", {
 		body: maliciousPayload,
 		headers: { "Content-Type": "text/html; charset=utf-8" }
 	});
@@ -1831,14 +656,14 @@ var esm_default = new class FetchMock {
 		const elapsed = performance.now() - start;
 		(0, node_assert.ok)(elapsed < 1e3, `Potential ReDoS vulnerability detected: ${elapsed}ms (expected < 1000ms)`);
 	});
-	esm_default.hardReset();
+	require_esm.esm_default.hardReset();
 });
 (0, _fedify_fixture.test)("getDocumentLoader() bounds JSON, HTML, and alternate documents", async () => {
 	const url = "https://example.com/bounded";
-	esm_default.mockGlobal();
+	require_esm.esm_default.mockGlobal();
 	let oversized = true;
 	try {
-		esm_default.get(url, () => new Response("{\"name\":\"hello\"}", { headers: {
+		require_esm.esm_default.get(url, () => new Response("{\"name\":\"hello\"}", { headers: {
 			"Content-Type": "application/activity+json",
 			...oversized ? { "Content-Length": String(16777217) } : {}
 		} }));
@@ -1847,20 +672,20 @@ var esm_default = new class FetchMock {
 		oversized = false;
 		(0, node_assert.deepStrictEqual)((await loader(url)).document, { name: "hello" });
 		oversized = true;
-		esm_default.get(`${url}/html`, () => new Response(" ".repeat(1048577), { headers: { "Content-Type": "text/html" } }));
+		require_esm.esm_default.get(`${url}/html`, () => new Response(" ".repeat(1048577), { headers: { "Content-Type": "text/html" } }));
 		await (0, node_assert.rejects)(require_docloader.getDocumentLoader({ allowPrivateAddress: true })(`${url}/html`), require_request.FetchError);
-		esm_default.get(`${url}/alternate`, () => new Response("", { headers: {
+		require_esm.esm_default.get(`${url}/alternate`, () => new Response("", { headers: {
 			"Content-Type": "text/html",
 			Link: `<${url}>; rel="alternate"; type="application/activity+json"`
 		} }));
 		await (0, node_assert.rejects)(loader(`${url}/alternate`), require_request.FetchError);
-		esm_default.get(`${url}/redirect`, {
+		require_esm.esm_default.get(`${url}/redirect`, {
 			status: 302,
 			headers: { Location: url }
 		});
 		await (0, node_assert.rejects)(loader(`${url}/redirect`), require_request.FetchError);
 	} finally {
-		esm_default.hardReset();
+		require_esm.esm_default.hardReset();
 	}
 });
 (0, _fedify_fixture.test)("getDocumentLoader() rejects oversized gzip responses from fetch", async () => {
@@ -1911,18 +736,14 @@ var esm_default = new class FetchMock {
 	(0, node_assert.deepStrictEqual)(pulls, 257);
 });
 (0, _fedify_fixture.test)("getDocumentLoader() logs DNS failures as such", async (t) => {
-	if ("Deno" in globalThis && (await Deno.permissions.query({ name: "net" })).state !== "granted") throw new Error("This DNS test requires Deno network permission (--allow-net).");
-	const loader = require_docloader.getDocumentLoader();
 	for (const result of [
 		"throws",
 		"empty",
-		"private"
+		"private",
+		"default"
 	]) await t.step(result, async () => {
-		const originalLookup = node_dns_promises.default.lookup;
-		node_dns_promises.default.lookup = (() => result === "throws" ? Promise.reject(/* @__PURE__ */ new Error("Resolver unavailable")) : Promise.resolve(result === "empty" ? [] : [{
-			address: "127.0.0.1",
-			family: 4
-		}]));
+		const lookup = () => result === "throws" ? Promise.reject(/* @__PURE__ */ new Error("Resolver unavailable")) : Promise.resolve(result === "empty" ? [] : [PRIVATE_ADDRESS]);
+		const loader = result === "default" ? require_docloader.getDocumentLoader() : require_docloader.createDocumentLoader({}, { openHop: (url) => unpinnedPublicFetch.openPublicFetch(url, { lookup }) });
 		const records = [];
 		await (0, _logtape_logtape.configure)({
 			sinks: { buffer: (record) => records.push(record) },
@@ -1937,19 +758,20 @@ var esm_default = new class FetchMock {
 			reset: true
 		});
 		try {
-			const url = "https://dns-failure.invalid/object";
+			const url = result === "default" ? "https://10.0.0.1/object" : "https://dns-failure.invalid/object";
 			let error;
 			await (0, node_assert.rejects)(() => loader(url), (e) => {
 				error = e;
 				return true;
 			});
 			(0, node_assert.ok)(error instanceof require_url.UrlError);
-			(0, node_assert.deepStrictEqual)(error.reason, result === "private" ? "disallowed" : "dns");
+			const disallowed = result === "private" || result === "default";
+			(0, node_assert.deepStrictEqual)(error.reason, disallowed ? "disallowed" : "dns");
 			(0, node_assert.deepStrictEqual)(records.map((r) => [
 				r.level,
 				r.rawMessage,
 				r.properties.url
-			]), [result === "private" ? [
+			]), [disallowed ? [
 				"error",
 				"Disallowed private URL: {url}",
 				url
@@ -1961,7 +783,6 @@ var esm_default = new class FetchMock {
 			(0, node_assert.ok)(records[0].properties.error === error);
 		} finally {
 			await (0, _logtape_logtape.reset)();
-			node_dns_promises.default.lookup = originalLookup;
 		}
 	});
 });
@@ -1973,9 +794,9 @@ var esm_default = new class FetchMock {
 		"html",
 		"mixed"
 	]) for (const hops of [20, 21]) await t.step(`${mode}: ${hops} hops`, async () => {
-		esm_default.mockGlobal();
+		require_esm.esm_default.mockGlobal();
 		let requests = 0;
-		esm_default.get(`begin:${base}`, ({ url }) => {
+		require_esm.esm_default.get(`begin:${base}`, ({ url }) => {
 			requests++;
 			const index = Number(new URL(url).pathname.split("/").at(-1));
 			if (index === hops || requests > 30) return Response.json({ done: true });
@@ -1992,7 +813,7 @@ var esm_default = new class FetchMock {
 			});
 			(0, node_assert.deepStrictEqual)(requests, 21);
 		} finally {
-			esm_default.hardReset();
+			require_esm.esm_default.hardReset();
 		}
 	});
 	for (const mode of [
@@ -2002,9 +823,9 @@ var esm_default = new class FetchMock {
 		"redirect-alternate",
 		"redirect-intermediate"
 	]) await t.step(`${mode}: cycle`, async () => {
-		esm_default.mockGlobal();
+		require_esm.esm_default.mockGlobal();
 		let requests = 0;
-		esm_default.get(`begin:${base}`, ({ url }) => {
+		require_esm.esm_default.get(`begin:${base}`, ({ url }) => {
 			requests++;
 			if (requests > 30) return Response.json({ stopped: true });
 			const index = Number(new URL(url).pathname.split("/").at(-1));
@@ -2020,13 +841,13 @@ var esm_default = new class FetchMock {
 			});
 			(0, node_assert.deepStrictEqual)(requests, mode === "redirect-intermediate" ? 3 : 2);
 		} finally {
-			esm_default.hardReset();
+			require_esm.esm_default.hardReset();
 		}
 	});
 	await t.step("alternate followed by 20 redirects shares the limit", async () => {
-		esm_default.mockGlobal();
+		require_esm.esm_default.mockGlobal();
 		let requests = 0;
-		esm_default.get(`begin:${base}`, ({ url }) => {
+		require_esm.esm_default.get(`begin:${base}`, ({ url }) => {
 			requests++;
 			const index = Number(new URL(url).pathname.split("/").at(-1));
 			if (index === 21) return Response.json({ done: true });
@@ -2040,14 +861,14 @@ var esm_default = new class FetchMock {
 			});
 			(0, node_assert.deepStrictEqual)(requests, 21);
 		} finally {
-			esm_default.hardReset();
+			require_esm.esm_default.hardReset();
 		}
 	});
 	await t.step("relative alternate after redirect and isolated calls", async () => {
-		esm_default.mockGlobal();
-		esm_default.get(`${base}start`, Response.redirect(`${base}html`, 302));
-		esm_default.get(`${base}html`, alternate("./document", true));
-		esm_default.get(`${base}document`, Response.json({ done: true }));
+		require_esm.esm_default.mockGlobal();
+		require_esm.esm_default.get(`${base}start`, Response.redirect(`${base}html`, 302));
+		require_esm.esm_default.get(`${base}html`, alternate("./document", true));
+		require_esm.esm_default.get(`${base}document`, Response.json({ done: true }));
 		try {
 			for (let i = 0; i < 2; i++) {
 				const results = await Promise.all([loader(`${base}start`), loader(`${base}start`)]);
@@ -2057,7 +878,7 @@ var esm_default = new class FetchMock {
 				}
 			}
 		} finally {
-			esm_default.hardReset();
+			require_esm.esm_default.hardReset();
 		}
 	});
 	function alternate(next, html) {
@@ -2071,10 +892,10 @@ var esm_default = new class FetchMock {
 	const base = "https://example.com/alternate-abort/";
 	const loader = require_docloader.getDocumentLoader({ allowPrivateAddress: true });
 	for (const html of [false, true]) await t.step(html ? "HTML" : "Link header", async () => {
-		esm_default.mockGlobal();
+		require_esm.esm_default.mockGlobal();
 		const controller = new AbortController();
 		let requests = 0;
-		esm_default.get(`begin:${base}`, ({ url }) => {
+		require_esm.esm_default.get(`begin:${base}`, ({ url }) => {
 			requests++;
 			const index = Number(new URL(url).pathname.split("/").at(-1));
 			if (index === 2) return Response.json({ done: true });
@@ -2089,15 +910,15 @@ var esm_default = new class FetchMock {
 			await (0, node_assert.rejects)(loader(`${base}0`, { signal: controller.signal }), { name: "AbortError" });
 			(0, node_assert.deepStrictEqual)(requests, 2);
 		} finally {
-			esm_default.hardReset();
+			require_esm.esm_default.hardReset();
 		}
 	});
 });
 (0, _fedify_fixture.test)("getDocumentLoader() rejects cancellation before fetching", async () => {
-	esm_default.mockGlobal();
+	require_esm.esm_default.mockGlobal();
 	let requests = 0;
 	const url = "https://example.com/pre-aborted-alternate";
-	esm_default.get(url, () => {
+	require_esm.esm_default.get(url, () => {
 		requests++;
 		return Response.json({ done: true });
 	});
@@ -2108,7 +929,7 @@ var esm_default = new class FetchMock {
 		await (0, node_assert.rejects)(loader(url, { signal: controller.signal }), { name: "AbortError" });
 		(0, node_assert.deepStrictEqual)(requests, 0);
 	} finally {
-		esm_default.hardReset();
+		require_esm.esm_default.hardReset();
 	}
 });
 async function withServer(handler, callback) {
@@ -2259,32 +1080,29 @@ function isTimeoutFetchError(error, url) {
 	});
 });
 (0, _fedify_fixture.test)("getDocumentLoader() bounds DNS lookups that ignore the timeout", async () => {
-	if ("Deno" in globalThis && (await Deno.permissions.query({ name: "net" })).state !== "granted") throw new Error("This DNS test requires Deno network permission (--allow-net).");
-	esm_default.mockGlobal();
+	require_esm.esm_default.mockGlobal();
 	let requests = 0;
 	const url = "https://slow-dns.example/object";
-	esm_default.get(url, () => {
+	require_esm.esm_default.get(url, () => {
 		requests++;
 		return Response.json({ id: url });
 	});
-	const originalLookup = node_dns_promises.default.lookup;
 	let resolveLookup = () => {};
 	const lookedUp = new Promise((resolve) => resolveLookup = resolve);
-	node_dns_promises.default.lookup = (() => new Promise((resolve) => setTimeout(() => {
+	const lookup = () => new Promise((resolve) => setTimeout(() => {
 		resolve([{
 			address: "93.184.215.14",
 			family: 4
 		}]);
 		resolveLookup();
-	}, 200)));
+	}, 200));
 	try {
-		await (0, node_assert.rejects)(require_docloader.getDocumentLoader({ timeout: 50 })(url), (e) => isTimeoutFetchError(e, url));
+		await (0, node_assert.rejects)(require_docloader.createDocumentLoader({ timeout: 50 }, { openHop: (url) => unpinnedPublicFetch.openPublicFetch(url, { lookup }) })(url), (e) => isTimeoutFetchError(e, url));
 		await lookedUp;
 		await new Promise((resolve) => setTimeout(resolve, 10));
 		(0, node_assert.deepStrictEqual)(requests, 0);
 	} finally {
-		node_dns_promises.default.lookup = originalLookup;
-		esm_default.hardReset();
+		require_esm.esm_default.hardReset();
 	}
 });
 (0, _fedify_fixture.test)("withDocumentLoaderTimeout() cleans up after each call", async () => {
@@ -2465,4 +1283,424 @@ for (const url of unsupportedUrls) {
 		});
 	});
 }
+function createHopRecorder(responder) {
+	const events = [];
+	const states = /* @__PURE__ */ new Map();
+	const violations = [];
+	let responses = 0;
+	let opens = 0;
+	let closes = 0;
+	function respond(url) {
+		const n = ++responses;
+		events.push(`fetch ${url} #${n}`);
+		const { status = 200, headers, body = "", failCancel, hangCancel, responseUrl } = responder(url);
+		const state = {
+			n,
+			settled: false
+		};
+		let sent = false;
+		const stream = new ReadableStream({
+			pull(controller) {
+				if (!sent && body !== "") {
+					sent = true;
+					controller.enqueue(new TextEncoder().encode(body));
+					return;
+				}
+				controller.close();
+				state.settled = true;
+				events.push(`consumed #${n}`);
+			},
+			cancel() {
+				state.settled = true;
+				events.push(`cancel #${n}`);
+				if (failCancel) throw new Error(`Failed to cancel #${n}`);
+				if (hangCancel) return new Promise(() => {});
+			}
+		}, { highWaterMark: 0 });
+		const response = new Response(stream, {
+			status,
+			headers
+		});
+		if (responseUrl != null) Object.defineProperty(response, "url", { value: responseUrl });
+		states.set(response, state);
+		return response;
+	}
+	function record(url, session) {
+		opens++;
+		events.push(`open ${url}`);
+		const fetched = [];
+		let closed = false;
+		return {
+			get url() {
+				return session.url;
+			},
+			async fetch(input, init) {
+				const response = await session.fetch(input, init);
+				fetched.push(response);
+				return response;
+			},
+			async close() {
+				if (closed) return;
+				closed = true;
+				for (const response of fetched) {
+					const state = states.get(response);
+					if (state != null && !state.settled) violations.push(`#${state.n} is still open when closing ${url}`);
+				}
+				closes++;
+				events.push(`close ${url}`);
+				await session.close();
+			}
+		};
+	}
+	function openHop(url) {
+		const origin = new URL(url).origin;
+		return Promise.resolve(record(url, {
+			url: new URL(url),
+			fetch(input) {
+				const target = input instanceof Request ? input.url : String(input);
+				(0, node_assert.ok)(new URL(target).origin === origin, `${target} is not on ${origin}`);
+				return Promise.resolve(respond(target));
+			},
+			close: () => Promise.resolve()
+		}));
+	}
+	return {
+		events,
+		respond,
+		record,
+		openHop,
+		assertInvariants() {
+			(0, node_assert.deepStrictEqual)(violations, []);
+			(0, node_assert.deepStrictEqual)(opens, closes);
+		}
+	};
+}
+const lifecycleDocument = {
+	"@context": "https://www.w3.org/ns/activitystreams",
+	id: "https://b.example/object",
+	type: "Object"
+};
+(0, _fedify_fixture.test)("getDocumentLoader() closes a redirect hop before the next hop", async () => {
+	const recorder = createHopRecorder((url) => url === "https://a.example/start" ? {
+		status: 302,
+		headers: { Location: "https://b.example/object" }
+	} : { body: JSON.stringify(lifecycleDocument) });
+	(0, node_assert.deepStrictEqual)(await require_docloader.createDocumentLoader({}, { openHop: recorder.openHop })("https://a.example/start"), {
+		contextUrl: null,
+		documentUrl: "https://b.example/object",
+		document: lifecycleDocument
+	});
+	(0, node_assert.deepStrictEqual)(recorder.events, [
+		"open https://a.example/start",
+		"fetch https://a.example/start #1",
+		"cancel #1",
+		"close https://a.example/start",
+		"open https://b.example/object",
+		"fetch https://b.example/object #2",
+		"consumed #2",
+		"close https://b.example/object"
+	]);
+	recorder.assertInvariants();
+});
+(0, _fedify_fixture.test)("getDocumentLoader() cancels the body before a Link header alternate", async () => {
+	const recorder = createHopRecorder((url) => url === "https://a.example/start" ? {
+		headers: {
+			"Content-Type": "text/plain",
+			Link: "<https://b.example/object>; rel=\"alternate\"; type=\"application/activity+json\""
+		},
+		body: "not JSON"
+	} : { body: JSON.stringify(lifecycleDocument) });
+	(0, node_assert.deepStrictEqual)((await require_docloader.createDocumentLoader({}, { openHop: recorder.openHop })("https://a.example/start")).documentUrl, "https://b.example/object");
+	(0, node_assert.deepStrictEqual)(recorder.events, [
+		"open https://a.example/start",
+		"fetch https://a.example/start #1",
+		"cancel #1",
+		"close https://a.example/start",
+		"open https://b.example/object",
+		"fetch https://b.example/object #2",
+		"consumed #2",
+		"close https://b.example/object"
+	]);
+	recorder.assertInvariants();
+});
+(0, _fedify_fixture.test)("getDocumentLoader() reads the body before an HTML alternate", async () => {
+	const recorder = createHopRecorder((url) => url === "https://a.example/start" ? {
+		headers: { "Content-Type": "text/html" },
+		body: "<link rel=\"alternate\" type=\"application/activity+json\" href=\"https://b.example/object\">"
+	} : { body: JSON.stringify(lifecycleDocument) });
+	(0, node_assert.deepStrictEqual)((await require_docloader.createDocumentLoader({}, { openHop: recorder.openHop })("https://a.example/start")).documentUrl, "https://b.example/object");
+	(0, node_assert.deepStrictEqual)(recorder.events, [
+		"open https://a.example/start",
+		"fetch https://a.example/start #1",
+		"consumed #1",
+		"close https://a.example/start",
+		"open https://b.example/object",
+		"fetch https://b.example/object #2",
+		"consumed #2",
+		"close https://b.example/object"
+	]);
+	recorder.assertInvariants();
+});
+/**
+* Fails instead of blocking the test if the given promise does not settle
+* within the given time.
+*/
+async function settlesWithin(promise, milliseconds = 1e3) {
+	let timer;
+	try {
+		return await Promise.race([promise, new Promise((_, reject) => {
+			timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Did not settle in ${milliseconds} ms.`)), milliseconds);
+		})]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/**
+* Runs the given function while capturing the document loader's logs, and
+* waits until the rejections of body cancellations started without being
+* awaited have been logged.
+*/
+async function captureDocumentLoaderLogs(fn) {
+	const records = [];
+	await (0, _logtape_logtape.configure)({
+		sinks: { buffer: (record) => records.push(record) },
+		loggers: [{
+			category: [
+				"fedify",
+				"runtime",
+				"docloader"
+			],
+			sinks: ["buffer"],
+			lowestLevel: "debug"
+		}, {
+			category: ["logtape", "meta"],
+			sinks: []
+		}],
+		reset: true
+	});
+	try {
+		const result = await fn();
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		return {
+			result,
+			records
+		};
+	} finally {
+		await (0, _logtape_logtape.reset)();
+	}
+}
+function cancelFailureLogs(records) {
+	return records.filter((record) => record.rawMessage === "Failed to cancel the response body from {url}: {error}").map((record) => [
+		record.level,
+		record.properties.url,
+		String(record.properties.error)
+	]);
+}
+function linkHeaderAlternate(next) {
+	return {
+		headers: {
+			"Content-Type": "text/plain",
+			Link: `<${next}>; rel="alternate"; type="application/activity+json"`
+		},
+		body: "not JSON"
+	};
+}
+(0, _fedify_fixture.test)("getDocumentLoader() continues if an intermediate body fails to cancel", async (t) => {
+	for (const kind of ["redirect", "Link header alternate"]) await t.step(kind, async () => {
+		const recorder = createHopRecorder((url) => url === "https://a.example/start" ? {
+			...kind === "redirect" ? {
+				status: 302,
+				headers: { Location: "https://b.example/object" }
+			} : linkHeaderAlternate("https://b.example/object"),
+			failCancel: true
+		} : { body: JSON.stringify(lifecycleDocument) });
+		const loader = require_docloader.createDocumentLoader({}, { openHop: recorder.openHop });
+		const { result, records } = await captureDocumentLoaderLogs(() => loader("https://a.example/start"));
+		(0, node_assert.deepStrictEqual)(result, {
+			contextUrl: null,
+			documentUrl: "https://b.example/object",
+			document: lifecycleDocument
+		});
+		(0, node_assert.deepStrictEqual)(recorder.events, [
+			"open https://a.example/start",
+			"fetch https://a.example/start #1",
+			"cancel #1",
+			"close https://a.example/start",
+			"open https://b.example/object",
+			"fetch https://b.example/object #2",
+			"consumed #2",
+			"close https://b.example/object"
+		]);
+		recorder.assertInvariants();
+		(0, node_assert.deepStrictEqual)(cancelFailureLogs(records), [[
+			"debug",
+			"https://a.example/start",
+			"Error: Failed to cancel #1"
+		]]);
+	});
+});
+(0, _fedify_fixture.test)("getDocumentLoader() does not wait for intermediate bodies to be cancelled", async (t) => {
+	for (const kind of ["redirect", "Link header alternate"]) await t.step(kind, async () => {
+		const recorder = createHopRecorder((url) => url === "https://a.example/start" ? {
+			...kind === "redirect" ? {
+				status: 302,
+				headers: { Location: "https://b.example/object" }
+			} : linkHeaderAlternate("https://b.example/object"),
+			hangCancel: true
+		} : { body: JSON.stringify(lifecycleDocument) });
+		(0, node_assert.deepStrictEqual)((await settlesWithin(require_docloader.createDocumentLoader({}, { openHop: recorder.openHop })("https://a.example/start"))).documentUrl, "https://b.example/object");
+		(0, node_assert.deepStrictEqual)(recorder.events, [
+			"open https://a.example/start",
+			"fetch https://a.example/start #1",
+			"cancel #1",
+			"close https://a.example/start",
+			"open https://b.example/object",
+			"fetch https://b.example/object #2",
+			"consumed #2",
+			"close https://b.example/object"
+		]);
+		recorder.assertInvariants();
+	});
+	await t.step("public session with a never-settling cancel", async () => {
+		let cancelled = 0;
+		const pinner = {
+			supports: () => true,
+			fetch: () => Promise.resolve(new Response(new ReadableStream({ cancel() {
+				cancelled++;
+				return new Promise(() => {});
+			} }), {
+				status: 302,
+				headers: { Location: "file:///private-document" }
+			})),
+			release() {}
+		};
+		const publicFetch = require_public_fetch.createPublicFetch({
+			pinner: () => Promise.resolve(pinner),
+			lookup: () => Promise.reject(/* @__PURE__ */ new Error("Unexpected default lookup"))
+		});
+		await settlesWithin((0, node_assert.rejects)(require_docloader.createDocumentLoader({}, { openHop: (url) => publicFetch.openPublicFetch(url, { lookup: lookupTestAddresses }) })("https://a.example/redirect"), require_url.UrlError));
+		(0, node_assert.deepStrictEqual)(cancelled, 1);
+	});
+});
+(0, _fedify_fixture.test)("getDocumentLoader() completes with tee'd fetch-mock responses", async (t) => {
+	const url = "https://example.com/teed";
+	function stream(text) {
+		return new ReadableStream({ start(controller) {
+			controller.enqueue(new TextEncoder().encode(text));
+			controller.close();
+		} });
+	}
+	const loaders = {
+		unpinned: require_docloader.createDocumentLoader({}, { openHop: openUnpinnedHop }),
+		"private addresses allowed": require_docloader.getDocumentLoader({ allowPrivateAddress: true })
+	};
+	for (const [name, loader] of Object.entries(loaders)) for (const body of ["string", "stream"]) await t.step(`${name}: ${body} bodies`, async () => {
+		const make = (text) => body === "string" ? text : stream(text);
+		require_esm.esm_default.mockGlobal();
+		try {
+			require_esm.esm_default.get(`${url}/object`, () => new Response(make(JSON.stringify(lifecycleDocument)), { headers: { "Content-Type": "application/activity+json" } }));
+			require_esm.esm_default.get(`${url}/redirect`, () => new Response(make("redirect"), {
+				status: 302,
+				headers: { Location: `${url}/object` }
+			}));
+			require_esm.esm_default.get(`${url}/alternate`, () => new Response(make("not JSON"), { headers: {
+				"Content-Type": "text/plain",
+				Link: `<${url}/object>; rel="alternate"; type="application/activity+json"`
+			} }));
+			require_esm.esm_default.get(`${url}/missing`, () => new Response(make("not found"), { status: 404 }));
+			for (const path of ["redirect", "alternate"]) (0, node_assert.deepStrictEqual)((await settlesWithin(loader(`${url}/${path}`))).document, lifecycleDocument);
+			await settlesWithin((0, node_assert.rejects)(loader(`${url}/missing`), require_request.FetchError));
+			(0, node_assert.deepStrictEqual)(require_esm.esm_default.callHistory.calls().map((call) => call.url), [
+				`${url}/redirect`,
+				`${url}/object`,
+				`${url}/alternate`,
+				`${url}/object`,
+				`${url}/missing`
+			]);
+		} finally {
+			require_esm.esm_default.hardReset();
+		}
+	});
+});
+(0, _fedify_fixture.test)("getDocumentLoader() resolves each hop once", async () => {
+	const lookups = [];
+	const recorder = createHopRecorder((url) => {
+		const responseUrl = `https://${PUBLIC_ADDRESS.address}${new URL(url).pathname}`;
+		if (url === "https://a.example/start") return {
+			status: 302,
+			headers: { Location: "https://b.example/next" },
+			responseUrl
+		};
+		else if (url === "https://b.example/next") return {
+			status: 301,
+			headers: { Location: "/object" },
+			responseUrl
+		};
+		return {
+			body: JSON.stringify(lifecycleDocument),
+			responseUrl
+		};
+	});
+	const pinner = {
+		supports: () => true,
+		fetch: (_grant, request) => Promise.resolve(recorder.respond(request.url)),
+		release() {}
+	};
+	const publicFetch = require_public_fetch.createPublicFetch({
+		pinner: () => Promise.resolve(pinner),
+		lookup: () => Promise.reject(/* @__PURE__ */ new Error("Unexpected default lookup"))
+	});
+	(0, node_assert.deepStrictEqual)(await require_docloader.createDocumentLoader({}, { openHop: async (url) => recorder.record(url, await publicFetch.openPublicFetch(url, { lookup(hostname) {
+		lookups.push(hostname);
+		return Promise.resolve([PUBLIC_ADDRESS]);
+	} })) })("https://a.example/start"), {
+		contextUrl: null,
+		documentUrl: "https://b.example/object",
+		document: lifecycleDocument
+	});
+	(0, node_assert.deepStrictEqual)(lookups, [
+		"a.example",
+		"b.example",
+		"b.example"
+	]);
+	(0, node_assert.deepStrictEqual)(recorder.events, [
+		"open https://a.example/start",
+		"fetch https://a.example/start #1",
+		"cancel #1",
+		"close https://a.example/start",
+		"open https://b.example/next",
+		"fetch https://b.example/next #2",
+		"cancel #2",
+		"close https://b.example/next",
+		"open https://b.example/object",
+		"fetch https://b.example/object #3",
+		"consumed #3",
+		"close https://b.example/object"
+	]);
+	recorder.assertInvariants();
+});
+(0, _fedify_fixture.test)("getRemoteDocument() cancels the body before loading a Link header alternate", async () => {
+	const recorder = createHopRecorder(() => ({
+		headers: {
+			"Content-Type": "text/html",
+			Link: "<https://b.example/object>; rel=\"alternate\"; type=\"application/activity+json\""
+		},
+		body: "<html></html>"
+	}));
+	const response = recorder.respond("https://a.example/start");
+	const placeholder = {
+		contextUrl: null,
+		document: {},
+		documentUrl: "https://b.example/object"
+	};
+	const alternates = [];
+	(0, node_assert.ok)(await require_docloader.getRemoteDocument("https://a.example/start", response, (url) => {
+		alternates.push(url);
+		(0, node_assert.deepStrictEqual)(recorder.events.at(-1), "cancel #1");
+		(0, node_assert.ok)(response.bodyUsed);
+		return Promise.resolve(placeholder);
+	}) === placeholder);
+	(0, node_assert.deepStrictEqual)(alternates, ["https://b.example/object"]);
+	(0, node_assert.deepStrictEqual)(recorder.events, ["fetch https://a.example/start #1", "cancel #1"]);
+});
 //#endregion