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

package/dist/tests/{key-CrrK9mYh.mjs → key-CDGDH_vC.mjs}

@@ -45,6 +45,11 @@ const algorithms = {
 	},
 	"1.3.101.112": "Ed25519"
 };
+const DID_KEY_PREFIX = "did:key:";
+const ED25519_PUBLIC_KEY_MULTICODEC = 237;
+const ED25519_PUBLIC_KEY_LENGTH = 32;
+const DID_KEY_PATTERN = /^did:key:([^/?#]+)$/;
+const DID_KEY_VERIFICATION_METHOD_PATTERN = /^did:key:([^/?#]+)#([^/?#]+)$/;
 /**
 * Imports a PEM-SPKI formatted public key.
 * @param pem The PEM-SPKI formatted public key.
@@ -106,6 +111,69 @@ const PKCS1_HEADER = /^\s*-----BEGIN\s+RSA\s+PUBLIC\s+KEY-----\s*\n/;
 function importPem(pem) {
 	return PKCS1_HEADER.test(pem) ? importPkcs1(pem) : importSpki(pem);
 }
+function decodeEd25519DidKeyMultibase(multibaseKey) {
+	if (!multibaseKey.startsWith("z")) throw new TypeError("did:key must use base58-btc Multibase encoding.");
+	let decoded;
+	try {
+		decoded = decodeMultibase(multibaseKey);
+	} catch (error) {
+		throw new TypeError("Invalid did:key Multibase encoding.", { cause: error });
+	}
+	const { code } = getMulticodecPrefix(decoded);
+	if (code !== ED25519_PUBLIC_KEY_MULTICODEC) throw new TypeError("Unsupported did:key type: 0x" + code.toString(16));
+	const content = removeMulticodecPrefix(decoded);
+	if (content.length !== ED25519_PUBLIC_KEY_LENGTH) throw new TypeError("Invalid Ed25519 did:key length.");
+	return content;
+}
+/**
+* Imports an Ed25519 `did:key` DID.
+*
+* @param did The `did:key` DID.
+* @returns The imported Ed25519 public key.
+* @throws {TypeError} If the DID is malformed or uses an unsupported key type.
+* @since 2.4.0
+*/
+async function importDidKey(did) {
+	const match = (did instanceof URL ? did.href : did).match(DID_KEY_PATTERN);
+	if (match == null) throw new TypeError("Invalid did:key DID.");
+	const content = decodeEd25519DidKeyMultibase(match[1]);
+	return await crypto.subtle.importKey("raw", content.slice(), "Ed25519", true, ["verify"]);
+}
+/**
+* Exports an Ed25519 public key as a `did:key` DID.
+*
+* @param key The Ed25519 public key.
+* @returns The `did:key` DID.
+* @throws {TypeError} If the key is invalid or unsupported.
+* @since 2.4.0
+*/
+async function exportDidKey(key) {
+	if (key.algorithm.name !== "Ed25519") throw new TypeError("Unsupported key type: " + JSON.stringify(key.algorithm));
+	return DID_KEY_PREFIX + await exportMultibaseKey(key);
+}
+/**
+* Parses an Ed25519 `did:key` verification method DID URL.
+*
+* @param didUrl The `did:key` DID URL.
+* @returns The parsed verification method.
+* @throws {TypeError} If the DID URL is malformed, unsupported, or its
+*                     fragment does not identify the same key as the DID.
+* @since 2.4.0
+*/
+async function parseDidKeyVerificationMethod(didUrl) {
+	const didUrlString = didUrl instanceof URL ? didUrl.href : didUrl;
+	const match = didUrlString.match(DID_KEY_VERIFICATION_METHOD_PATTERN);
+	if (match == null) throw new TypeError("Invalid did:key verification method.");
+	const [, publicKeyMultibase, fragment] = match;
+	if (publicKeyMultibase !== fragment) throw new TypeError("Invalid did:key verification method fragment.");
+	const publicKey = await importDidKey(DID_KEY_PREFIX + publicKeyMultibase);
+	return {
+		id: new URL(didUrlString),
+		controller: new URL(DID_KEY_PREFIX + publicKeyMultibase),
+		publicKeyMultibase,
+		publicKey
+	};
+}
 /**
 * Imports a [Multibase]-encoded public key.
 *
@@ -169,4 +237,4 @@ async function exportMultibaseKey(key) {
 	return new TextDecoder().decode(encoded);
 }
 //#endregion
-export { importPkcs1 as a, importJwk as c, importPem as i, exportSpki as n, importSpki as o, importMultibaseKey as r, exportJwk as s, exportMultibaseKey as t };
+export { importMultibaseKey as a, importSpki as c, importJwk as d, importDidKey as i, parseDidKeyVerificationMethod as l, exportMultibaseKey as n, importPem as o, exportSpki as r, importPkcs1 as s, exportDidKey as t, exportJwk as u };

package/dist/tests/{key-pMmqUKuo.cjs → key-_wXwomh_.cjs}

@@ -46,6 +46,11 @@ const algorithms = {
 	},
 	"1.3.101.112": "Ed25519"
 };
+const DID_KEY_PREFIX = "did:key:";
+const ED25519_PUBLIC_KEY_MULTICODEC = 237;
+const ED25519_PUBLIC_KEY_LENGTH = 32;
+const DID_KEY_PATTERN = /^did:key:([^/?#]+)$/;
+const DID_KEY_VERIFICATION_METHOD_PATTERN = /^did:key:([^/?#]+)#([^/?#]+)$/;
 /**
 * Imports a PEM-SPKI formatted public key.
 * @param pem The PEM-SPKI formatted public key.
@@ -107,6 +112,69 @@ const PKCS1_HEADER = /^\s*-----BEGIN\s+RSA\s+PUBLIC\s+KEY-----\s*\n/;
 function importPem(pem) {
 	return PKCS1_HEADER.test(pem) ? importPkcs1(pem) : importSpki(pem);
 }
+function decodeEd25519DidKeyMultibase(multibaseKey) {
+	if (!multibaseKey.startsWith("z")) throw new TypeError("did:key must use base58-btc Multibase encoding.");
+	let decoded;
+	try {
+		decoded = require_multibase.decodeMultibase(multibaseKey);
+	} catch (error) {
+		throw new TypeError("Invalid did:key Multibase encoding.", { cause: error });
+	}
+	const { code } = require_multicodec.getMulticodecPrefix(decoded);
+	if (code !== ED25519_PUBLIC_KEY_MULTICODEC) throw new TypeError("Unsupported did:key type: 0x" + code.toString(16));
+	const content = require_multicodec.removeMulticodecPrefix(decoded);
+	if (content.length !== ED25519_PUBLIC_KEY_LENGTH) throw new TypeError("Invalid Ed25519 did:key length.");
+	return content;
+}
+/**
+* Imports an Ed25519 `did:key` DID.
+*
+* @param did The `did:key` DID.
+* @returns The imported Ed25519 public key.
+* @throws {TypeError} If the DID is malformed or uses an unsupported key type.
+* @since 2.4.0
+*/
+async function importDidKey(did) {
+	const match = (did instanceof URL ? did.href : did).match(DID_KEY_PATTERN);
+	if (match == null) throw new TypeError("Invalid did:key DID.");
+	const content = decodeEd25519DidKeyMultibase(match[1]);
+	return await crypto.subtle.importKey("raw", content.slice(), "Ed25519", true, ["verify"]);
+}
+/**
+* Exports an Ed25519 public key as a `did:key` DID.
+*
+* @param key The Ed25519 public key.
+* @returns The `did:key` DID.
+* @throws {TypeError} If the key is invalid or unsupported.
+* @since 2.4.0
+*/
+async function exportDidKey(key) {
+	if (key.algorithm.name !== "Ed25519") throw new TypeError("Unsupported key type: " + JSON.stringify(key.algorithm));
+	return DID_KEY_PREFIX + await exportMultibaseKey(key);
+}
+/**
+* Parses an Ed25519 `did:key` verification method DID URL.
+*
+* @param didUrl The `did:key` DID URL.
+* @returns The parsed verification method.
+* @throws {TypeError} If the DID URL is malformed, unsupported, or its
+*                     fragment does not identify the same key as the DID.
+* @since 2.4.0
+*/
+async function parseDidKeyVerificationMethod(didUrl) {
+	const didUrlString = didUrl instanceof URL ? didUrl.href : didUrl;
+	const match = didUrlString.match(DID_KEY_VERIFICATION_METHOD_PATTERN);
+	if (match == null) throw new TypeError("Invalid did:key verification method.");
+	const [, publicKeyMultibase, fragment] = match;
+	if (publicKeyMultibase !== fragment) throw new TypeError("Invalid did:key verification method fragment.");
+	const publicKey = await importDidKey(DID_KEY_PREFIX + publicKeyMultibase);
+	return {
+		id: new URL(didUrlString),
+		controller: new URL(DID_KEY_PREFIX + publicKeyMultibase),
+		publicKeyMultibase,
+		publicKey
+	};
+}
 /**
 * Imports a [Multibase]-encoded public key.
 *
@@ -170,6 +238,12 @@ async function exportMultibaseKey(key) {
 	return new TextDecoder().decode(encoded);
 }
 //#endregion
+Object.defineProperty(exports, "exportDidKey", {
+	enumerable: true,
+	get: function() {
+		return exportDidKey;
+	}
+});
 Object.defineProperty(exports, "exportJwk", {
 	enumerable: true,
 	get: function() {
@@ -188,6 +262,12 @@ Object.defineProperty(exports, "exportSpki", {
 		return exportSpki;
 	}
 });
+Object.defineProperty(exports, "importDidKey", {
+	enumerable: true,
+	get: function() {
+		return importDidKey;
+	}
+});
 Object.defineProperty(exports, "importJwk", {
 	enumerable: true,
 	get: function() {
@@ -218,3 +298,9 @@ Object.defineProperty(exports, "importSpki", {
 		return importSpki;
 	}
 });
+Object.defineProperty(exports, "parseDidKeyVerificationMethod", {
+	enumerable: true,
+	get: function() {
+		return parseDidKeyVerificationMethod;
+	}
+});

package/dist/tests/key.test.cjs

@@ -1,5 +1,6 @@
 require("./chunk-C2EiDwsr.cjs");
-const require_key = require("./key-pMmqUKuo.cjs");
+const require_multicodec = require("./multicodec-CxGVGa91.cjs");
+const require_key = require("./key-_wXwomh_.cjs");
 const require_multibase = require("./multibase-Bz_UUDtL.cjs");
 let node_assert = require("node:assert");
 let node_test = require("node:test");
@@ -71,4 +72,50 @@ const ed25519Multibase = "z6MksHj1MJnidCtDiyYW9ugNFftoX9fLK4bornTxmMZ6X7vq";
 		x: "Lm_M42cB3HkUiODQsXRcweM6TByfzEHGO9ND274JcOY"
 	}, "public")), "z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK");
 });
+(0, node_test.test)("exportDidKey() and importDidKey()", async () => {
+	const did = await require_key.exportDidKey(await require_key.importJwk(ed25519Jwk, "public"));
+	(0, node_assert.deepStrictEqual)(did, `did:key:${ed25519Multibase}`);
+	(0, node_assert.deepStrictEqual)(await require_key.exportJwk(await require_key.importDidKey(did)), ed25519Jwk);
+	(0, node_assert.deepStrictEqual)(await require_key.exportJwk(await require_key.importDidKey(new URL(did))), ed25519Jwk);
+	const rsaKey = await require_key.importJwk(rsaJwk, "public");
+	await (0, node_assert.rejects)(() => require_key.exportDidKey(rsaKey), TypeError);
+	await (0, node_assert.rejects)(() => require_key.importDidKey(`did:key:${rsaMultibase}`), /* @__PURE__ */ new TypeError("Unsupported did:key type: 0x1205"));
+});
+(0, node_test.test)("parseDidKeyVerificationMethod()", async () => {
+	const verificationMethod = `did:key:${ed25519Multibase}#${ed25519Multibase}`;
+	const parsed = await require_key.parseDidKeyVerificationMethod(verificationMethod);
+	(0, node_assert.deepStrictEqual)(parsed.id, new URL(verificationMethod));
+	(0, node_assert.deepStrictEqual)(parsed.controller, new URL(`did:key:${ed25519Multibase}`));
+	(0, node_assert.deepStrictEqual)(parsed.publicKeyMultibase, ed25519Multibase);
+	(0, node_assert.deepStrictEqual)(await require_key.exportJwk(parsed.publicKey), ed25519Jwk);
+});
+(0, node_test.test)("did:key helpers reject malformed values", async () => {
+	const ed25519Key = await require_key.importJwk(ed25519Jwk, "public");
+	const raw = new Uint8Array(await crypto.subtle.exportKey("raw", ed25519Key));
+	const shortEd25519 = new TextDecoder().decode(require_multibase.encodeMultibase("base58btc", require_multicodec.addMulticodecPrefix(237, raw.slice(0, 31))));
+	const base64UrlEd25519 = new TextDecoder().decode(require_multibase.encodeMultibase("base64url", require_multicodec.addMulticodecPrefix(237, raw)));
+	const malformedMulticodec = new TextDecoder().decode(require_multibase.encodeMultibase("base58btc", Uint8Array.from([128])));
+	for (const value of [
+		"did:web:example.com",
+		"did:key:",
+		`did:key:${ed25519Multibase}/path`,
+		`did:key:${ed25519Multibase}?query`,
+		`did:key:${ed25519Multibase}#${ed25519Multibase}`,
+		"did:key:z0",
+		`did:key:${base64UrlEd25519}`,
+		`did:key:${shortEd25519}`,
+		`did:key:${malformedMulticodec}`
+	]) await (0, node_assert.rejects)(() => require_key.importDidKey(value), TypeError);
+	for (const value of [
+		`did:key:${ed25519Multibase}`,
+		`did:key:${ed25519Multibase}#`,
+		`did:key:${ed25519Multibase}#z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK`,
+		`did:key:${ed25519Multibase}#${base64UrlEd25519}`,
+		"did:key:z0#z0",
+		`did:key:${rsaMultibase}#${rsaMultibase}`,
+		`did:key:${shortEd25519}#${shortEd25519}`,
+		`did:key:${malformedMulticodec}#${malformedMulticodec}`,
+		"https://example.com/key"
+	]) await (0, node_assert.rejects)(() => require_key.parseDidKeyVerificationMethod(value), TypeError);
+});
 //#endregion

package/dist/tests/key.test.mjs

@@ -1,4 +1,5 @@
-import { a as importPkcs1, c as importJwk, i as importPem, n as exportSpki, o as importSpki, r as importMultibaseKey, s as exportJwk, t as exportMultibaseKey } from "./key-CrrK9mYh.mjs";
+import { t as addMulticodecPrefix } from "./multicodec-CyFp54fI.mjs";
+import { a as importMultibaseKey, c as importSpki, d as importJwk, i as importDidKey, l as parseDidKeyVerificationMethod, n as exportMultibaseKey, o as importPem, r as exportSpki, s as importPkcs1, t as exportDidKey, u as exportJwk } from "./key-CDGDH_vC.mjs";
 import { n as encodeMultibase } from "./multibase-B4bvakyA.mjs";
 import { deepStrictEqual, rejects } from "node:assert";
 import { test } from "node:test";
@@ -70,5 +71,51 @@ test("exportMultibaseKey()", async () => {
 		x: "Lm_M42cB3HkUiODQsXRcweM6TByfzEHGO9ND274JcOY"
 	}, "public")), "z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK");
 });
