@fedify/fedify 1.6.0-dev.813 → 1.6.0-experiment.0

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

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

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

@@ -0,0 +1,148 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { diff } from "./diff.js";
+
+//#region node_modules/.pnpm/@jsr+std__internal@1.0.7/node_modules/@jsr/std__internal/diff_str.js
+/**
+* Unescape invisible characters.
+*
+* @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#escape_sequences}
+*
+* @param string String to unescape.
+*
+* @returns Unescaped string.
+*
+* @example Usage
+* ```ts
+* import { unescape } from "@std/internal/diff-str";
+* import { assertEquals } from "@std/assert";
+*
+* assertEquals(unescape("Hello\nWorld"), "Hello\\n\nWorld");
+* ```
+*/ function unescape(string) {
+	return string.replaceAll("\\", "\\\\").replaceAll("\b", "\\b").replaceAll("\f", "\\f").replaceAll("	", "\\t").replaceAll("\v", "\\v").replaceAll(/\r\n|\r|\n/g, (str) => str === "\r" ? "\\r" : str === "\n" ? "\\n\n" : "\\r\\n\r\n");
+}
+const WHITESPACE_SYMBOLS = /((?:\\[bftv]|[^\S\r\n])+|\\[rn\\]|[()[\]{}'"\r\n]|\b)/;
+/**
+* Tokenizes a string into an array of tokens.
+*
+* @param string The string to tokenize.
+* @param wordDiff If true, performs word-based tokenization. Default is false.
+*
+* @returns An array of tokens.
+*
+* @example Usage
+* ```ts
+* import { tokenize } from "@std/internal/diff-str";
+* import { assertEquals } from "@std/assert";
+*
+* assertEquals(tokenize("Hello\nWorld"), ["Hello\n", "World"]);
+* ```
+*/ function tokenize(string, wordDiff = false) {
+	if (wordDiff) return string.split(WHITESPACE_SYMBOLS).filter((token) => token);
+	const tokens = [];
+	const lines = string.split(/(\n|\r\n)/).filter((line) => line);
+	for (const [i, line] of lines.entries()) if (i % 2) tokens[tokens.length - 1] += line;
+	else tokens.push(line);
+	return tokens;
+}
+/**
+* Create details by filtering relevant word-diff for current line and merge
+* "space-diff" if surrounded by word-diff for cleaner displays.
+*
+* @param line Current line
+* @param tokens Word-diff tokens
+*
+* @returns Array of diff results.
+*
+* @example Usage
+* ```ts
+* import { createDetails } from "@std/internal/diff-str";
+* import { assertEquals } from "@std/assert";
+*
+* const tokens = [
+*   { type: "added", value: "a" },
+*   { type: "removed", value: "b" },
+*   { type: "common", value: "c" },
+* ] as const;
+* assertEquals(
+*   createDetails({ type: "added", value: "a" }, [...tokens]),
+*   [{ type: "added", value: "a" }, { type: "common", value: "c" }]
+* );
+* ```
+*/ function createDetails(line, tokens) {
+	return tokens.filter(({ type }) => type === line.type || type === "common").map((result, i, t) => {
+		const token = t[i - 1];
+		if (result.type === "common" && token && token.type === t[i + 1]?.type && /\s+/.test(result.value)) return {
+			...result,
+			type: token.type
+		};
+		return result;
+	});
+}
+const NON_WHITESPACE_REGEXP = /\S/;
+/**
+* Renders the differences between the actual and expected strings. Partially
+* inspired from {@link https://github.com/kpdecker/jsdiff}.
+*
+* @param A Actual string
+* @param B Expected string
+*
+* @returns Array of diff results.
+*
+* @example Usage
+* ```ts
+* import { diffStr } from "@std/internal/diff-str";
+* import { assertEquals } from "@std/assert";
+*
+* assertEquals(diffStr("Hello!", "Hello"), [
+*   {
+*     type: "removed",
+*     value: "Hello!\n",
+*     details: [
+*       { type: "common", value: "Hello" },
+*       { type: "removed", value: "!" },
+*       { type: "common", value: "\n" }
+*     ]
+*   },
+*   {
+*     type: "added",
+*     value: "Hello\n",
+*     details: [
+*       { type: "common", value: "Hello" },
+*       { type: "common", value: "\n" }
+*     ]
+*   }
+* ]);
+* ```
+*/ function diffStr(A, B) {
+	const diffResult = diff(tokenize(`${unescape(A)}\n`), tokenize(`${unescape(B)}\n`));
+	const added = [];
+	const removed = [];
+	for (const result of diffResult) {
+		if (result.type === "added") added.push(result);
+		if (result.type === "removed") removed.push(result);
+	}
+	const hasMoreRemovedLines = added.length < removed.length;
+	const aLines = hasMoreRemovedLines ? added : removed;
+	const bLines = hasMoreRemovedLines ? removed : added;
+	for (const a of aLines) {
+		let tokens = [];
+		let b;
+		while (bLines.length) {
+			b = bLines.shift();
+			const tokenized = [tokenize(a.value, true), tokenize(b.value, true)];
+			if (hasMoreRemovedLines) tokenized.reverse();
+			tokens = diff(tokenized[0], tokenized[1]);
+			if (tokens.some(({ type, value }) => type === "common" && NON_WHITESPACE_REGEXP.test(value))) break;
+		}
+		a.details = createDetails(a, tokens);
+		if (b) b.details = createDetails(b, tokens);
+	}
+	return diffResult;
+}
+
+//#endregion
+export { createDetails, diffStr, tokenize, unescape };

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

@@ -0,0 +1,37 @@
+
+      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/format.js
+/**
+* Converts the input into a string. Objects, Sets and Maps are sorted so as to
+* make tests less flaky.
+*
+* @param v Value to be formatted
+*
+* @returns The formatted string
+*
+* @example Usage
+* ```ts
+* import { format } from "@std/internal/format";
+* import { assertEquals } from "@std/assert";
+*
+* assertEquals(format({ a: 1, b: 2 }), "{\n  a: 1,\n  b: 2,\n}");
+* assertEquals(format(new Set([1, 2])), "Set(2) {\n  1,\n  2,\n}");
+* assertEquals(format(new Map([[1, 2]])), "Map(1) {\n  1 => 2,\n}");
+* ```
+*/ function format(v) {
+	const { Deno } = globalThis;
+	return typeof Deno?.inspect === "function" ? Deno.inspect(v, {
+		depth: Infinity,
+		sorted: true,
+		trailingComma: true,
+		compact: false,
+		iterableLimit: Infinity,
+		getters: true,
+		strAbbreviateSize: Infinity
+	}) : `"${String(v).replace(/(?=["\\])/g, "\\")}"`;
+}
+
+//#endregion
+export { format };

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

@@ -0,0 +1,10 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { AssertionState } from "./assertion_state.js";
+import { bgGreen, bgRed, bold, brightBlack, gray, green, red, stripAnsiCode, white } from "./styles.js";
+import { buildMessage, createColor, createSign } from "./build_message.js";
+import { assertFp, backTrace, createCommon, createFp, diff } from "./diff.js";
+import { createDetails, diffStr, tokenize, unescape } from "./diff_str.js";
+import { format } from "./format.js";

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

@@ -0,0 +1,172 @@
+
+      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/styles.js
+const { Deno } = globalThis;
+const noColor = typeof Deno?.noColor === "boolean" ? Deno.noColor : false;
+const enabled = !noColor;
+function code(open, close) {
+	return {
+		open: `\x1b[${open.join(";")}m`,
+		close: `\x1b[${close}m`,
+		regexp: new RegExp(`\\x1b\\[${close}m`, "g")
+	};
+}
+function run(str, code$1) {
+	return enabled ? `${code$1.open}${str.replace(code$1.regexp, code$1.open)}${code$1.close}` : str;
+}
+/**
+* Sets the style of text to be printed to bold.
+*
+* Disable by setting the `NO_COLOR` environmental variable.
+*
+* @param str Text to make bold
+*
+* @returns Bold text for printing
+*
+* @example Usage
+* ```ts no-assert
+* import { bold } from "@std/internal/styles";
+*
+* console.log(bold("Hello, world!")); // Prints "Hello, world!" in bold
+* ```
+*/ function bold(str) {
+	return run(str, code([1], 22));
+}
+/**
+* Sets the color of text to be printed to red.
+*
+* Disable by setting the `NO_COLOR` environmental variable.
+*
+* @param str Text to make red
+*
+* @returns Red text for printing
+*
+* @example Usage
+* ```ts no-assert
+* import { red } from "@std/internal/styles";
+*
+* console.log(red("Hello, world!")); // Prints "Hello, world!" in red
+* ```
+*/ function red(str) {
+	return run(str, code([31], 39));
+}
+/**
+* Sets the color of text to be printed to green.
+*
+* Disable by setting the `NO_COLOR` environmental variable.
+*
+* @param str Text to make green
+*
+* @returns Green text for print
+*
+* @example Usage
+* ```ts no-assert
+* import { green } from "@std/internal/styles";
+*
+* console.log(green("Hello, world!")); // Prints "Hello, world!" in green
+* ```
+*/ function green(str) {
+	return run(str, code([32], 39));
+}
+/**
+* Sets the color of text to be printed to white.
+*
+* @param str Text to make white
+*
+* @returns White text for print
+*
+* @example Usage
+* ```ts no-assert
+* import { white } from "@std/internal/styles";
+*
+* console.log(white("Hello, world!")); // Prints "Hello, world!" in white
+* ```
+*/ function white(str) {
+	return run(str, code([37], 39));
+}
+/**
+* Sets the color of text to be printed to gray.
+*
+* @param str Text to make gray
+*
+* @returns Gray text for print
+*
+* @example Usage
+* ```ts no-assert
+* import { gray } from "@std/internal/styles";
+*
+* console.log(gray("Hello, world!")); // Prints "Hello, world!" in gray
+* ```
+*/ function gray(str) {
+	return brightBlack(str);
+}
+/**
+* Sets the color of text to be printed to bright-black.
+*
+* @param str Text to make bright-black
+*
+* @returns Bright-black text for print
+*
+* @example Usage
+* ```ts no-assert
+* import { brightBlack } from "@std/internal/styles";
+*
+* console.log(brightBlack("Hello, world!")); // Prints "Hello, world!" in bright-black
+* ```
+*/ function brightBlack(str) {
+	return run(str, code([90], 39));
+}
+/**
+* Sets the background color of text to be printed to red.
+*
+* @param str Text to make its background red
+*
+* @returns Red background text for print
+*
+* @example Usage
+* ```ts no-assert
+* import { bgRed } from "@std/internal/styles";
+*
+* console.log(bgRed("Hello, world!")); // Prints "Hello, world!" with red background
+* ```
+*/ function bgRed(str) {
+	return run(str, code([41], 49));
+}
+/**
+* Sets the background color of text to be printed to green.
+*
+* @param str Text to make its background green
+*
+* @returns Green background text for print
+*
+* @example Usage
+* ```ts no-assert
+* import { bgGreen } from "@std/internal/styles";
+*
+* console.log(bgGreen("Hello, world!")); // Prints "Hello, world!" with green background
+* ```
+*/ function bgGreen(str) {
+	return run(str, code([42], 49));
+}
+const ANSI_PATTERN = new RegExp(["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)", "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TXZcf-nq-uy=><~]))"].join("|"), "g");
+/**
+* Remove ANSI escape codes from the string.
+*
+* @param string Text to remove ANSI escape codes from
+*
+* @returns Text without ANSI escape codes
+*
+* @example Usage
+* ```ts no-assert
+* import { red, stripAnsiCode } from "@std/internal/styles";
+*
+* console.log(stripAnsiCode(red("Hello, world!"))); // Prints "Hello, world!"
+* ```
+*/ function stripAnsiCode(string) {
+	return string.replace(ANSI_PATTERN, "");
+}
+
+//#endregion
+export { bgGreen, bgRed, bold, brightBlack, gray, green, red, stripAnsiCode, white };

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

@@ -0,0 +1,11 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/@jsr+std__path@1.0.9/node_modules/@jsr/std__path/_common/assert_path.js
+function assertPath(path) {
+	if (typeof path !== "string") throw new TypeError(`Path must be a string, received "${JSON.stringify(path)}"`);
+}
+
+//#endregion
+export { assertPath };

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

@@ -0,0 +1,16 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/@jsr+std__path@1.0.9/node_modules/@jsr/std__path/_common/constants.js
+const CHAR_UPPERCASE_A = 65;
+const CHAR_LOWERCASE_A = 97;
+const CHAR_UPPERCASE_Z = 90;
+const CHAR_LOWERCASE_Z = 122;
+const CHAR_DOT = 46;
+const CHAR_FORWARD_SLASH = 47;
+const CHAR_BACKWARD_SLASH = 92;
+const CHAR_COLON = 58;
+
+//#endregion
+export { CHAR_BACKWARD_SLASH, CHAR_COLON, CHAR_DOT, CHAR_FORWARD_SLASH, CHAR_LOWERCASE_A, CHAR_LOWERCASE_Z, CHAR_UPPERCASE_A, CHAR_UPPERCASE_Z };

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

@@ -0,0 +1,14 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { assertPath } from "./assert_path.js";
+
+//#region node_modules/.pnpm/@jsr+std__path@1.0.9/node_modules/@jsr/std__path/_common/dirname.js
+function assertArg(path) {
+	assertPath(path);
+	if (path.length === 0) return ".";
+}
+
+//#endregion
+export { assertArg as assertArg$1 };

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

@@ -0,0 +1,13 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/@jsr+std__path@1.0.9/node_modules/@jsr/std__path/_common/from_file_url.js
+function assertArg(url) {
+	url = url instanceof URL ? url : new URL(url);
+	if (url.protocol !== "file:") throw new TypeError(`URL must be a file URL: received "${url.protocol}"`);
+	return url;
+}
+
+//#endregion
+export { assertArg as assertArg$2 };