@fedify/fedify 1.6.0-dev.814 → 1.6.0

package/dist/node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_rejects.js

@@ -0,0 +1,42 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { AssertionError } from "./assertion_error.js";
+import { assertIsError } from "./assert_is_error.js";
+
+//#region node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert_rejects.js
+async function assertRejects(fn, errorClassOrMsg, msgIncludesOrMsg, msg) {
+	let ErrorClass = void 0;
+	let msgIncludes = void 0;
+	let err;
+	if (typeof errorClassOrMsg !== "string") {
+		if (errorClassOrMsg === void 0 || errorClassOrMsg.prototype instanceof Error || errorClassOrMsg.prototype === Error.prototype) {
+			ErrorClass = errorClassOrMsg;
+			msgIncludes = msgIncludesOrMsg;
+		}
+	} else msg = errorClassOrMsg;
+	let doesThrow = false;
+	let isPromiseReturned = false;
+	const msgSuffix = msg ? `: ${msg}` : ".";
+	try {
+		const possiblePromise = fn();
+		if (possiblePromise && typeof possiblePromise === "object" && typeof possiblePromise.then === "function") {
+			isPromiseReturned = true;
+			await possiblePromise;
+		} else throw Error();
+	} catch (error) {
+		if (!isPromiseReturned) throw new AssertionError(`Function throws when expected to reject${msgSuffix}`);
+		if (ErrorClass) {
+			if (!(error instanceof Error)) throw new AssertionError(`A non-Error object was rejected${msgSuffix}`);
+			assertIsError(error, ErrorClass, msgIncludes, msg);
+		}
+		err = error;
+		doesThrow = true;
+	}
+	if (!doesThrow) throw new AssertionError(`Expected function to reject${msgSuffix}`);
+	return err;
+}
+
+//#endregion
+export { assertRejects };

package/dist/node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_strict_equals.js

@@ -0,0 +1,53 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { AssertionError } from "./assertion_error.js";
+import { red } from "../../../../@jsr_std__internal@1.0.7/node_modules/@jsr/std__internal/styles.js";
+import { buildMessage } from "../../../../@jsr_std__internal@1.0.7/node_modules/@jsr/std__internal/build_message.js";
+import { diff } from "../../../../@jsr_std__internal@1.0.7/node_modules/@jsr/std__internal/diff.js";
+import { diffStr } from "../../../../@jsr_std__internal@1.0.7/node_modules/@jsr/std__internal/diff_str.js";
+import { format } from "../../../../@jsr_std__internal@1.0.7/node_modules/@jsr/std__internal/format.js";
+
+//#region node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert_strict_equals.js
+/**
+* Make an assertion that `actual` and `expected` are equal using
+* {@linkcode Object.is} for equality comparison. If not, then throw.
+*
+* @example Usage
+* ```ts no-eval
+* import { assertStrictEquals } from "@std/assert/assert-strict-equals";
+*
+* const a = {};
+* const b = a;
+* assertStrictEquals(a, b); // Doesn't throw
+*
+* const c = {};
+* const d = {};
+* assertStrictEquals(c, d); // Throws
+* ```
+*
+* @typeParam T The type of the expected value.
+* @param actual The actual value to compare.
+* @param expected The expected value to compare.
+* @param msg The optional message to display if the assertion fails.
+*/ function assertStrictEquals(actual, expected, msg) {
+	if (Object.is(actual, expected)) return;
+	const msgSuffix = msg ? `: ${msg}` : ".";
+	let message;
+	const actualString = format(actual);
+	const expectedString = format(expected);
+	if (actualString === expectedString) {
+		const withOffset = actualString.split("\n").map((l) => `    ${l}`).join("\n");
+		message = `Values have the same structure but are not reference-equal${msgSuffix}\n\n${red(withOffset)}\n`;
+	} else {
+		const stringDiff = typeof actual === "string" && typeof expected === "string";
+		const diffResult = stringDiff ? diffStr(actual, expected) : diff(actualString.split("\n"), expectedString.split("\n"));
+		const diffMsg = buildMessage(diffResult, { stringDiff }).join("\n");
+		message = `Values are not strictly equal${msgSuffix}\n${diffMsg}`;
+	}
+	throw new AssertionError(message);
+}
+
+//#endregion
+export { assertStrictEquals };

