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

package/dist/node_modules/.pnpm/@jsr_std__path@1.0.9/node_modules/@jsr/std__path/join.js

@@ -1,35 +1,4 @@
 
       import { Temporal } from "@js-temporal/polyfill";
       import { URLPattern } from "urlpattern-polyfill";
-    
-import { isWindows } from "./_os.js";
-import { join$1 as join } from "./posix/join.js";
-import { join$2 as join$1 } from "./windows/join.js";
-
-//#region node_modules/.pnpm/@jsr+std__path@1.0.9/node_modules/@jsr/std__path/join.js
-/**
-* Joins a sequence of paths, then normalizes the resulting path.
-*
-* @example Usage
-* ```ts
-* import { join } from "@std/path/join";
-* import { assertEquals } from "@std/assert";
-*
-* if (Deno.build.os === "windows") {
-*   assertEquals(join("C:\\foo", "bar", "baz\\quux", "garply", ".."), "C:\\foo\\bar\\baz\\quux");
-* } else {
-*   assertEquals(join("/foo", "bar", "baz/quux", "garply", ".."), "/foo/bar/baz/quux");
-* }
-* ```
-*
-* Note: If you are working with file URLs,
-* use the new version of `join` from `@std/path/unstable-join`.
-*
-* @param paths Paths to be joined and normalized.
-* @returns The joined and normalized path.
-*/ function join$2(...paths) {
-	return isWindows ? join$1(...paths) : join(...paths);
-}
-
-//#endregion
-export { join$2 as join };
+    

package/dist/node_modules/.pnpm/@jsr_std__path@1.0.9/node_modules/@jsr/std__path/mod.js

@@ -2,6 +2,4 @@
       import { Temporal } from "@js-temporal/polyfill";
       import { URLPattern } from "urlpattern-polyfill";
     
-import { dirname } from "./dirname.js";
 import { fromFileUrl } from "./from_file_url.js";
-import { join } from "./join.js";

package/dist/node_modules/.pnpm/@jsr_std__path@1.0.9/node_modules/@jsr/std__path/posix/_util.js

@@ -10,4 +10,4 @@ function isPosixPathSeparator(code) {
 }
 
 //#endregion
-export { isPosixPathSeparator as isPosixPathSeparator$1 };
+export { isPosixPathSeparator };

package/dist/node_modules/.pnpm/@jsr_std__path@1.0.9/node_modules/@jsr/std__path/posix/dirname.js

@@ -3,8 +3,8 @@
       import { URLPattern } from "urlpattern-polyfill";
     
 import { stripTrailingSeparators } from "../_common/strip_trailing_separators.js";
-import { isPosixPathSeparator$1 as isPosixPathSeparator } from "./_util.js";
-import { assertArg$1 as assertArg } from "../_common/dirname.js";
+import { isPosixPathSeparator } from "./_util.js";
+import { assertArg } from "../_common/dirname.js";
 
 //#region node_modules/.pnpm/@jsr+std__path@1.0.9/node_modules/@jsr/std__path/posix/dirname.js
 /**

package/dist/node_modules/.pnpm/@jsr_std__path@1.0.9/node_modules/@jsr/std__path/posix/from_file_url.js

@@ -2,7 +2,7 @@
       import { Temporal } from "@js-temporal/polyfill";
       import { URLPattern } from "urlpattern-polyfill";
     
-import { assertArg } from "../_common/from_file_url.js";
+import { assertArg$2 as assertArg } from "../_common/from_file_url.js";
 
 //#region node_modules/.pnpm/@jsr+std__path@1.0.9/node_modules/@jsr/std__path/posix/from_file_url.js
 /**

package/dist/node_modules/.pnpm/@jsr_std__path@1.0.9/node_modules/@jsr/std__path/posix/normalize.js

@@ -2,8 +2,8 @@
       import { Temporal } from "@js-temporal/polyfill";
       import { URLPattern } from "urlpattern-polyfill";
     
-import { isPosixPathSeparator$1 as isPosixPathSeparator } from "./_util.js";
-import { assertArg$2 as assertArg } from "../_common/normalize.js";
+import { isPosixPathSeparator } from "./_util.js";
+import { assertArg$1 as assertArg } from "../_common/normalize.js";
 import { normalizeString } from "../_common/normalize_string.js";
 
 //#region node_modules/.pnpm/@jsr+std__path@1.0.9/node_modules/@jsr/std__path/posix/normalize.js

package/dist/node_modules/.pnpm/@jsr_std__path@1.0.9/node_modules/@jsr/std__path/windows/from_file_url.js

@@ -2,7 +2,7 @@
       import { Temporal } from "@js-temporal/polyfill";
       import { URLPattern } from "urlpattern-polyfill";
     
-import { assertArg } from "../_common/from_file_url.js";
+import { assertArg$2 as assertArg } from "../_common/from_file_url.js";
 
 //#region node_modules/.pnpm/@jsr+std__path@1.0.9/node_modules/@jsr/std__path/windows/from_file_url.js
 /**

package/dist/node_modules/.pnpm/@jsr_std__url@1.0.0-rc.3/node_modules/@jsr/std__url/dirname.js

@@ -35,4 +35,4 @@ import { strip } from "./_strip.js";
 }
 
 //#endregion
-export { dirname$1 as dirname$3 };
+export { dirname$1 as dirname };

package/dist/node_modules/.pnpm/@jsr_std__url@1.0.0-rc.3/node_modules/@jsr/std__url/join.js

@@ -33,4 +33,4 @@ import { join$1 as join } from "../../../../@jsr_std__path@1.0.9/node_modules/@j
 }
 
 //#endregion
-export { join$1 as join$3 };
+export { join$1 as join };

package/dist/node_modules/.pnpm/dequal@2.0.3/node_modules/dequal/dist/index.js

@@ -0,0 +1,68 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#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
+export { dequal };

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 };