@fedify/vocab-runtime 2.4.0-dev.1570 → 2.4.0-dev.1573

package/dist/tests/url.test.cjs

@@ -1,8 +1,111 @@
 require("./chunk-C2EiDwsr.cjs");
-const require_url = require("./url-C20FhC7p.cjs");
+const require_url = require("./url-2XwVbUS_.cjs");
 let node_assert = require("node:assert");
 let node_test = require("node:test");
 //#region src/url.test.ts
+(0, node_test.test)("parseIri() accepts portable ActivityPub URI schemes", () => {
+	for (const iri of [
+		"ap://did:key:z6Mkabc/actor",
+		"ap://did%3Akey%3Az6Mkabc/actor",
+		"ap+ef61://did:key:z6Mkabc/actor",
+		"ap+ef61://did%3Akey%3Az6Mkabc/actor",
+		"AP+EF61://did:key:z6Mkabc/actor"
+	]) (0, node_assert.deepStrictEqual)(require_url.parseIri(iri), new URL("ap+ef61://did%3Akey%3Az6Mkabc/actor"));
+});
+(0, node_test.test)("parseIri() accepts DID schemes case-insensitively", () => {
+	for (const iri of ["ap://DID:key:z6Mkabc/actor", "ap://DID%3Akey%3Az6Mkabc/actor"]) (0, node_assert.deepStrictEqual)(require_url.parseIri(iri), new URL("ap+ef61://DID%3Akey%3Az6Mkabc/actor"));
+});
+(0, node_test.test)("parseIri() accepts DID method names that start with digits", () => {
+	(0, node_assert.deepStrictEqual)(require_url.parseIri("ap://did:3:abc/actor"), new URL("ap+ef61://did%3A3%3Aabc/actor"));
+});
+(0, node_test.test)("parseIri() accepts hyphens in DID method-specific IDs", () => {
+	(0, node_assert.deepStrictEqual)(require_url.parseIri("ap+ef61://did:web:foo-bar.example/actor"), new URL("ap+ef61://did%3Aweb%3Afoo-bar.example/actor"));
+});
+(0, node_test.test)("parseIri() preserves existing URL parsing behavior", () => {
+	(0, node_assert.deepStrictEqual)(require_url.parseIri("/actor", new URL("https://example.com/users/alice")), new URL("https://example.com/actor"));
+	(0, node_assert.deepStrictEqual)(require_url.parseIri("at://did:plc:example/record"), new URL("at://did%3Aplc%3Aexample/record"));
+	(0, node_assert.throws)(() => require_url.parseIri("ap://not-a-did/actor"), TypeError);
+});
+(0, node_test.test)("parseJsonLdId() parses JSON-LD ids", () => {
+	(0, node_assert.deepStrictEqual)(require_url.parseJsonLdId(void 0), void 0);
+	(0, node_assert.deepStrictEqual)(require_url.parseJsonLdId("_:blank"), void 0);
+	(0, node_assert.deepStrictEqual)(require_url.parseJsonLdId("/actor", new URL("https://example.com/users/alice")), new URL("https://example.com/actor"));
+	(0, node_assert.deepStrictEqual)(require_url.parseJsonLdId("ap://did:key:z6Mkabc/actor"), new URL("ap+ef61://did%3Akey%3Az6Mkabc/actor"));
+	(0, node_assert.throws)(() => require_url.parseJsonLdId("/actor"), {
+		name: "TypeError",
+		message: "Invalid @id: /actor"
+	});
+});
+(0, node_test.test)("parseIri() resolves relative IRIs against portable string bases", () => {
+	(0, node_assert.deepStrictEqual)(require_url.parseIri("/actor", "ap://did:key:z6Mkabc/objects/1"), new URL("ap+ef61://did%3Akey%3Az6Mkabc/actor"));
+	(0, node_assert.deepStrictEqual)(require_url.parseIri("attachments/1", "ap://did:key:z6Mkabc/objects/1"), new URL("ap+ef61://did%3Akey%3Az6Mkabc/objects/attachments/1"));
+	(0, node_assert.throws)(() => require_url.parseIri("//example.com/outbox", "ap://did:key:z6Mkabc/objects/1"), TypeError);
+});
+(0, node_test.test)("parseIri() resolves relative IRIs against at:// string bases", () => {
+	(0, node_assert.deepStrictEqual)(require_url.parseIri("/record", "at://did:plc:example/collection/item"), new URL("at://did%3Aplc%3Aexample/record"));
+	(0, node_assert.deepStrictEqual)(require_url.parseIri("reply", "at://did:plc:example/collection/item"), new URL("at://did%3Aplc%3Aexample/collection/reply"));
+	(0, node_assert.deepStrictEqual)(require_url.parseIri("reply", "at://did%3Aplc%3Aexample/collection/item"), new URL("at://did%3Aplc%3Aexample/collection/reply"));
+});
+(0, node_test.test)("parseIri() rejects portable IRIs without paths", () => {
+	(0, node_assert.throws)(() => require_url.parseIri("ap://did:key:z6Mkabc"), TypeError);
+	(0, node_assert.throws)(() => require_url.parseIri("ap://did:key:z6Mkabc?gateways=https%3A%2F%2Fserver.example"), TypeError);
+	(0, node_assert.throws)(() => require_url.parseIri("ap://did:key:z6Mkabc#actor"), TypeError);
+});
+(0, node_test.test)("parseIri() rejects malformed portable DID authorities", () => {
+	for (const iri of [
+		"ap://did:/actor",
+		"ap://did:key/actor",
+		"ap://did%3Akey%3Aabc%25zz/actor",
+		"ap://did:key:abc%25zz/actor"
+	]) (0, node_assert.throws)(() => require_url.parseIri(iri), TypeError);
+});
+(0, node_test.test)("haveSameIriOrigin() compares portable IRI authorities", () => {
+	(0, node_assert.ok)(require_url.haveSameIriOrigin(require_url.parseIri("ap://did:key:z6Mkabc/actor"), require_url.parseIri("ap://did:key:z6Mkabc/outbox")));
+	(0, node_assert.ok)(require_url.haveSameIriOrigin(new URL("ap://did%3Akey%3Az6Mkabc/actor"), new URL("ap+ef61://did%3Akey%3Az6Mkabc/outbox")));
+	(0, node_assert.ok)(require_url.haveSameIriOrigin(require_url.parseIri("ap://DID:key:z6Mkabc/actor"), require_url.parseIri("ap://did:key:z6Mkabc/outbox")));
+	(0, node_assert.ok)(require_url.haveSameIriOrigin(new URL("ap+ef61://DID%3Akey%3Az6Mkabc/actor"), new URL("ap+ef61://did%3Akey%3Az6Mkabc/outbox")));
+	(0, node_assert.ok)(!require_url.haveSameIriOrigin(require_url.parseIri("ap://did:key:z6Mkabc/actor"), require_url.parseIri("ap://did:key:z6Mkdef/actor")));
+});
+(0, node_test.test)("parseIri() normalizes portable URL instances", () => {
+	(0, node_assert.deepStrictEqual)(require_url.parseIri(new URL("ap+ef61://did%3Aexample%3Aabc%2Fdef/actor")), new URL("ap+ef61://did%3Aexample%3Aabc%252Fdef/actor"));
+	(0, node_assert.throws)(() => require_url.parseIri("ap+ef61://not-a-did/actor"), TypeError);
+});
+(0, node_test.test)("formatIri() emits canonical portable ActivityPub URI syntax", () => {
+	const cases = [new URL("ap://did%3Akey%3Az6Mkabc/actor"), new URL("ap+ef61://did%3Akey%3Az6Mkabc/actor")];
+	for (const iri of cases) (0, node_assert.deepStrictEqual)(require_url.formatIri(iri), "ap+ef61://did:key:z6Mkabc/actor");
+	(0, node_assert.deepStrictEqual)(require_url.formatIri(new URL("https://example.com/actor")), "https://example.com/actor");
+	(0, node_assert.deepStrictEqual)(require_url.formatIri("/actor"), "/actor");
+});
+(0, node_test.test)("formatIri() preserves DID authority pct-encoded delimiters", () => {
+	const parsed = require_url.parseIri("ap://did:example:abc%2Fdef/actor");
+	(0, node_assert.deepStrictEqual)(parsed, new URL("ap+ef61://did%3Aexample%3Aabc%252Fdef/actor"));
+	(0, node_assert.deepStrictEqual)(require_url.formatIri(parsed), "ap+ef61://did:example:abc%2Fdef/actor");
+	(0, node_assert.deepStrictEqual)(require_url.parseIri(require_url.formatIri(parsed)), parsed);
+	(0, node_assert.deepStrictEqual)(require_url.formatIri(new URL("ap+ef61://did%3Aexample%3Aabc%2Fdef/actor")), "ap+ef61://did:example:abc%2Fdef/actor");
+});
+(0, node_test.test)("parseIri() normalizes equivalent encoded DID authorities", () => {
+	(0, node_assert.deepStrictEqual)(require_url.parseIri("ap://did:example:abc%252Fdef/actor"), require_url.parseIri("ap://did%3Aexample%3Aabc%252Fdef/actor"));
+});
+(0, node_test.test)("formatIri() preserves DID-internal pct-encoded authority characters", () => {
+	const parsed = require_url.parseIri("ap://did:web:example.com%3A3000/actor");
+	(0, node_assert.deepStrictEqual)(parsed, new URL("ap+ef61://did%3Aweb%3Aexample.com%253A3000/actor"));
+	(0, node_assert.deepStrictEqual)(require_url.formatIri(parsed), "ap+ef61://did:web:example.com%3A3000/actor");
+});
+(0, node_test.test)("parseIri() accepts portable DID URLs with encoded DID delimiters", () => {
+	const parsed = require_url.parseIri("ap://did:web:example.com%3A3000/u/1");
+	(0, node_assert.deepStrictEqual)(parsed, new URL("ap+ef61://did%3Aweb%3Aexample.com%253A3000/u/1"));
+	(0, node_assert.deepStrictEqual)(require_url.formatIri(parsed), "ap+ef61://did:web:example.com%3A3000/u/1");
+});
+(0, node_test.test)("parseIri() decodes pct-encoded DID delimiters in order", () => {
+	const parsed = require_url.parseIri("ap://did%3Aweb%3Aexample.com%253A3000/u/1");
+	(0, node_assert.deepStrictEqual)(parsed, new URL("ap+ef61://did%3Aweb%3Aexample.com%253A3000/u/1"));
+	(0, node_assert.deepStrictEqual)(require_url.formatIri(parsed), "ap+ef61://did:web:example.com%3A3000/u/1");
+});
+(0, node_test.test)("parseIri() preserves encoded percent signs while decoding delimiters", () => {
+	const parsed = require_url.parseIri("ap://did%3Aweb%3Aexample.com%2500/u/1");
+	(0, node_assert.deepStrictEqual)(parsed, new URL("ap+ef61://did%3Aweb%3Aexample.com%2500/u/1"));
+	(0, node_assert.deepStrictEqual)(require_url.formatIri(parsed), "ap+ef61://did:web:example.com%00/u/1");
+});
 (0, node_test.test)("validatePublicUrl()", async () => {
 	await (0, node_assert.rejects)(() => require_url.validatePublicUrl("ftp://localhost"), require_url.UrlError);
 	await (0, node_assert.rejects)(() => require_url.validatePublicUrl("data:text/plain;base64,SGVsbG8sIFdvcmxkIQ=="), require_url.UrlError);

package/dist/tests/url.test.mjs

@@ -1,7 +1,110 @@
-import { a as validatePublicUrl, i as isValidPublicIPv6Address, n as expandIPv6Address, r as isValidPublicIPv4Address, t as UrlError } from "./url-m9Qzxy-Y.mjs";
-import { deepStrictEqual, ok, rejects } from "node:assert";
+import { a as isValidPublicIPv4Address, c as parseJsonLdId, i as haveSameIriOrigin, l as validatePublicUrl, n as expandIPv6Address, o as isValidPublicIPv6Address, r as formatIri, s as parseIri, t as UrlError } from "./url-YWJbnRlf.mjs";
+import { deepStrictEqual, ok, rejects, throws } from "node:assert";
 import { test } from "node:test";
 //#region src/url.test.ts
+test("parseIri() accepts portable ActivityPub URI schemes", () => {
+	for (const iri of [
+		"ap://did:key:z6Mkabc/actor",
+		"ap://did%3Akey%3Az6Mkabc/actor",
+		"ap+ef61://did:key:z6Mkabc/actor",
+		"ap+ef61://did%3Akey%3Az6Mkabc/actor",
+		"AP+EF61://did:key:z6Mkabc/actor"
+	]) deepStrictEqual(parseIri(iri), new URL("ap+ef61://did%3Akey%3Az6Mkabc/actor"));
+});
+test("parseIri() accepts DID schemes case-insensitively", () => {
+	for (const iri of ["ap://DID:key:z6Mkabc/actor", "ap://DID%3Akey%3Az6Mkabc/actor"]) deepStrictEqual(parseIri(iri), new URL("ap+ef61://DID%3Akey%3Az6Mkabc/actor"));
+});
+test("parseIri() accepts DID method names that start with digits", () => {
+	deepStrictEqual(parseIri("ap://did:3:abc/actor"), new URL("ap+ef61://did%3A3%3Aabc/actor"));
+});
+test("parseIri() accepts hyphens in DID method-specific IDs", () => {
+	deepStrictEqual(parseIri("ap+ef61://did:web:foo-bar.example/actor"), new URL("ap+ef61://did%3Aweb%3Afoo-bar.example/actor"));
+});
+test("parseIri() preserves existing URL parsing behavior", () => {
+	deepStrictEqual(parseIri("/actor", new URL("https://example.com/users/alice")), new URL("https://example.com/actor"));
+	deepStrictEqual(parseIri("at://did:plc:example/record"), new URL("at://did%3Aplc%3Aexample/record"));
+	throws(() => parseIri("ap://not-a-did/actor"), TypeError);
+});
+test("parseJsonLdId() parses JSON-LD ids", () => {
+	deepStrictEqual(parseJsonLdId(void 0), void 0);
+	deepStrictEqual(parseJsonLdId("_:blank"), void 0);
+	deepStrictEqual(parseJsonLdId("/actor", new URL("https://example.com/users/alice")), new URL("https://example.com/actor"));
+	deepStrictEqual(parseJsonLdId("ap://did:key:z6Mkabc/actor"), new URL("ap+ef61://did%3Akey%3Az6Mkabc/actor"));
+	throws(() => parseJsonLdId("/actor"), {
+		name: "TypeError",
+		message: "Invalid @id: /actor"
+	});
+});
+test("parseIri() resolves relative IRIs against portable string bases", () => {
+	deepStrictEqual(parseIri("/actor", "ap://did:key:z6Mkabc/objects/1"), new URL("ap+ef61://did%3Akey%3Az6Mkabc/actor"));
+	deepStrictEqual(parseIri("attachments/1", "ap://did:key:z6Mkabc/objects/1"), new URL("ap+ef61://did%3Akey%3Az6Mkabc/objects/attachments/1"));
+	throws(() => parseIri("//example.com/outbox", "ap://did:key:z6Mkabc/objects/1"), TypeError);
+});
+test("parseIri() resolves relative IRIs against at:// string bases", () => {
+	deepStrictEqual(parseIri("/record", "at://did:plc:example/collection/item"), new URL("at://did%3Aplc%3Aexample/record"));
+	deepStrictEqual(parseIri("reply", "at://did:plc:example/collection/item"), new URL("at://did%3Aplc%3Aexample/collection/reply"));
+	deepStrictEqual(parseIri("reply", "at://did%3Aplc%3Aexample/collection/item"), new URL("at://did%3Aplc%3Aexample/collection/reply"));
+});
+test("parseIri() rejects portable IRIs without paths", () => {
+	throws(() => parseIri("ap://did:key:z6Mkabc"), TypeError);
+	throws(() => parseIri("ap://did:key:z6Mkabc?gateways=https%3A%2F%2Fserver.example"), TypeError);
+	throws(() => parseIri("ap://did:key:z6Mkabc#actor"), TypeError);
+});
+test("parseIri() rejects malformed portable DID authorities", () => {
+	for (const iri of [
+		"ap://did:/actor",
+		"ap://did:key/actor",
+		"ap://did%3Akey%3Aabc%25zz/actor",
+		"ap://did:key:abc%25zz/actor"
+	]) throws(() => parseIri(iri), TypeError);
+});
+test("haveSameIriOrigin() compares portable IRI authorities", () => {
+	ok(haveSameIriOrigin(parseIri("ap://did:key:z6Mkabc/actor"), parseIri("ap://did:key:z6Mkabc/outbox")));
+	ok(haveSameIriOrigin(new URL("ap://did%3Akey%3Az6Mkabc/actor"), new URL("ap+ef61://did%3Akey%3Az6Mkabc/outbox")));
+	ok(haveSameIriOrigin(parseIri("ap://DID:key:z6Mkabc/actor"), parseIri("ap://did:key:z6Mkabc/outbox")));
+	ok(haveSameIriOrigin(new URL("ap+ef61://DID%3Akey%3Az6Mkabc/actor"), new URL("ap+ef61://did%3Akey%3Az6Mkabc/outbox")));
+	ok(!haveSameIriOrigin(parseIri("ap://did:key:z6Mkabc/actor"), parseIri("ap://did:key:z6Mkdef/actor")));
+});
+test("parseIri() normalizes portable URL instances", () => {
+	deepStrictEqual(parseIri(new URL("ap+ef61://did%3Aexample%3Aabc%2Fdef/actor")), new URL("ap+ef61://did%3Aexample%3Aabc%252Fdef/actor"));
+	throws(() => parseIri("ap+ef61://not-a-did/actor"), TypeError);
+});
+test("formatIri() emits canonical portable ActivityPub URI syntax", () => {
+	const cases = [new URL("ap://did%3Akey%3Az6Mkabc/actor"), new URL("ap+ef61://did%3Akey%3Az6Mkabc/actor")];
+	for (const iri of cases) deepStrictEqual(formatIri(iri), "ap+ef61://did:key:z6Mkabc/actor");
+	deepStrictEqual(formatIri(new URL("https://example.com/actor")), "https://example.com/actor");
+	deepStrictEqual(formatIri("/actor"), "/actor");
+});
+test("formatIri() preserves DID authority pct-encoded delimiters", () => {
+	const parsed = parseIri("ap://did:example:abc%2Fdef/actor");
+	deepStrictEqual(parsed, new URL("ap+ef61://did%3Aexample%3Aabc%252Fdef/actor"));
+	deepStrictEqual(formatIri(parsed), "ap+ef61://did:example:abc%2Fdef/actor");
+	deepStrictEqual(parseIri(formatIri(parsed)), parsed);
+	deepStrictEqual(formatIri(new URL("ap+ef61://did%3Aexample%3Aabc%2Fdef/actor")), "ap+ef61://did:example:abc%2Fdef/actor");
+});
+test("parseIri() normalizes equivalent encoded DID authorities", () => {
+	deepStrictEqual(parseIri("ap://did:example:abc%252Fdef/actor"), parseIri("ap://did%3Aexample%3Aabc%252Fdef/actor"));
+});
+test("formatIri() preserves DID-internal pct-encoded authority characters", () => {
+	const parsed = parseIri("ap://did:web:example.com%3A3000/actor");
+	deepStrictEqual(parsed, new URL("ap+ef61://did%3Aweb%3Aexample.com%253A3000/actor"));
+	deepStrictEqual(formatIri(parsed), "ap+ef61://did:web:example.com%3A3000/actor");
+});
+test("parseIri() accepts portable DID URLs with encoded DID delimiters", () => {
+	const parsed = parseIri("ap://did:web:example.com%3A3000/u/1");
+	deepStrictEqual(parsed, new URL("ap+ef61://did%3Aweb%3Aexample.com%253A3000/u/1"));
+	deepStrictEqual(formatIri(parsed), "ap+ef61://did:web:example.com%3A3000/u/1");
+});
+test("parseIri() decodes pct-encoded DID delimiters in order", () => {
+	const parsed = parseIri("ap://did%3Aweb%3Aexample.com%253A3000/u/1");
+	deepStrictEqual(parsed, new URL("ap+ef61://did%3Aweb%3Aexample.com%253A3000/u/1"));
+	deepStrictEqual(formatIri(parsed), "ap+ef61://did:web:example.com%3A3000/u/1");
+});
+test("parseIri() preserves encoded percent signs while decoding delimiters", () => {
+	const parsed = parseIri("ap://did%3Aweb%3Aexample.com%2500/u/1");
+	deepStrictEqual(parsed, new URL("ap+ef61://did%3Aweb%3Aexample.com%2500/u/1"));
+	deepStrictEqual(formatIri(parsed), "ap+ef61://did:web:example.com%00/u/1");
+});
 test("validatePublicUrl()", async () => {
 	await rejects(() => validatePublicUrl("ftp://localhost"), UrlError);
 	await rejects(() => validatePublicUrl("data:text/plain;base64,SGVsbG8sIFdvcmxkIQ=="), UrlError);

package/dist/url-BAdyyqAa.cjs

@@ -0,0 +1,315 @@
+
+require("./chunk-M78iaK0I.cjs");
+let node_dns_promises = require("node:dns/promises");
+let node_net = require("node:net");
+//#region src/url.ts
+var UrlError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "UrlError";
+	}
+};
+const PORTABLE_IRI_PATTERN = /^(ap|ap\+ef61):\/\/([^/?#]*)([^?#]*)(\?[^#]*)?(#.*)?$/i;
+const INVALID_PERCENT_ENCODING_PATTERN = /%(?![0-9A-Fa-f]{2})/;
+const DID_SCHEME_PATTERN = /^did:/i;
+const DID_PATTERN = /^did:[a-z0-9]+:[-A-Za-z0-9._%]+(?::[-A-Za-z0-9._%]+)*$/i;
+/**
+* Parses a JSON-LD `@id` value as an IRI.
+*/
+function parseJsonLdId(id, base) {
+	if (id == null || id.startsWith("_:")) return void 0;
+	try {
+		return parseIri(id, base);
+	} catch {
+		throw new TypeError("Invalid @id: " + id);
+	}
+}
+/**
+* Parses an IRI as a URL, including FEP-ef61 portable ActivityPub IRIs.
+*/
+function parseIri(iri, base) {
+	if (iri instanceof URL) return normalizePortableUrl(iri) ?? new URL(iri.href);
+	const portable = parsePortableIri(iri);
+	if (portable != null) return portable;
+	base = normalizeBaseIri(base);
+	if (!URL.canParse(iri, base) && iri.startsWith("at://")) return parseAtUri(iri);
+	const parsed = new URL(iri, base);
+	return normalizePortableUrl(parsed) ?? parsed;
+}
+/**
+* Formats a URL as an IRI, including FEP-ef61 portable ActivityPub IRIs.
+*/
+function formatIri(iri) {
+	const parsed = parsePortableIri(iri instanceof URL ? iri.href : iri);
+	if (parsed == null) return iri instanceof URL ? iri.href : URL.canParse(iri) ? new URL(iri).href : iri;
+	return `ap+ef61://${decodePortableAuthority(parsed.host)}${parsed.pathname}${parsed.search}${parsed.hash}`;
+}
+/**
+* Checks whether two IRIs have the same origin.
+*/
+function haveSameIriOrigin(left, right) {
+	return getComparableIriOrigin(left) === getComparableIriOrigin(right);
+}
+function getComparableIriOrigin(iri) {
+	iri = normalizePortableUrl(iri) ?? iri;
+	if (iri.origin !== "null") return iri.origin;
+	if (iri.host !== "") {
+		const host = iri.protocol === "ap+ef61:" ? encodeURIComponent(decodePortableAuthority(iri.host).replace(DID_SCHEME_PATTERN, "did:")) : iri.host;
+		return `${iri.protocol}//${host}`;
+	}
+	return iri.href;
+}
+function parsePortableIri(iri) {
+	const match = iri.match(PORTABLE_IRI_PATTERN);
+	if (match == null) return null;
+	const authority = decodePortableAuthority(match[2]);
+	if (!DID_PATTERN.test(authority)) throw new TypeError("Invalid portable ActivityPub IRI authority.");
+	if (match[3] === "") throw new TypeError("Invalid portable ActivityPub IRI path.");
+	return new URL(`ap+ef61://${encodeURIComponent(authority)}${match[3]}${match[4] ?? ""}${match[5] ?? ""}`);
+}
+function normalizePortableUrl(iri) {
+	if (iri.protocol !== "ap:" && iri.protocol !== "ap+ef61:") return null;
+	return parsePortableIri(`ap+ef61://${iri.host}${iri.pathname}${iri.search}${iri.hash}`);
+}
+function normalizeBaseIri(base) {
+	if (base == null) return void 0;
+	if (base instanceof URL) return normalizePortableUrl(base) ?? base;
+	return parsePortableIri(base) ?? (base.startsWith("at://") && !URL.canParse(".", base) ? parseAtUri(base) : base);
+}
+function decodePortableAuthority(authority) {
+	if (INVALID_PERCENT_ENCODING_PATTERN.test(authority)) throw new TypeError("Invalid portable ActivityPub IRI authority.");
+	if (DID_SCHEME_PATTERN.test(authority)) {
+		const decoded = authority.replace(/%25/gi, "%");
+		if (INVALID_PERCENT_ENCODING_PATTERN.test(decoded)) throw new TypeError("Invalid portable ActivityPub IRI authority.");
+		return decoded;
+	}
+	const decoded = authority.replace(/%(25|3A)/gi, (match) => match.toLowerCase() === "%3a" ? ":" : "%");
+	if (INVALID_PERCENT_ENCODING_PATTERN.test(decoded)) throw new TypeError("Invalid portable ActivityPub IRI authority.");
+	return decoded;
+}
+function parseAtUri(uri) {
+	const index = uri.indexOf("/", 5);
+	const authority = index >= 0 ? uri.slice(5, index) : uri.slice(5);
+	const path = index >= 0 ? uri.slice(index) : "";
+	return new URL("at://" + encodeURIComponent(authority) + path);
+}
+/**
+* Validates a URL to prevent SSRF attacks.
+*/
+async function validatePublicUrl(url) {
+	const parsed = new URL(url);
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new UrlError(`Unsupported protocol: ${parsed.protocol}`);
+	let hostname = parsed.hostname;
+	if (hostname.startsWith("[") && hostname.endsWith("]")) hostname = hostname.slice(1, -1);
+	if (hostname === "localhost") throw new UrlError("Localhost is not allowed");
+	const hostnameFamily = (0, node_net.isIP)(hostname);
+	if (hostnameFamily !== 0) {
+		validatePublicIpAddress(hostname, hostnameFamily);
+		return;
+	}
+	if ("Deno" in globalThis && !(0, node_net.isIP)(hostname)) {
+		if ((await Deno.permissions.query({ name: "net" })).state !== "granted") return;
+	}
+	if ("Bun" in globalThis) {
+		if (hostname === "example.com" || hostname.endsWith(".example.com")) return;
+		else if (hostname === "fedify-test.internal") throw new UrlError("Invalid or private address: fedify-test.internal");
+	}
+	let addresses;
+	try {
+		addresses = await (0, node_dns_promises.lookup)(hostname, { all: true });
+	} catch {
+		addresses = [];
+	}
+	for (const { address, family } of addresses) validatePublicIpAddress(address, family);
+}
+function validatePublicIpAddress(address, family) {
+	if (family === 4 && isValidPublicIPv4Address(address) || family === 6 && isValidPublicIPv6Address(address)) return;
+	throw new UrlError(`Invalid or private address: ${address}`);
+}
+function isValidPublicIPv4Address(address) {
+	const parts = parseIPv4Address(address);
+	if (parts == null) return false;
+	const value = ipv4PartsToNumber(parts);
+	return !nonPublicIPv4Prefixes.some(({ base, prefix }) => matchesIPv4Prefix(value, base, prefix));
+}
+function isValidPublicIPv6Address(address) {
+	const words = parseIPv6Address(address);
+	if (words == null) return false;
+	if (nonPublicIPv6Prefixes.some(({ words: prefixWords, prefix }) => matchesIPv6Prefix(words, prefixWords, prefix))) return false;
+	for (const { extractIPv4, prefix, words: prefixWords } of ipv6WithIPv4Prefixes) {
+		if (!matchesIPv6Prefix(words, prefixWords, prefix)) continue;
+		const ipv4Address = extractIPv4(words);
+		if (ipv4Address != null && !isValidPublicIPv4Address(ipv4Address)) return false;
+	}
+	return true;
+}
+function expandIPv6Address(address) {
+	address = address.toLowerCase();
+	const ipv4Delimiter = address.lastIndexOf(":");
+	if (address.includes(".") && ipv4Delimiter >= 0) {
+		const ipv4Parts = parseIPv4Address(address.substring(ipv4Delimiter + 1));
+		if (ipv4Parts == null) return address;
+		const high = (ipv4Parts[0] << 8) + ipv4Parts[1];
+		const low = (ipv4Parts[2] << 8) + ipv4Parts[3];
+		address = address.substring(0, ipv4Delimiter + 1) + high.toString(16) + ":" + low.toString(16);
+	}
+	if (address === "::") return "0000:0000:0000:0000:0000:0000:0000:0000";
+	if (address.startsWith("::")) address = "0000" + address;
+	if (address.endsWith("::")) address = address + "0000";
+	address = address.replace("::", ":0000".repeat(8 - (address.match(/:/g) || []).length) + ":");
+	return address.split(":").map((part) => part.padStart(4, "0")).join(":");
+}
+const nonPublicIPv4Prefixes = [
+	ipv4Prefix("0.0.0.0/8", "RFC 6890"),
+	ipv4Prefix("10.0.0.0/8", "RFC 1918"),
+	ipv4Prefix("100.64.0.0/10", "RFC 6598"),
+	ipv4Prefix("127.0.0.0/8", "RFC 1122"),
+	ipv4Prefix("169.254.0.0/16", "RFC 3927"),
+	ipv4Prefix("172.16.0.0/12", "RFC 1918"),
+	ipv4Prefix("192.0.0.0/24", "RFC 6890"),
+	ipv4Prefix("192.0.2.0/24", "RFC 5737"),
+	ipv4Prefix("192.88.99.0/24", "RFC 7526"),
+	ipv4Prefix("192.168.0.0/16", "RFC 1918"),
+	ipv4Prefix("198.18.0.0/15", "RFC 2544"),
+	ipv4Prefix("198.51.100.0/24", "RFC 5737"),
+	ipv4Prefix("203.0.113.0/24", "RFC 5737"),
+	ipv4Prefix("224.0.0.0/4", "RFC 5771"),
+	ipv4Prefix("240.0.0.0/4", "RFC 1112")
+];
+const nonPublicIPv6Prefixes = [
+	ipv6Prefix("::/16", "RFC 4291"),
+	ipv6Prefix("2001::/32", "RFC 4380"),
+	ipv6Prefix("2002::/16", "RFC 3056"),
+	ipv6Prefix("64:ff9b:1::/48", "RFC 8215"),
+	ipv6Prefix("fc00::/7", "RFC 4193"),
+	ipv6Prefix("fe80::/10", "RFC 4291"),
+	ipv6Prefix("ff00::/8", "RFC 4291")
+];
+const ipv6WithIPv4Prefixes = [{
+	...ipv6Prefix("64:ff9b::/96", "RFC 6052"),
+	extractIPv4: (words) => ipv4FromWords(words[6], words[7])
+}];
+function ipv4Prefix(cidr, rfc) {
+	const [address, prefixText] = cidr.split("/");
+	const prefix = parseInt(prefixText, 10);
+	const parts = parseIPv4Address(address);
+	if (parts == null || !Number.isInteger(prefix) || prefix < 0 || prefix > 32) throw new Error(`Invalid IPv4 prefix: ${cidr}`);
+	return {
+		cidr,
+		base: ipv4PartsToNumber(parts),
+		prefix,
+		rfc
+	};
+}
+function ipv6Prefix(cidr, rfc) {
+	const [address, prefixText] = cidr.split("/");
+	const prefix = parseInt(prefixText, 10);
+	const words = parseIPv6Address(address);
+	if (words == null || !Number.isInteger(prefix) || prefix < 0 || prefix > 128) throw new Error(`Invalid IPv6 prefix: ${cidr}`);
+	return {
+		cidr,
+		words,
+		prefix,
+		rfc
+	};
+}
+function parseIPv4Address(address) {
+	const parts = address.split(".").map((part) => {
+		if (!/^\d+$/.test(part)) return NaN;
+		return parseInt(part, 10);
+	});
+	if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) return null;
+	return parts;
+}
+function parseIPv6Address(address) {
+	const parts = expandIPv6Address(address).split(":");
+	if (parts.length !== 8) return null;
+	const words = parts.map((part) => {
+		if (!/^[0-9a-f]{1,4}$/i.test(part)) return NaN;
+		return parseInt(part, 16);
+	});
+	if (words.some((word) => !Number.isInteger(word) || word < 0 || word > 65535)) return null;
+	return words;
+}
+function ipv4PartsToNumber(parts) {
+	return parts[0] * 2 ** 24 + parts[1] * 2 ** 16 + parts[2] * 2 ** 8 + parts[3];
+}
+function ipv4FromWords(highWord, lowWord) {
+	return [
+		highWord >> 8,
+		highWord & 255,
+		lowWord >> 8,
+		lowWord & 255
+	].join(".");
+}
+function matchesIPv4Prefix(address, prefixBase, prefixLength) {
+	const blockSize = 2 ** (32 - prefixLength);
+	return Math.floor(address / blockSize) === Math.floor(prefixBase / blockSize);
+}
+function matchesIPv6Prefix(address, prefixWords, prefixLength) {
+	let remaining = prefixLength;
+	for (let i = 0; i < 8 && remaining > 0; i++) if (remaining >= 16) {
+		if (address[i] !== prefixWords[i]) return false;
+		remaining -= 16;
+	} else {
+		const mask = 65535 << 16 - remaining & 65535;
+		if ((address[i] & mask) !== (prefixWords[i] & mask)) return false;
+		remaining = 0;
+	}
+	return true;
+}
+//#endregion
+Object.defineProperty(exports, "UrlError", {
+	enumerable: true,
+	get: function() {
+		return UrlError;
+	}
+});
+Object.defineProperty(exports, "expandIPv6Address", {
+	enumerable: true,
+	get: function() {
+		return expandIPv6Address;
+	}
+});
+Object.defineProperty(exports, "formatIri", {
+	enumerable: true,
+	get: function() {
+		return formatIri;
+	}
+});
+Object.defineProperty(exports, "haveSameIriOrigin", {
+	enumerable: true,
+	get: function() {
+		return haveSameIriOrigin;
+	}
+});
+Object.defineProperty(exports, "isValidPublicIPv4Address", {
+	enumerable: true,
+	get: function() {
+		return isValidPublicIPv4Address;
+	}
+});
+Object.defineProperty(exports, "isValidPublicIPv6Address", {
+	enumerable: true,
+	get: function() {
+		return isValidPublicIPv6Address;
+	}
+});
+Object.defineProperty(exports, "parseIri", {
+	enumerable: true,
+	get: function() {
+		return parseIri;
+	}
+});
+Object.defineProperty(exports, "parseJsonLdId", {
+	enumerable: true,
+	get: function() {
+		return parseJsonLdId;
+	}
+});
+Object.defineProperty(exports, "validatePublicUrl", {
+	enumerable: true,
+	get: function() {
+		return validatePublicUrl;
+	}
+});