package/dist/node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_string_includes.js

@@ -0,0 +1,32 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { AssertionError } from "./assertion_error.js";
+
+//#region node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert_string_includes.js
+/**
+* Make an assertion that actual includes expected. If not
+* then throw.
+*
+* @example Usage
+* ```ts no-eval
+* import { assertStringIncludes } from "@std/assert/assert-string-includes";
+*
+* assertStringIncludes("Hello", "ello"); // Doesn't throw
+* assertStringIncludes("Hello", "world"); // Throws
+* ```
+*
+* @param actual The actual string to check for inclusion.
+* @param expected The expected string to check for inclusion.
+* @param msg The optional message to display if the assertion fails.
+*/ function assertStringIncludes(actual, expected, msg) {
+	if (!actual.includes(expected)) {
+		const msgSuffix = msg ? `: ${msg}` : ".";
+		msg = `Expected actual: "${actual}" to contain: "${expected}"${msgSuffix}`;
+		throw new AssertionError(msg);
+	}
+}
+
+//#endregion
+export { assertStringIncludes };

package/dist/node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_throws.js

@@ -0,0 +1,38 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { AssertionError } from "./assertion_error.js";
+import { assertIsError } from "./assert_is_error.js";
+
+//#region node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert_throws.js
+function assertThrows(fn, errorClassOrMsg, msgIncludesOrMsg, msg) {
+	let ErrorClass = void 0;
+	let msgIncludes = void 0;
+	let err;
+	if (typeof errorClassOrMsg !== "string") if (errorClassOrMsg === void 0 || errorClassOrMsg?.prototype instanceof Error || errorClassOrMsg?.prototype === Error.prototype) {
+		ErrorClass = errorClassOrMsg;
+		msgIncludes = msgIncludesOrMsg;
+	} else msg = msgIncludesOrMsg;
+	else msg = errorClassOrMsg;
+	let doesThrow = false;
+	const msgSuffix = msg ? `: ${msg}` : ".";
+	try {
+		fn();
+	} catch (error) {
+		if (ErrorClass) {
+			if (error instanceof Error === false) throw new AssertionError(`A non-Error object was thrown${msgSuffix}`);
+			assertIsError(error, ErrorClass, msgIncludes, msg);
+		}
+		err = error;
+		doesThrow = true;
+	}
+	if (!doesThrow) {
+		msg = `Expected function to throw${msgSuffix}`;
+		throw new AssertionError(msg);
+	}
+	return err;
+}
+
+//#endregion
+export { assertThrows };

package/dist/node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assertion_error.js

@@ -0,0 +1,33 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assertion_error.js
+/**
+* Error thrown when an assertion fails.
+*
+* @example Usage
+* ```ts no-eval
+* import { AssertionError } from "@std/assert/assertion-error";
+*
+* throw new AssertionError("Assertion failed");
+* ```
+*/ var AssertionError = class extends Error {
+	/** Constructs a new instance.
+	*
+	* @example Usage
+	* ```ts no-eval
+	* import { AssertionError } from "@std/assert/assertion-error";
+	*
+	* throw new AssertionError("Assertion failed");
+	* ```
+	*
+	* @param message The error message.
+	*/ constructor(message) {
+		super(message);
+		this.name = "AssertionError";
+	}
+};
+
+//#endregion
+export { AssertionError };

package/dist/node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/equal.js