+test("exportDidKey() and importDidKey()", async () => {
+	const did = await exportDidKey(await importJwk(ed25519Jwk, "public"));
+	deepStrictEqual(did, `did:key:${ed25519Multibase}`);
+	deepStrictEqual(await exportJwk(await importDidKey(did)), ed25519Jwk);
+	deepStrictEqual(await exportJwk(await importDidKey(new URL(did))), ed25519Jwk);
+	const rsaKey = await importJwk(rsaJwk, "public");
+	await rejects(() => exportDidKey(rsaKey), TypeError);
+	await rejects(() => importDidKey(`did:key:${rsaMultibase}`), /* @__PURE__ */ new TypeError("Unsupported did:key type: 0x1205"));
+});
+test("parseDidKeyVerificationMethod()", async () => {
+	const verificationMethod = `did:key:${ed25519Multibase}#${ed25519Multibase}`;
+	const parsed = await parseDidKeyVerificationMethod(verificationMethod);
+	deepStrictEqual(parsed.id, new URL(verificationMethod));
+	deepStrictEqual(parsed.controller, new URL(`did:key:${ed25519Multibase}`));
+	deepStrictEqual(parsed.publicKeyMultibase, ed25519Multibase);
+	deepStrictEqual(await exportJwk(parsed.publicKey), ed25519Jwk);
+});
+test("did:key helpers reject malformed values", async () => {
+	const ed25519Key = await importJwk(ed25519Jwk, "public");
+	const raw = new Uint8Array(await crypto.subtle.exportKey("raw", ed25519Key));
+	const shortEd25519 = new TextDecoder().decode(encodeMultibase("base58btc", addMulticodecPrefix(237, raw.slice(0, 31))));
+	const base64UrlEd25519 = new TextDecoder().decode(encodeMultibase("base64url", addMulticodecPrefix(237, raw)));
+	const malformedMulticodec = new TextDecoder().decode(encodeMultibase("base58btc", Uint8Array.from([128])));
+	for (const value of [
+		"did:web:example.com",
+		"did:key:",
+		`did:key:${ed25519Multibase}/path`,
+		`did:key:${ed25519Multibase}?query`,
+		`did:key:${ed25519Multibase}#${ed25519Multibase}`,
+		"did:key:z0",
+		`did:key:${base64UrlEd25519}`,
+		`did:key:${shortEd25519}`,
+		`did:key:${malformedMulticodec}`
+	]) await rejects(() => importDidKey(value), TypeError);
+	for (const value of [
+		`did:key:${ed25519Multibase}`,
+		`did:key:${ed25519Multibase}#`,
+		`did:key:${ed25519Multibase}#z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK`,
+		`did:key:${ed25519Multibase}#${base64UrlEd25519}`,
+		"did:key:z0#z0",
+		`did:key:${rsaMultibase}#${rsaMultibase}`,
+		`did:key:${shortEd25519}#${shortEd25519}`,
+		`did:key:${malformedMulticodec}#${malformedMulticodec}`,
+		"https://example.com/key"
+	]) await rejects(() => parseDidKeyVerificationMethod(value), TypeError);
+});
 //#endregion
 export {};

