@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/CallHistory.js

@@ -0,0 +1,94 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { createCallLogFromUrlAndOptions } from "./RequestUtils.js";
+import { 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/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.isFallback);
+			else if ([false, "unmatched"].includes(filter)) calls = calls.filter(({ route }) => Boolean(route.config.isFallback));
+			if (!options) return calls;
+		} else if (isName(filter)) {
+			calls = calls.filter(({ route: { config: { name } } }) => name === filter);
+			if (!options) return calls;
+		} else if (isUrlMatcher(filter)) options = {
+			url: filter,
+			...options || {}
+		};
+		else options = {
+			...filter,
+			...options || {}
+		};
+		const { matcher } = new Route_default({
+			response: "ok",
+			...options
+		});
+		calls = calls.filter(({ url, options: options$1 }) => {
+			return matcher(createCallLogFromUrlAndOptions(url, options$1));
+		});
+		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);
+	}
+};
+var CallHistory_default = CallHistory;
+
+//#endregion
+export { CallHistory_default };

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

@@ -0,0 +1,143 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { createCallLogFromRequest, createCallLogFromUrlAndOptions } from "./RequestUtils.js";
+import { Route_default } from "./Route.js";
+import { Router$2 as Router } from "./Router.js";
+import { CallHistory_default } from "./CallHistory.js";
+
+//#region node_modules/.pnpm/fetch-mock@12.5.2/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));
+	};
+};
+var FetchMock = 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_default(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_default.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();
+	}
+};
+const fetchMock = new FetchMock({ ...defaultFetchMockConfig });
+var FetchMock_default = fetchMock;
+
+//#endregion
+export { FetchMock, FetchMock_default, defaultFetchMockConfig };

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

@@ -0,0 +1,103 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { TypeDescriptor } from "./TypeDescriptor.js";
+
+//#region node_modules/.pnpm/fetch-mock@12.5.2/node_modules/fetch-mock/dist/esm/IsSubsetOf.js
+const allowedTypes = 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];
+			const subsetValueType = TypeDescriptor.of(subsetValue);
+			switch (subsetValueType) {
+				case "array":
+				case "object":
+				case "function": {
+					if (visited.includes(subsetValue)) continue;
+					visited.push(subsetValue);
+					try {
+						const isInSuperset = isSubsetOf(subsetValue, supersetValue, visited);
+						if (!isInSuperset) 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 {
+				const isInSuperset = isSubsetOf.structural(subsetValue, supersetValue, visited);
+				if (!isInSuperset) return false;
+			} catch {
+				return false;
+			}
+		}
+	}
+	return true;
+};
+
+//#endregion
+export { isSubsetOf };

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

@@ -0,0 +1,195 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { __toESM } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_glob_to_regexp } from "../../../../../glob-to-regexp@0.4.1/node_modules/glob-to-regexp/index.js";
+import { parse$1 as parse } from "../../../../../regexparam@3.0.0/node_modules/regexparam/dist/index.js";
+import { isSubsetOf } from "./IsSubsetOf.js";
+import { dequal } from "../../../../../dequal@2.0.3/node_modules/dequal/dist/index.js";
+import { getPath, normalizeHeaders, normalizeUrl } from "./RequestUtils.js";
+
+//#region node_modules/.pnpm/fetch-mock@12.5.2/node_modules/fetch-mock/dist/esm/Matchers.js
+var import_glob_to_regexp = __toESM(require_glob_to_regexp(), 1);
+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;
+		};
+	}
+};
+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 } = {} }) => {
+		const actualMethod = method ? method.toLowerCase() : "get";
+		return expectedMethod === actualMethod;
+	};
+};
+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$1) => matchers.every((matcher) => matcher(route$1));
+	}
+};
+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
+export { builtInMatchers, isFunctionMatcher, isUrlMatcher };

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

@@ -0,0 +1,83 @@
+
+      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/RequestUtils.js
+const absoluteUrlRX = new RegExp("^[a-z]+://|^data:", "i");
+const protocolRelativeUrlRX = 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);
+	const callLog = {
+		args: [request, options],
+		url,
+		queryParams: new URLSearchParams(getQuery(url)),
+		options: Object.assign(derivedOptions, options || {}),
+		request,
+		signal: options && options.signal || request.signal,
+		pendingPromises
+	};
+	return callLog;
+}
+function getPath(url) {
+	const u = absoluteUrlRX.test(url) ? new URL(url) : new URL(url, "http://dummy");
+	return u.pathname;
+}
+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
+export { createCallLogFromRequest, createCallLogFromUrlAndOptions, getPath, hasCredentialsInUrl, normalizeHeaders, normalizeUrl };