@@ -0,0 +1,79 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/equal.js
+function isKeyedCollection(x) {
+	return [Symbol.iterator, "size"].every((k) => k in x);
+}
+function constructorsEqual(a, b) {
+	return a.constructor === b.constructor || a.constructor === Object && !b.constructor || !a.constructor && b.constructor === Object;
+}
+/**
+* Deep equality comparison used in assertions
+*
+* @param c The actual value
+* @param d The expected value
+* @returns `true` if the values are deeply equal, `false` otherwise
+*
+* @example Usage
+* ```ts
+* import { equal } from "@std/assert/equal";
+*
+* equal({ foo: "bar" }, { foo: "bar" }); // Returns `true`
+* equal({ foo: "bar" }, { foo: "baz" }); // Returns `false
+* ```
+*/ function equal(c, d) {
+	const seen = new Map();
+	return function compare(a, b) {
+		if (a && b && (a instanceof RegExp && b instanceof RegExp || a instanceof URL && b instanceof URL)) return String(a) === String(b);
+		if (a instanceof Date && b instanceof Date) {
+			const aTime = a.getTime();
+			const bTime = b.getTime();
+			if (Number.isNaN(aTime) && Number.isNaN(bTime)) return true;
+			return aTime === bTime;
+		}
+		if (typeof a === "number" && typeof b === "number") return Number.isNaN(a) && Number.isNaN(b) || a === b;
+		if (Object.is(a, b)) return true;
+		if (a && typeof a === "object" && b && typeof b === "object") {
+			if (a && b && !constructorsEqual(a, b)) return false;
+			if (a instanceof WeakMap || b instanceof WeakMap) {
+				if (!(a instanceof WeakMap && b instanceof WeakMap)) return false;
+				throw new TypeError("cannot compare WeakMap instances");
+			}
+			if (a instanceof WeakSet || b instanceof WeakSet) {
+				if (!(a instanceof WeakSet && b instanceof WeakSet)) return false;
+				throw new TypeError("cannot compare WeakSet instances");
+			}
+			if (a instanceof WeakRef || b instanceof WeakRef) {
+				if (!(a instanceof WeakRef && b instanceof WeakRef)) return false;
+				return compare(a.deref(), b.deref());
+			}
+			if (seen.get(a) === b) return true;
+			if (Object.keys(a).length !== Object.keys(b).length) return false;
+			seen.set(a, b);
+			if (isKeyedCollection(a) && isKeyedCollection(b)) {
+				if (a.size !== b.size) return false;
+				let unmatchedEntries = a.size;
+				for (const [aKey, aValue] of a.entries()) for (const [bKey, bValue] of b.entries()) if (aKey === aValue && bKey === bValue && compare(aKey, bKey) || compare(aKey, bKey) && compare(aValue, bValue)) {
+					unmatchedEntries--;
+					break;
+				}
+				return unmatchedEntries === 0;
+			}
+			const merged = {
+				...a,
+				...b
+			};
+			for (const key of [...Object.getOwnPropertyNames(merged), ...Object.getOwnPropertySymbols(merged)]) {
+				if (!compare(a && a[key], b && b[key])) return false;
+				if (key in a && !(key in b) || key in b && !(key in a)) return false;
+			}
+			return true;
+		}
+		return false;
+	}(c, d);
+}
+
+//#endregion
+export { equal };

package/dist/node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/mod.js

@@ -0,0 +1,19 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { AssertionError } from "./assertion_error.js";
+import { assert } from "./assert.js";
+import { equal } from "./equal.js";
+import { assertEquals } from "./assert_equals.js";
+import { assertInstanceOf } from "./assert_instance_of.js";
+import { assertExists } from "./assert_exists.js";
+import { assertFalse } from "./assert_false.js";
+import { assertGreaterOrEqual } from "./assert_greater_or_equal.js";
+import { assertGreater } from "./assert_greater.js";
+import { assertIsError } from "./assert_is_error.js";
+import { assertNotEquals } from "./assert_not_equals.js";
+import { assertRejects } from "./assert_rejects.js";
+import { assertStrictEquals } from "./assert_strict_equals.js";
+import { assertStringIncludes } from "./assert_string_includes.js";
+import { assertThrows } from "./assert_throws.js";

package/dist/node_modules/.pnpm/@jsr_std__internal@1.0.7/node_modules/@jsr/std__internal/assertion_state.js

