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

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

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

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

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

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

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

@@ -1,274 +0,0 @@
-
-      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/diff.js
-const REMOVED = 1;
-const COMMON = 2;
-const ADDED = 3;
-/**
-* Creates an array of common elements between two arrays.
-*
-* @typeParam T The type of elements in the arrays.
-*
-* @param A The first array.
-* @param B The second array.
-*
-* @returns An array containing the common elements between the two arrays.
-*
-* @example Usage
-* ```ts
-* import { createCommon } from "@std/internal/diff";
-* import { assertEquals } from "@std/assert";
-*
-* const a = [1, 2, 3];
-* const b = [1, 2, 4];
-*
-* assertEquals(createCommon(a, b), [1, 2]);
-* ```
-*/ function createCommon(A, B) {
-	const common = [];
-	if (A.length === 0 || B.length === 0) return [];
-	for (let i = 0; i < Math.min(A.length, B.length); i += 1) {
-		const a = A[i];
-		const b = B[i];
-		if (a !== void 0 && a === b) common.push(a);
-		else return common;
-	}
-	return common;
-}
-/**
-* Asserts that the value is a {@linkcode FarthestPoint}.
-* If not, an error is thrown.
-*
-* @param value The value to check.
-*
-* @returns A void value that returns once the assertion completes.
-*
-* @example Usage
-* ```ts
-* import { assertFp } from "@std/internal/diff";
-* import { assertThrows } from "@std/assert";
-*
-* assertFp({ y: 0, id: 0 });
-* assertThrows(() => assertFp({ id: 0 }));
-* assertThrows(() => assertFp({ y: 0 }));
-* assertThrows(() => assertFp(undefined));
-* ```
-*/ function assertFp(value) {
-	if (value == null || typeof value !== "object" || typeof value?.y !== "number" || typeof value?.id !== "number") throw new Error(`Unexpected value, expected 'FarthestPoint': received ${typeof value}`);
-}
-/**
-* Creates an array of backtraced differences.
-*
-* @typeParam T The type of elements in the arrays.
-*
-* @param A The first array.
-* @param B The second array.
-* @param current The current {@linkcode FarthestPoint}.
-* @param swapped Boolean indicating if the arrays are swapped.
-* @param routes The routes array.
-* @param diffTypesPtrOffset The offset of the diff types in the routes array.
-*
-* @returns An array of backtraced differences.
-*
-* @example Usage
-* ```ts
-* import { backTrace } from "@std/internal/diff";
-* import { assertEquals } from "@std/assert";
-*
-* assertEquals(
-*   backTrace([], [], { y: 0, id: 0 }, false, new Uint32Array(0), 0),
-*   [],
-* );
-* ```
-*/ function backTrace(A, B, current, swapped, routes, diffTypesPtrOffset) {
-	const M = A.length;
-	const N = B.length;
-	const result = [];
-	let a = M - 1;
-	let b = N - 1;
-	let j = routes[current.id];
-	let type = routes[current.id + diffTypesPtrOffset];
-	while (true) {
-		if (!j && !type) break;
-		const prev = j;
-		if (type === REMOVED) {
-			result.unshift({
-				type: swapped ? "removed" : "added",
-				value: B[b]
-			});
-			b -= 1;
-		} else if (type === ADDED) {
-			result.unshift({
-				type: swapped ? "added" : "removed",
-				value: A[a]
-			});
-			a -= 1;
-		} else {
-			result.unshift({
-				type: "common",
-				value: A[a]
-			});
-			a -= 1;
-			b -= 1;
-		}
-		j = routes[prev];
-		type = routes[prev + diffTypesPtrOffset];
-	}
-	return result;
-}
-/**
-* Creates a {@linkcode FarthestPoint}.
-*
-* @param k The current index.
-* @param M The length of the first array.
-* @param routes The routes array.
-* @param diffTypesPtrOffset The offset of the diff types in the routes array.
-* @param ptr The current pointer.
-* @param slide The slide {@linkcode FarthestPoint}.
-* @param down The down {@linkcode FarthestPoint}.
-*
-* @returns A {@linkcode FarthestPoint}.
-*
-* @example Usage
-* ```ts
-* import { createFp } from "@std/internal/diff";
-* import { assertEquals } from "@std/assert";
-*
-* assertEquals(
-*   createFp(
-*     0,
-*     0,
-*     new Uint32Array(0),
-*     0,
-*     0,
-*     { y: -1, id: 0 },
-*     { y: 0, id: 0 },
-*   ),
-*   { y: -1, id: 1 },
-* );
-* ```
-*/ function createFp(k, M, routes, diffTypesPtrOffset, ptr, slide, down) {
-	if (slide && slide.y === -1 && down && down.y === -1) return {
-		y: 0,
-		id: 0
-	};
-	const isAdding = down?.y === -1 || k === M || (slide?.y ?? 0) > (down?.y ?? 0) + 1;
-	if (slide && isAdding) {
-		const prev = slide.id;
-		ptr++;
-		routes[ptr] = prev;
-		routes[ptr + diffTypesPtrOffset] = ADDED;
-		return {
-			y: slide.y,
-			id: ptr
-		};
-	}
-	if (down && !isAdding) {
-		const prev = down.id;
-		ptr++;
-		routes[ptr] = prev;
-		routes[ptr + diffTypesPtrOffset] = REMOVED;
-		return {
-			y: down.y + 1,
-			id: ptr
-		};
-	}
-	throw new Error("Unexpected missing FarthestPoint");
-}
-/**
-* Renders the differences between the actual and expected values.
-*
-* @typeParam T The type of elements in the arrays.
-*
-* @param A Actual value
-* @param B Expected value
-*
-* @returns An array of differences between the actual and expected values.
-*
-* @example Usage
-* ```ts
-* import { diff } from "@std/internal/diff";
-* import { assertEquals } from "@std/assert";
-*
-* const a = [1, 2, 3];
-* const b = [1, 2, 4];
-*
-* assertEquals(diff(a, b), [
-*   { type: "common", value: 1 },
-*   { type: "common", value: 2 },
-*   { type: "removed", value: 3 },
-*   { type: "added", value: 4 },
-* ]);
-* ```
-*/ function diff(A, B) {
-	const prefixCommon = createCommon(A, B);
-	A = A.slice(prefixCommon.length);
-	B = B.slice(prefixCommon.length);
-	const swapped = B.length > A.length;
-	[A, B] = swapped ? [B, A] : [A, B];
-	const M = A.length;
-	const N = B.length;
-	if (!M && !N && !prefixCommon.length) return [];
-	if (!N) return [...prefixCommon.map((value) => ({
-		type: "common",
-		value
-	})), ...A.map((value) => ({
-		type: swapped ? "added" : "removed",
-		value
-	}))];
-	const offset = N;
-	const delta = M - N;
-	const length = M + N + 1;
-	const fp = Array.from({ length }, () => ({
-		y: -1,
-		id: -1
-	}));
-	/**
-	* Note: this buffer is used to save memory and improve performance. The first
-	* half is used to save route and the last half is used to save diff type.
-	*/ const routes = new Uint32Array((M * N + length + 1) * 2);
-	const diffTypesPtrOffset = routes.length / 2;
-	let ptr = 0;
-	function snake(k, A$1, B$1, slide, down) {
-		const M$1 = A$1.length;
-		const N$1 = B$1.length;
-		const fp$1 = createFp(k, M$1, routes, diffTypesPtrOffset, ptr, slide, down);
-		ptr = fp$1.id;
-		while (fp$1.y + k < M$1 && fp$1.y < N$1 && A$1[fp$1.y + k] === B$1[fp$1.y]) {
-			const prev = fp$1.id;
-			ptr++;
-			fp$1.id = ptr;
-			fp$1.y += 1;
-			routes[ptr] = prev;
-			routes[ptr + diffTypesPtrOffset] = COMMON;
-		}
-		return fp$1;
-	}
-	let currentFp = fp[delta + offset];
-	assertFp(currentFp);
-	let p = -1;
-	while (currentFp.y < N) {
-		p = p + 1;
-		for (let k = -p; k < delta; ++k) {
-			const index$1 = k + offset;
-			fp[index$1] = snake(k, A, B, fp[index$1 - 1], fp[index$1 + 1]);
-		}
-		for (let k = delta + p; k > delta; --k) {
-			const index$1 = k + offset;
-			fp[index$1] = snake(k, A, B, fp[index$1 - 1], fp[index$1 + 1]);
-		}
-		const index = delta + offset;
-		fp[delta + offset] = snake(delta, A, B, fp[index - 1], fp[index + 1]);
-		currentFp = fp[delta + offset];
-		assertFp(currentFp);
-	}
-	return [...prefixCommon.map((value) => ({
-		type: "common",
-		value
-	})), ...backTrace(A, B, currentFp, swapped, routes, diffTypesPtrOffset)];
-}
-
-//#endregion
-export { assertFp, backTrace, createCommon, createFp, diff };