@fedify/vocab-runtime 2.2.18-dev.2386 → 2.2.18

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/vocab-runtime",
-  "version": "2.2.18-dev.2386+41abb5f5",
+  "version": "2.2.18",
   "license": "MIT",
   "exports": {
     ".": "./src/mod.ts",

package/dist/mod.cjs

@@ -4593,7 +4593,7 @@ const preloadedContexts = {
 //#endregion
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.2.18-dev.2386+41abb5f5";
+var version = "2.2.18";
 //#endregion
 //#region src/request.ts
 /**
@@ -5254,7 +5254,9 @@ function getDocumentLoader({ allowPrivateAddress, maxRedirection, skipPreloadedC
 	const maximumRedirection = maxRedirection ?? DEFAULT_MAX_REDIRECTION;
 	async function load(url, options, redirected = 0, visited = /* @__PURE__ */ new Set()) {
 		options?.signal?.throwIfAborted();
-		const currentUrl = new URL(url).href;
+		const parsedUrl = new URL(url);
+		if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") throw new UrlError(`Unsupported protocol: ${parsedUrl.protocol}`);
+		const currentUrl = parsedUrl.href;
 		if (!skipPreloadedContexts && currentUrl in preloadedContexts) {
 			logger.debug("Using preloaded context: {url}.", { url: currentUrl });
 			return {

package/dist/mod.js

@@ -4588,7 +4588,7 @@ const preloadedContexts = {
 //#endregion
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.2.18-dev.2386+41abb5f5";
+var version = "2.2.18";
 //#endregion
 //#region src/request.ts
 /**
@@ -5249,7 +5249,9 @@ function getDocumentLoader({ allowPrivateAddress, maxRedirection, skipPreloadedC
 	const maximumRedirection = maxRedirection ?? DEFAULT_MAX_REDIRECTION;
 	async function load(url, options, redirected = 0, visited = /* @__PURE__ */ new Set()) {
 		options?.signal?.throwIfAborted();
-		const currentUrl = new URL(url).href;
+		const parsedUrl = new URL(url);
+		if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") throw new UrlError(`Unsupported protocol: ${parsedUrl.protocol}`);
+		const currentUrl = parsedUrl.href;
 		if (!skipPreloadedContexts && currentUrl in preloadedContexts) {
 			logger.debug("Using preloaded context: {url}.", { url: currentUrl });
 			return {

package/dist/tests/{body-DgJUdoFW.cjs → body-CaJBg0tr.cjs}

@@ -1,5 +1,5 @@
 require("./chunk-Do9eywBl.cjs");
-const require_request = require("./request-CNVibwBp.cjs");
+const require_request = require("./request-BngWcP0t.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 //#region src/body.ts
 /** Decoded JSON body limit: 16 MiB.  @internal */

package/dist/tests/{body-BblGrtLX.mjs → body-CbvYxP3V.mjs}

@@ -1,4 +1,4 @@
-import { t as FetchError } from "./request-D5w4xI1V.mjs";
+import { t as FetchError } from "./request-BE7XIrGw.mjs";
 import { getLogger } from "@logtape/logtape";
 //#region src/body.ts
 /** Decoded JSON body limit: 16 MiB.  @internal */

package/dist/tests/body.test.cjs

@@ -1,5 +1,5 @@
 require("./chunk-Do9eywBl.cjs");
-const require_body = require("./body-DgJUdoFW.cjs");
+const require_body = require("./body-CaJBg0tr.cjs");
 let node_assert_strict = require("node:assert/strict");
 let node_test = require("node:test");
 let node_zlib = require("node:zlib");

package/dist/tests/body.test.mjs

@@ -1,4 +1,4 @@
-import { r as readBoundedText, t as BodyTooLargeError } from "./body-BblGrtLX.mjs";
+import { r as readBoundedText, t as BodyTooLargeError } from "./body-CbvYxP3V.mjs";
 import { deepStrictEqual, ok, rejects } from "node:assert/strict";
 import { test } from "node:test";
 import { gunzipSync, gzipSync } from "node:zlib";

package/dist/tests/decimal.test.cjs

@@ -1,5 +1,5 @@
 require("./chunk-Do9eywBl.cjs");
-require("./docloader-BpTNd9pG.cjs");
+require("./docloader-k2T5kUlV.cjs");
 require("./url-vZTgkIZg.cjs");
 require("./key-BarKGLQz.cjs");
 require("./multibase-8zhYPa7o.cjs");

package/dist/tests/decimal.test.mjs

@@ -1,4 +1,4 @@
-import "./docloader-D-e_R3Qj.mjs";
+import "./docloader-jQMjHIRI.mjs";
 import "./url-3fyJuqC0.mjs";
 import "./key-BDIsC6hV.mjs";
 import "./multibase-Ds75BvXs.mjs";

package/dist/tests/{docloader-D-e_R3Qj.mjs → docloader-jQMjHIRI.mjs}

@@ -1,5 +1,5 @@
-import { a as name, i as logRequest, n as createActivityPubRequest, o as version, t as FetchError } from "./request-D5w4xI1V.mjs";
-import { n as MAX_BODY_SIZE, r as readBoundedText } from "./body-BblGrtLX.mjs";
+import { a as name, i as logRequest, n as createActivityPubRequest, o as version, t as FetchError } from "./request-BE7XIrGw.mjs";
+import { n as MAX_BODY_SIZE, r as readBoundedText } from "./body-CbvYxP3V.mjs";
 import { t as HttpHeaderLink } from "./link-CYszIegt.mjs";
 import { o as validatePublicUrl, t as UrlError } from "./url-3fyJuqC0.mjs";
 import { getLogger } from "@logtape/logtape";
@@ -4704,7 +4704,9 @@ function getDocumentLoader({ allowPrivateAddress, maxRedirection, skipPreloadedC
 	const maximumRedirection = maxRedirection ?? DEFAULT_MAX_REDIRECTION;
 	async function load(url, options, redirected = 0, visited = /* @__PURE__ */ new Set()) {
 		options?.signal?.throwIfAborted();
-		const currentUrl = new URL(url).href;
+		const parsedUrl = new URL(url);
+		if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") throw new UrlError(`Unsupported protocol: ${parsedUrl.protocol}`);
+		const currentUrl = parsedUrl.href;
 		if (!skipPreloadedContexts && currentUrl in preloadedContexts) {
 			logger.debug("Using preloaded context: {url}.", { url: currentUrl });
 			return {

package/dist/tests/{docloader-BpTNd9pG.cjs → docloader-k2T5kUlV.cjs}

@@ -1,6 +1,6 @@
 require("./chunk-Do9eywBl.cjs");
-const require_request = require("./request-CNVibwBp.cjs");
-const require_body = require("./body-DgJUdoFW.cjs");
+const require_request = require("./request-BngWcP0t.cjs");
+const require_body = require("./body-CaJBg0tr.cjs");
 const require_link = require("./link-qDTmjPw_.cjs");
 const require_url = require("./url-vZTgkIZg.cjs");
 let _logtape_logtape = require("@logtape/logtape");
@@ -4705,7 +4705,9 @@ function getDocumentLoader({ allowPrivateAddress, maxRedirection, skipPreloadedC
 	const maximumRedirection = maxRedirection ?? DEFAULT_MAX_REDIRECTION;
 	async function load(url, options, redirected = 0, visited = /* @__PURE__ */ new Set()) {
 		options?.signal?.throwIfAborted();
-		const currentUrl = new URL(url).href;
+		const parsedUrl = new URL(url);
+		if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") throw new require_url.UrlError(`Unsupported protocol: ${parsedUrl.protocol}`);
+		const currentUrl = parsedUrl.href;
 		if (!skipPreloadedContexts && currentUrl in preloadedContexts) {
 			logger.debug("Using preloaded context: {url}.", { url: currentUrl });
 			return {

package/dist/tests/docloader.test.cjs

@@ -1,6 +1,6 @@
 const require_chunk = require("./chunk-Do9eywBl.cjs");
-const require_request = require("./request-CNVibwBp.cjs");
-const require_docloader = require("./docloader-BpTNd9pG.cjs");
+const require_request = require("./request-BngWcP0t.cjs");
+const require_docloader = require("./docloader-k2T5kUlV.cjs");
 const require_url = require("./url-vZTgkIZg.cjs");
 let node_zlib = require("node:zlib");
 let _logtape_logtape = require("@logtape/logtape");
@@ -2009,4 +2009,52 @@ var jsonld_default = jsonld_dist_jsonld_esm_js.default;
 		esm_default.hardReset();
 	}
 });
+const unsupportedUrls = [
+	"ftp://example.com/collection",
+	"file:///collection",
+	`data:application/ld+json,${encodeURIComponent(JSON.stringify({ id: "https://example.com/data" }))}`
+];
+function isUnsupportedProtocolError(error, url) {
+	return error instanceof require_url.UrlError && error.message === `Unsupported protocol: ${new URL(url).protocol}` && error.reason === "disallowed";
+}
+async function withFetchStub(respond, callback) {
+	const fetched = [];
+	const originalFetch = globalThis.fetch;
+	globalThis.fetch = (input) => {
+		const url = input instanceof Request ? input.url : String(input);
+		fetched.push(url);
+		return Promise.resolve(respond(url));
+	};
+	try {
+		await callback(fetched);
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+}
+for (const url of unsupportedUrls) {
+	const scheme = new URL(url).protocol;
+	(0, _fedify_fixture.test)(`getDocumentLoader() rejects ${scheme} URLs with private addresses allowed before fetching`, async () => {
+		await withFetchStub(() => Response.json({}), async (fetched) => {
+			await (0, node_assert.rejects)(require_docloader.getDocumentLoader({ allowPrivateAddress: true })(url), (e) => isUnsupportedProtocolError(e, url));
+			(0, node_assert.deepStrictEqual)(fetched, []);
+		});
+	});
+	(0, _fedify_fixture.test)(`getDocumentLoader() rejects redirects to ${scheme} URLs with private addresses allowed`, async () => {
+		const start = "https://example.com/redirect-to-unsupported";
+		await withFetchStub(() => Response.redirect(url, 302), async (fetched) => {
+			await (0, node_assert.rejects)(require_docloader.getDocumentLoader({ allowPrivateAddress: true })(start), (e) => isUnsupportedProtocolError(e, url));
+			(0, node_assert.deepStrictEqual)(fetched, [start]);
+		});
+	});
+	for (const html of [false, true]) (0, _fedify_fixture.test)(`getDocumentLoader() rejects ${html ? "HTML" : "Link header"} alternates to ${scheme} URLs with private addresses allowed`, async () => {
+		const start = "https://example.com/alternate-to-unsupported";
+		await withFetchStub(() => html ? new Response(`<link rel="alternate" type="application/activity+json" href="${url}">`, { headers: { "Content-Type": "text/html" } }) : new Response("", { headers: {
+			"Content-Type": "text/plain",
+			Link: `<${url}>; rel="alternate"; type="application/activity+json"`
+		} }), async (fetched) => {
+			await (0, node_assert.rejects)(require_docloader.getDocumentLoader({ allowPrivateAddress: true })(start), (e) => isUnsupportedProtocolError(e, url));
+			(0, node_assert.deepStrictEqual)(fetched, [start]);
+		});
+	});
+}
 //#endregion

package/dist/tests/docloader.test.mjs

@@ -1,5 +1,5 @@
-import { t as FetchError } from "./request-D5w4xI1V.mjs";
-import { i as cid_v1_default, n as getRemoteDocument, r as preloadedContexts, t as getDocumentLoader } from "./docloader-D-e_R3Qj.mjs";
+import { t as FetchError } from "./request-BE7XIrGw.mjs";
+import { i as cid_v1_default, n as getRemoteDocument, r as preloadedContexts, t as getDocumentLoader } from "./docloader-jQMjHIRI.mjs";
 import { t as UrlError } from "./url-3fyJuqC0.mjs";
 import { gzipSync } from "node:zlib";
 import { configure, reset } from "@logtape/logtape";
@@ -2026,5 +2026,53 @@ test("getDocumentLoader() rejects cancellation before fetching", async () => {
 		esm_default.hardReset();
 	}
 });
+const unsupportedUrls = [
+	"ftp://example.com/collection",
+	"file:///collection",
+	`data:application/ld+json,${encodeURIComponent(JSON.stringify({ id: "https://example.com/data" }))}`
+];
+function isUnsupportedProtocolError(error, url) {
+	return error instanceof UrlError && error.message === `Unsupported protocol: ${new URL(url).protocol}` && error.reason === "disallowed";
+}
+async function withFetchStub(respond, callback) {
+	const fetched = [];
+	const originalFetch = globalThis.fetch;
+	globalThis.fetch = (input) => {
+		const url = input instanceof Request ? input.url : String(input);
+		fetched.push(url);
+		return Promise.resolve(respond(url));
+	};
+	try {
+		await callback(fetched);
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+}
+for (const url of unsupportedUrls) {
+	const scheme = new URL(url).protocol;
+	test(`getDocumentLoader() rejects ${scheme} URLs with private addresses allowed before fetching`, async () => {
+		await withFetchStub(() => Response.json({}), async (fetched) => {
+			await rejects(getDocumentLoader({ allowPrivateAddress: true })(url), (e) => isUnsupportedProtocolError(e, url));
+			deepStrictEqual(fetched, []);
+		});
+	});
+	test(`getDocumentLoader() rejects redirects to ${scheme} URLs with private addresses allowed`, async () => {
+		const start = "https://example.com/redirect-to-unsupported";
+		await withFetchStub(() => Response.redirect(url, 302), async (fetched) => {
+			await rejects(getDocumentLoader({ allowPrivateAddress: true })(start), (e) => isUnsupportedProtocolError(e, url));
+			deepStrictEqual(fetched, [start]);
+		});
+	});
+	for (const html of [false, true]) test(`getDocumentLoader() rejects ${html ? "HTML" : "Link header"} alternates to ${scheme} URLs with private addresses allowed`, async () => {
+		const start = "https://example.com/alternate-to-unsupported";
+		await withFetchStub(() => html ? new Response(`<link rel="alternate" type="application/activity+json" href="${url}">`, { headers: { "Content-Type": "text/html" } }) : new Response("", { headers: {
+			"Content-Type": "text/plain",
+			Link: `<${url}>; rel="alternate"; type="application/activity+json"`
+		} }), async (fetched) => {
+			await rejects(getDocumentLoader({ allowPrivateAddress: true })(start), (e) => isUnsupportedProtocolError(e, url));
+			deepStrictEqual(fetched, [start]);
+		});
+	});
+}
 //#endregion
 export {};

package/dist/tests/{request-D5w4xI1V.mjs → request-BE7XIrGw.mjs}

@@ -1,7 +1,7 @@
 import process from "node:process";
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.2.18-dev.2386+41abb5f5";
+var version = "2.2.18";
 //#endregion
 //#region src/request.ts
 /**

package/dist/tests/{request-CNVibwBp.cjs → request-BngWcP0t.cjs}

@@ -3,7 +3,7 @@ let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process);
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.2.18-dev.2386+41abb5f5";
+var version = "2.2.18";
 //#endregion
 //#region src/request.ts
 /**

package/dist/tests/request.test.cjs

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-Do9eywBl.cjs");
-const require_request = require("./request-CNVibwBp.cjs");
+const require_request = require("./request-BngWcP0t.cjs");
 let node_test = require("node:test");
 let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process);

package/dist/tests/request.test.mjs

@@ -1,4 +1,4 @@
-import { o as version, r as getUserAgent } from "./request-D5w4xI1V.mjs";
+import { o as version, r as getUserAgent } from "./request-BE7XIrGw.mjs";
 import { test } from "node:test";
 import process from "node:process";
 import { deepStrictEqual } from "node:assert";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/vocab-runtime",
-  "version": "2.2.18-dev.2386+41abb5f5",
+  "version": "2.2.18",
   "homepage": "https://fedify.dev/",
   "repository": {
     "type": "git",

package/src/docloader.test.ts

@@ -1103,3 +1103,93 @@ test("getDocumentLoader() rejects cancellation before fetching", async () => {
     fetchMock.hardReset();
   }
 });
+
+const unsupportedUrls = [
+  "ftp://example.com/collection",
+  "file:///collection",
+  `data:application/ld+json,${
+    encodeURIComponent(JSON.stringify({ id: "https://example.com/data" }))
+  }`,
+];
+
+function isUnsupportedProtocolError(error: unknown, url: string): boolean {
+  return error instanceof UrlError &&
+    error.message === `Unsupported protocol: ${new URL(url).protocol}` &&
+    error.reason === "disallowed";
+}
+
+async function withFetchStub(
+  respond: (url: string) => Response,
+  callback: (fetched: string[]) => Promise<void>,
+): Promise<void> {
+  const fetched: string[] = [];
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = (input: RequestInfo | URL) => {
+    const url = input instanceof Request ? input.url : String(input);
+    fetched.push(url);
+    return Promise.resolve(respond(url));
+  };
+  try {
+    await callback(fetched);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+}
+
+for (const url of unsupportedUrls) {
+  const scheme = new URL(url).protocol;
+
+  test(`getDocumentLoader() rejects ${scheme} URLs with private addresses allowed before fetching`, async () => {
+    await withFetchStub(() => Response.json({}), async (fetched) => {
+      await rejects(
+        getDocumentLoader({ allowPrivateAddress: true })(url),
+        (e) => isUnsupportedProtocolError(e, url),
+      );
+      deepStrictEqual(fetched, []);
+    });
+  });
+
+  test(`getDocumentLoader() rejects redirects to ${scheme} URLs with private addresses allowed`, async () => {
+    const start = "https://example.com/redirect-to-unsupported";
+    await withFetchStub(() => Response.redirect(url, 302), async (fetched) => {
+      await rejects(
+        getDocumentLoader({ allowPrivateAddress: true })(start),
+        (e) => isUnsupportedProtocolError(e, url),
+      );
+      deepStrictEqual(fetched, [start]);
+    });
+  });
+
+  for (const html of [false, true]) {
+    test(
+      `getDocumentLoader() rejects ${
+        html ? "HTML" : "Link header"
+      } alternates to ${scheme} URLs with private addresses allowed`,
+      async () => {
+        const start = "https://example.com/alternate-to-unsupported";
+        await withFetchStub(
+          () =>
+            html
+              ? new Response(
+                `<link rel="alternate" type="application/activity+json" href="${url}">`,
+                { headers: { "Content-Type": "text/html" } },
+              )
+              : new Response("", {
+                headers: {
+                  "Content-Type": "text/plain",
+                  Link:
+                    `<${url}>; rel="alternate"; type="application/activity+json"`,
+                },
+              }),
+          async (fetched) => {
+            await rejects(
+              getDocumentLoader({ allowPrivateAddress: true })(start),
+              (e) => isUnsupportedProtocolError(e, url),
+            );
+            deepStrictEqual(fetched, [start]);
+          },
+        );
+      },
+    );
+  }
+}

package/src/docloader.ts

@@ -311,7 +311,11 @@ export function getDocumentLoader(
     visited = new Set<string>(),
   ): Promise<RemoteDocument> {
     options?.signal?.throwIfAborted();
-    const currentUrl = new URL(url).href;
+    const parsedUrl = new URL(url);
+    if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+      throw new UrlError(`Unsupported protocol: ${parsedUrl.protocol}`);
+    }
+    const currentUrl = parsedUrl.href;
     if (!skipPreloadedContexts && currentUrl in preloadedContexts) {
       logger.debug("Using preloaded context: {url}.", { url: currentUrl });
       return {