package/dist/tests/{request-BEXkv1ul.mjs → request-BGoZTy5L.mjs}

@@ -1,7 +1,7 @@
 import process from "node:process";
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.4.0-dev.1570+f1b6aaa3";
+var version = "2.4.0-dev.1573+246bd0b2";
 //#endregion
 //#region src/request.ts
 /**

package/dist/tests/{request-SworbvLc.cjs → request-DX4gki5x.cjs}

@@ -3,7 +3,7 @@ let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process, 1);
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.4.0-dev.1570+f1b6aaa3";
+var version = "2.4.0-dev.1573+246bd0b2";
 //#endregion
 //#region src/request.ts
 /**

package/dist/tests/request.test.cjs

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-C2EiDwsr.cjs");
-const require_request = require("./request-SworbvLc.cjs");
+const require_request = require("./request-DX4gki5x.cjs");
 let node_assert = require("node:assert");
 let node_test = require("node:test");
 let node_process = require("node:process");

package/dist/tests/request.test.mjs

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

package/dist/tests/{url-C20FhC7p.cjs → url-2XwVbUS_.cjs}

@@ -8,6 +8,90 @@ var UrlError = class extends Error {
 		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.
 */
@@ -186,6 +270,18 @@ Object.defineProperty(exports, "expandIPv6Address", {
 		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() {
@@ -198,6 +294,18 @@ Object.defineProperty(exports, "isValidPublicIPv6Address", {
 		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() {

package/dist/tests/{url-m9Qzxy-Y.mjs → url-YWJbnRlf.mjs}

@@ -7,6 +7,90 @@ var UrlError = class extends Error {
 		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.
 */
@@ -173,4 +257,4 @@ function matchesIPv6Prefix(address, prefixWords, prefixLength) {
 	return true;
 }
 //#endregion
-export { validatePublicUrl as a, isValidPublicIPv6Address as i, expandIPv6Address as n, isValidPublicIPv4Address as r, UrlError as t };
+export { isValidPublicIPv4Address as a, parseJsonLdId as c, haveSameIriOrigin as i, validatePublicUrl as l, expandIPv6Address as n, isValidPublicIPv6Address as o, formatIri as r, parseIri as s, UrlError as t };