@fedify/fedify 1.6.1-dev.869 → 1.6.1-dev.873

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/utils/stringify.js

@@ -1,217 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-      import { URLPattern } from "urlpattern-polyfill";
-    
-import { SMap, SString, SSymbol, safeFilter, safeGetTime, safeIndexOf, safeJoin, safeMap, safePush, safeToISOString, safeToString } from "./globals.js";
-
-//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/utils/stringify.js
-const safeArrayFrom = Array.from;
-const safeBufferIsBuffer = typeof Buffer !== "undefined" ? Buffer.isBuffer : void 0;
-const safeJsonStringify = JSON.stringify;
-const safeNumberIsNaN = Number.isNaN;
-const safeObjectKeys = Object.keys;
-const safeObjectGetOwnPropertySymbols = Object.getOwnPropertySymbols;
-const safeObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
-const safeObjectGetPrototypeOf = Object.getPrototypeOf;
-const safeNegativeInfinity = Number.NEGATIVE_INFINITY;
-const safePositiveInfinity = Number.POSITIVE_INFINITY;
-const toStringMethod = Symbol.for("fast-check/toStringMethod");
-function hasToStringMethod(instance) {
-	return instance !== null && (typeof instance === "object" || typeof instance === "function") && toStringMethod in instance && typeof instance[toStringMethod] === "function";
-}
-const asyncToStringMethod = Symbol.for("fast-check/asyncToStringMethod");
-function hasAsyncToStringMethod(instance) {
-	return instance !== null && (typeof instance === "object" || typeof instance === "function") && asyncToStringMethod in instance && typeof instance[asyncToStringMethod] === "function";
-}
-const findSymbolNameRegex = /^Symbol\((.*)\)$/;
-function getSymbolDescription(s) {
-	if (s.description !== void 0) return s.description;
-	const m = findSymbolNameRegex.exec(SString(s));
-	return m && m[1].length ? m[1] : null;
-}
-function stringifyNumber(numValue) {
-	switch (numValue) {
-		case 0: return 1 / numValue === safeNegativeInfinity ? "-0" : "0";
-		case safeNegativeInfinity: return "Number.NEGATIVE_INFINITY";
-		case safePositiveInfinity: return "Number.POSITIVE_INFINITY";
-		default: return numValue === numValue ? SString(numValue) : "Number.NaN";
-	}
-}
-function isSparseArray(arr) {
-	let previousNumberedIndex = -1;
-	for (const index in arr) {
-		const numberedIndex = Number(index);
-		if (numberedIndex !== previousNumberedIndex + 1) return true;
-		previousNumberedIndex = numberedIndex;
-	}
-	return previousNumberedIndex + 1 !== arr.length;
-}
-function stringifyInternal(value, previousValues, getAsyncContent) {
-	const currentValues = [...previousValues, value];
-	if (typeof value === "object") {
-		if (safeIndexOf(previousValues, value) !== -1) return "[cyclic]";
-	}
-	if (hasAsyncToStringMethod(value)) {
-		const content = getAsyncContent(value);
-		if (content.state === "fulfilled") return content.value;
-	}
-	if (hasToStringMethod(value)) try {
-		return value[toStringMethod]();
-	} catch (err) {}
-	switch (safeToString(value)) {
-		case "[object Array]": {
-			const arr = value;
-			if (arr.length >= 50 && isSparseArray(arr)) {
-				const assignments = [];
-				for (const index in arr) if (!safeNumberIsNaN(Number(index))) safePush(assignments, `${index}:${stringifyInternal(arr[index], currentValues, getAsyncContent)}`);
-				return assignments.length !== 0 ? `Object.assign(Array(${arr.length}),{${safeJoin(assignments, ",")}})` : `Array(${arr.length})`;
-			}
-			const stringifiedArray = safeJoin(safeMap(arr, (v) => stringifyInternal(v, currentValues, getAsyncContent)), ",");
-			return arr.length === 0 || arr.length - 1 in arr ? `[${stringifiedArray}]` : `[${stringifiedArray},]`;
-		}
-		case "[object BigInt]": return `${value}n`;
-		case "[object Boolean]": {
-			const unboxedToString = value == true ? "true" : "false";
-			return typeof value === "boolean" ? unboxedToString : `new Boolean(${unboxedToString})`;
-		}
-		case "[object Date]": {
-			const d = value;
-			return safeNumberIsNaN(safeGetTime(d)) ? `new Date(NaN)` : `new Date(${safeJsonStringify(safeToISOString(d))})`;
-		}
-		case "[object Map]": return `new Map(${stringifyInternal(Array.from(value), currentValues, getAsyncContent)})`;
-		case "[object Null]": return `null`;
-		case "[object Number]": return typeof value === "number" ? stringifyNumber(value) : `new Number(${stringifyNumber(Number(value))})`;
-		case "[object Object]": {
-			try {
-				const toStringAccessor = value.toString;
-				if (typeof toStringAccessor === "function" && toStringAccessor !== Object.prototype.toString) return value.toString();
-			} catch (err) {
-				return "[object Object]";
-			}
-			const mapper = (k) => `${k === "__proto__" ? "[\"__proto__\"]" : typeof k === "symbol" ? `[${stringifyInternal(k, currentValues, getAsyncContent)}]` : safeJsonStringify(k)}:${stringifyInternal(value[k], currentValues, getAsyncContent)}`;
-			const stringifiedProperties = [...safeMap(safeObjectKeys(value), mapper), ...safeMap(safeFilter(safeObjectGetOwnPropertySymbols(value), (s) => {
-				const descriptor = safeObjectGetOwnPropertyDescriptor(value, s);
-				return descriptor && descriptor.enumerable;
-			}), mapper)];
-			const rawRepr = "{" + safeJoin(stringifiedProperties, ",") + "}";
-			if (safeObjectGetPrototypeOf(value) === null) return rawRepr === "{}" ? "Object.create(null)" : `Object.assign(Object.create(null),${rawRepr})`;
-			return rawRepr;
-		}
-		case "[object Set]": return `new Set(${stringifyInternal(Array.from(value), currentValues, getAsyncContent)})`;
-		case "[object String]": return typeof value === "string" ? safeJsonStringify(value) : `new String(${safeJsonStringify(value)})`;
-		case "[object Symbol]": {
-			const s = value;
-			if (SSymbol.keyFor(s) !== void 0) return `Symbol.for(${safeJsonStringify(SSymbol.keyFor(s))})`;
-			const desc = getSymbolDescription(s);
-			if (desc === null) return "Symbol()";
-			const knownSymbol = desc.startsWith("Symbol.") && SSymbol[desc.substring(7)];
-			return s === knownSymbol ? desc : `Symbol(${safeJsonStringify(desc)})`;
-		}
-		case "[object Promise]": {
-			const promiseContent = getAsyncContent(value);
-			switch (promiseContent.state) {
-				case "fulfilled": return `Promise.resolve(${stringifyInternal(promiseContent.value, currentValues, getAsyncContent)})`;
-				case "rejected": return `Promise.reject(${stringifyInternal(promiseContent.value, currentValues, getAsyncContent)})`;
-				case "pending": return `new Promise(() => {/*pending*/})`;
-				case "unknown":
-				default: return `new Promise(() => {/*unknown*/})`;
-			}
-		}
-		case "[object Error]":
-			if (value instanceof Error) return `new Error(${stringifyInternal(value.message, currentValues, getAsyncContent)})`;
-			break;
-		case "[object Undefined]": return `undefined`;
-		case "[object Int8Array]":
-		case "[object Uint8Array]":
-		case "[object Uint8ClampedArray]":
-		case "[object Int16Array]":
-		case "[object Uint16Array]":
-		case "[object Int32Array]":
-		case "[object Uint32Array]":
-		case "[object Float32Array]":
-		case "[object Float64Array]":
-		case "[object BigInt64Array]":
-		case "[object BigUint64Array]": {
-			if (typeof safeBufferIsBuffer === "function" && safeBufferIsBuffer(value)) return `Buffer.from(${stringifyInternal(safeArrayFrom(value.values()), currentValues, getAsyncContent)})`;
-			const valuePrototype = safeObjectGetPrototypeOf(value);
-			const className = valuePrototype && valuePrototype.constructor && valuePrototype.constructor.name;
-			if (typeof className === "string") {
-				const typedArray = value;
-				const valuesFromTypedArr = typedArray.values();
-				return `${className}.from(${stringifyInternal(safeArrayFrom(valuesFromTypedArr), currentValues, getAsyncContent)})`;
-			}
-			break;
-		}
-	}
-	try {
-		return value.toString();
-	} catch (_a) {
-		return safeToString(value);
-	}
-}
-function stringify(value) {
-	return stringifyInternal(value, [], () => ({
-		state: "unknown",
-		value: void 0
-	}));
-}
-function possiblyAsyncStringify(value) {
-	const stillPendingMarker = SSymbol();
-	const pendingPromisesForCache = [];
-	const cache = new SMap();
-	function createDelay0() {
-		let handleId = null;
-		const cancel = () => {
-			if (handleId !== null) clearTimeout(handleId);
-		};
-		const delay = new Promise((resolve) => {
-			handleId = setTimeout(() => {
-				handleId = null;
-				resolve(stillPendingMarker);
-			}, 0);
-		});
-		return {
-			delay,
-			cancel
-		};
-	}
-	const unknownState = {
-		state: "unknown",
-		value: void 0
-	};
-	const getAsyncContent = function getAsyncContent$1(data) {
-		const cacheKey = data;
-		if (cache.has(cacheKey)) return cache.get(cacheKey);
-		const delay0 = createDelay0();
-		const p = asyncToStringMethod in data ? Promise.resolve().then(() => data[asyncToStringMethod]()) : data;
-		p.catch(() => {});
-		pendingPromisesForCache.push(Promise.race([p, delay0.delay]).then((successValue) => {
-			if (successValue === stillPendingMarker) cache.set(cacheKey, {
-				state: "pending",
-				value: void 0
-			});
-			else cache.set(cacheKey, {
-				state: "fulfilled",
-				value: successValue
-			});
-			delay0.cancel();
-		}, (errorValue) => {
-			cache.set(cacheKey, {
-				state: "rejected",
-				value: errorValue
-			});
-			delay0.cancel();
-		}));
-		cache.set(cacheKey, unknownState);
-		return unknownState;
-	};
-	function loop() {
-		const stringifiedValue = stringifyInternal(value, [], getAsyncContent);
-		if (pendingPromisesForCache.length === 0) return stringifiedValue;
-		return Promise.all(pendingPromisesForCache.splice(0)).then(loop);
-	}
-	return loop();
-}
-
-//#endregion
-export { asyncToStringMethod, hasAsyncToStringMethod, hasToStringMethod, possiblyAsyncStringify, stringify, toStringMethod };

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

@@ -1,94 +0,0 @@
-
-      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

@@ -1,143 +0,0 @@
-
-      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

@@ -1,103 +0,0 @@
-
-      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 };