@@ -0,0 +1,177 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/@jsr+std__internal@1.0.7/node_modules/@jsr/std__internal/assertion_state.js
+/**
+* Check the test suite internal state
+*
+* @example Usage
+* ```ts ignore
+* import { AssertionState } from "@std/internal";
+*
+* const assertionState = new AssertionState();
+* ```
+*/ var AssertionState = class {
+	#state;
+	constructor() {
+		this.#state = {
+			assertionCount: void 0,
+			assertionCheck: false,
+			assertionTriggered: false,
+			assertionTriggeredCount: 0
+		};
+		globalThis.addEventListener("unload", () => {
+			if (this.#state.assertionCheck || this.#state.assertionCount !== void 0) throw new Error("AssertionCounter was not cleaned up: If tests are not otherwise failing, ensure `expect.hasAssertion` and `expect.assertions` are only run in bdd tests");
+		});
+	}
+	/**
+	* Get the number that through `expect.assertions` api set.
+	*
+	* @returns the number that through `expect.assertions` api set.
+	*
+	* @example Usage
+	* ```ts ignore
+	* import { AssertionState } from "@std/internal";
+	*
+	* const assertionState = new AssertionState();
+	* assertionState.assertionCount;
+	* ```
+	*/ get assertionCount() {
+		return this.#state.assertionCount;
+	}
+	/**
+	* Get a certain number that assertions were called before.
+	*
+	* @returns return a certain number that assertions were called before.
+	*
+	* @example Usage
+	* ```ts ignore
+	* import { AssertionState } from "@std/internal";
+	*
+	* const assertionState = new AssertionState();
+	* assertionState.assertionTriggeredCount;
+	* ```
+	*/ get assertionTriggeredCount() {
+		return this.#state.assertionTriggeredCount;
+	}
+	/**
+	* If `expect.hasAssertions` called, then through this method to update #state.assertionCheck value.
+	*
+	* @param val Set #state.assertionCheck's value
+	*
+	* @example Usage
+	* ```ts ignore
+	* import { AssertionState } from "@std/internal";
+	*
+	* const assertionState = new AssertionState();
+	* assertionState.setAssertionCheck(true);
+	* ```
+	*/ setAssertionCheck(val) {
+		this.#state.assertionCheck = val;
+	}
+	/**
+	* If any matchers was called, `#state.assertionTriggered` will be set through this method.
+	*
+	* @param val Set #state.assertionTriggered's value
+	*
+	* @example Usage
+	* ```ts ignore
+	* import { AssertionState } from "@std/internal";
+	*
+	* const assertionState = new AssertionState();
+	* assertionState.setAssertionTriggered(true);
+	* ```
+	*/ setAssertionTriggered(val) {
+		this.#state.assertionTriggered = val;
+	}
+	/**
+	* If `expect.assertions` called, then through this method to update #state.assertionCheck value.
+	*
+	* @param num Set #state.assertionCount's value, for example if the value is set 2, that means
+	* you must have two assertion matchers call in your test suite.
+	*
+	* @example Usage
+	* ```ts ignore
+	* import { AssertionState } from "@std/internal";
+	*
+	* const assertionState = new AssertionState();
+	* assertionState.setAssertionCount(2);
+	* ```
+	*/ setAssertionCount(num) {
+		this.#state.assertionCount = num;
+	}
+	/**
+	* If any matchers was called, `#state.assertionTriggeredCount` value will plus one internally.
+	*
+	* @example Usage
+	* ```ts ignore
+	* import { AssertionState } from "@std/internal";
+	*
+	* const assertionState = new AssertionState();
+	* assertionState.updateAssertionTriggerCount();
+	* ```
+	*/ updateAssertionTriggerCount() {
+		if (this.#state.assertionCount !== void 0) this.#state.assertionTriggeredCount += 1;
+	}
+	/**
+	* Check Assertion internal state, if `#state.assertionCheck` is set true, but
+	* `#state.assertionTriggered` is still false, then should throw an Assertion Error.
+	*
+	* @returns a boolean value, that the test suite is satisfied with the check. If not,
+	* it should throw an AssertionError.
+	*
+	* @example Usage
+	* ```ts ignore
+	* import { AssertionState } from "@std/internal";
+	*
+	* const assertionState = new AssertionState();
+	* if (assertionState.checkAssertionErrorState()) {
+	*   // throw AssertionError("");
+	* }
+	* ```
+	*/ checkAssertionErrorState() {
+		return this.#state.assertionCheck && !this.#state.assertionTriggered;
+	}
+	/**
+	* Reset all assertion state when every test suite function ran completely.
+	*
+	* @example Usage
+	* ```ts ignore
+	* import { AssertionState } from "@std/internal";
+	*
+	* const assertionState = new AssertionState();
+	* assertionState.resetAssertionState();
+	* ```
+	*/ resetAssertionState() {
+		this.#state = {
+			assertionCount: void 0,
+			assertionCheck: false,
+			assertionTriggered: false,
+			assertionTriggeredCount: 0
+		};
+	}
+	/**
+	* Check Assertion called state, if `#state.assertionCount` is set to a number value, but
+	* `#state.assertionTriggeredCount` is less then it, then should throw an assertion error.
+	*
+	* @returns a boolean value, that the test suite is satisfied with the check. If not,
+	* it should throw an AssertionError.
+	*
+	* @example Usage
+	* ```ts ignore
+	* import { AssertionState } from "@std/internal";
+	*
+	* const assertionState = new AssertionState();
+	* if (assertionState.checkAssertionCountSatisfied()) {
+	*   // throw AssertionError("");
+	* }
+	* ```
+	*/ checkAssertionCountSatisfied() {
+		return this.#state.assertionCount !== void 0 && this.#state.assertionCount !== this.#state.assertionTriggeredCount;
+	}
+};
+const assertionState = new AssertionState();
+
+//#endregion
+export { AssertionState };

package/dist/node_modules/.pnpm/@jsr_std__internal@1.0.7/node_modules/@jsr/std__internal/build_message.js

@@ -0,0 +1,101 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { bgGreen, bgRed, bold, gray, green, red, white } from "./styles.js";
+
+//#region node_modules/.pnpm/@jsr+std__internal@1.0.7/node_modules/@jsr/std__internal/build_message.js
+/**
+* Colors the output of assertion diffs.
+*
+* @param diffType Difference type, either added or removed.
+* @param background If true, colors the background instead of the text.
+*
+* @returns A function that colors the input string.
+*
+* @example Usage
+* ```ts
+* import { createColor } from "@std/internal";
+* import { assertEquals } from "@std/assert";
+* import { bold, green, red, white } from "@std/fmt/colors";
+*
+* assertEquals(createColor("added")("foo"), green(bold("foo")));
+* assertEquals(createColor("removed")("foo"), red(bold("foo")));
+* assertEquals(createColor("common")("foo"), white("foo"));
+* ```
+*/ function createColor(diffType, background = false) {
+	switch (diffType) {
+		case "added": return (s) => background ? bgGreen(white(s)) : green(bold(s));
+		case "removed": return (s) => background ? bgRed(white(s)) : red(bold(s));
+		default: return white;
+	}
+}
+/**
+* Prefixes `+` or `-` in diff output.
+*
+* @param diffType Difference type, either added or removed
+*
+* @returns A string representing the sign.
+*
+* @example Usage
+* ```ts
+* import { createSign } from "@std/internal";
+* import { assertEquals } from "@std/assert";
+*
+* assertEquals(createSign("added"), "+   ");
+* assertEquals(createSign("removed"), "-   ");
+* assertEquals(createSign("common"), "    ");
+* ```
+*/ function createSign(diffType) {
+	switch (diffType) {
+		case "added": return "+   ";
+		case "removed": return "-   ";
+		default: return "    ";
+	}
+}
+/**
+* Builds a message based on the provided diff result.
+*
+* @param diffResult The diff result array.
+* @param options Optional parameters for customizing the message.
+*
+* @returns An array of strings representing the built message.
+*
+* @example Usage
+* ```ts no-assert
+* import { diffStr, buildMessage } from "@std/internal";
+*
+* const diffResult = diffStr("Hello, world!", "Hello, world");
+*
+* console.log(buildMessage(diffResult));
+* // [
+* //   "",
+* //   "",
+* //   "    [Diff] Actual / Expected",
+* //   "",
+* //   "",
+* //   "-   Hello, world!",
+* //   "+   Hello, world",
+* //   "",
+* // ]
+* ```
+*/ function buildMessage(diffResult, options = {}) {
+	const { stringDiff = false } = options;
+	const messages = [
+		"",
+		"",
+		`    ${gray(bold("[Diff]"))} ${red(bold("Actual"))} / ${green(bold("Expected"))}`,
+		"",
+		""
+	];
+	const diffMessages = diffResult.map((result) => {
+		const color = createColor(result.type);
+		const line = result.details?.map((detail) => detail.type !== "common" ? createColor(detail.type, true)(detail.value) : detail.value).join("") ?? result.value;
+		return color(`${createSign(result.type)}${line}`);
+	});
+	messages.push(...stringDiff ? [diffMessages.join("")] : diffMessages, "");
+	return messages;
+}
+
+//#endregion
+export { buildMessage, createColor, createSign };