@fedify/vocab-runtime 2.4.0-pr.936.41 → 2.4.1

package/dist/url-DGVbSVVi.js

@@ -1,393 +0,0 @@
-
-import { lookup } from "node:dns/promises";
-import { isIP } from "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 PERCENT_ENCODING_PATTERN = /%[0-9A-Fa-f]{2}/g;
-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}`;
-}
-/**
-* Canonicalizes a FEP-ef61 portable ActivityPub URI for comparison.
-*
-* This accepts both `ap:` and `ap+ef61:` URI strings with decoded or
-* percent-encoded DID authorities.  The returned value uses the `ap+ef61:`
-* scheme, a decoded DID authority, and no query component.  Pass the raw URI
-* string, not a `URL` object, because JavaScript `URL` normalizes opaque path
-* segments before Fedify can compare them.
-*
-* @param input The raw portable ActivityPub URI string to canonicalize.
-* @returns The canonical portable ActivityPub URI string.
-* @throws {TypeError} If the input is not a valid portable ActivityPub IRI.
-* @since 2.4.0
-*/
-function canonicalizePortableUri(input) {
-	if (typeof input !== "string") throw new TypeError("Invalid portable ActivityPub IRI.");
-	const parsed = parsePortableIri(input);
-	if (parsed == null) throw new TypeError("Invalid portable ActivityPub IRI.");
-	const match = input.match(PORTABLE_IRI_PATTERN);
-	return `ap+ef61://${normalizePortableAuthority(getDidUrlOrigin(decodePortableAuthority(parsed.host)))}${normalizePortableComponent(match[3])}${match[5] == null ? "" : normalizePortableComponent(match[5])}`;
-}
-/**
-* Checks whether two FEP-ef61 portable ActivityPub URIs identify the same
-* portable object.
-*
-* Non-string inputs return `false`.  Non-portable URI strings use strict string
-* equality.  Portable URI strings are compared through
-* {@link canonicalizePortableUri}; malformed portable URI strings return
-* `false` unless they are exactly equal.
-*
-* @since 2.4.0
-*/
-function arePortableUrisEqual(left, right) {
-	if (typeof left !== "string" || typeof right !== "string") return false;
-	if (left === right) return true;
-	if (!PORTABLE_IRI_PATTERN.test(left) || !PORTABLE_IRI_PATTERN.test(right)) return false;
-	try {
-		return canonicalizePortableUri(left) === canonicalizePortableUri(right);
-	} catch (error) {
-		if (error instanceof TypeError) return false;
-		throw error;
-	}
-}
-/**
-* Computes an IRI's FEP-fe34 origin.
-*
-* HTTP(S) IRIs use their web origin.  FEP-ef61 portable ActivityPub IRIs and
-* DID URLs use their DID as a cryptographic origin.
-*
-* @throws {TypeError} If the IRI does not have a supported FEP-fe34 origin.
-* @since 2.4.0
-*/
-function getFe34Origin(input) {
-	if (input instanceof URL) {
-		const portable = normalizePortableUrl(input);
-		if (portable != null) return getPortableCryptographicOrigin(portable);
-		if (input.protocol === "did:") return getDidUrlOrigin(input.href);
-		if (input.protocol === "http:" || input.protocol === "https:") return input.origin;
-		throw new TypeError("Unsupported FEP-fe34 origin IRI.");
-	}
-	const portable = parsePortableIri(input);
-	if (portable != null) return getPortableCryptographicOrigin(portable);
-	if (DID_SCHEME_PATTERN.test(input)) return getDidUrlOrigin(input);
-	const parsed = new URL(input);
-	if (parsed.protocol === "http:" || parsed.protocol === "https:") return parsed.origin;
-	throw new TypeError("Unsupported FEP-fe34 origin IRI.");
-}
-/**
-* Checks whether two IRIs have the same FEP-fe34 origin.
-*
-* Malformed or unsupported IRIs are treated as non-matching.
-*
-* @since 2.4.0
-*/
-function haveSameFe34Origin(left, right) {
-	try {
-		return getFe34Origin(left) === getFe34Origin(right);
-	} catch (error) {
-		if (error instanceof TypeError) return false;
-		throw error;
-	}
-}
-/**
-* 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(getDidUrlOrigin(decodePortableAuthority(iri.host))) : iri.host;
-		return `${iri.protocol}//${host}`;
-	}
-	return iri.href;
-}
-function getPortableCryptographicOrigin(iri) {
-	return getDidUrlOrigin(decodePortableAuthority(iri.host));
-}
-function getDidUrlOrigin(iri) {
-	const did = iri.split(/[/?#]/, 1)[0].replace(DID_SCHEME_PATTERN, "did:");
-	if (!DID_PATTERN.test(did)) throw new TypeError("Invalid DID URL.");
-	const parts = did.split(":");
-	parts[1] = parts[1].toLowerCase();
-	return normalizePortableAuthority(parts.join(":"));
-}
-function parsePortableIri(iri) {
-	const match = iri.match(PORTABLE_IRI_PATTERN);
-	if (match == null) return null;
-	const authority = getDidUrlOrigin(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 normalizePercentEncoding(value) {
-	return value.replace(PERCENT_ENCODING_PATTERN, (match) => match.toUpperCase());
-}
-function normalizePortableAuthority(authority) {
-	return normalizePercentEncoding(authority).replace(PERCENT_ENCODING_PATTERN, (match) => {
-		const decoded = String.fromCharCode(Number.parseInt(match.slice(1), 16));
-		return /[A-Za-z0-9._~-]/.test(decoded) ? decoded : match;
-	});
-}
-function normalizePortableComponent(value) {
-	if (INVALID_PERCENT_ENCODING_PATTERN.test(value)) throw new TypeError("Invalid portable ActivityPub IRI component.");
-	return value.replace(/%[0-9A-Fa-f]{2}|[^%]+/g, (match) => {
-		if (match.startsWith("%")) {
-			const upper = match.toUpperCase();
-			const decoded = String.fromCharCode(Number.parseInt(upper.slice(1), 16));
-			return /[A-Za-z0-9._~-]/.test(decoded) ? decoded : upper;
-		}
-		try {
-			return encodeURI(match);
-		} catch (error) {
-			if (error instanceof URIError) throw new TypeError("Invalid portable ActivityPub IRI component.");
-			throw error;
-		}
-	});
-}
-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);
-}
-/**
-* Checks whether the URL is an FEP-ef61 gateway base URI.
-*/
-function isGatewayUrl(url) {
-	return (url.protocol === "http:" || url.protocol === "https:") && url.username === "" && url.password === "" && url.pathname === "/" && url.search === "" && url.hash === "";
-}
-/**
-* Parses and validates an FEP-ef61 gateway base URI.
-*/
-function parseGatewayUrl(url) {
-	const parsed = parseIri(url);
-	if (!isGatewayUrl(parsed)) throw new TypeError("FEP-ef61 gateways must be HTTP(S) base URIs with no credentials, path, query, or fragment.");
-	return parsed;
-}
-/**
-* 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 = isIP(hostname);
-	if (hostnameFamily !== 0) {
-		validatePublicIpAddress(hostname, hostnameFamily);
-		return;
-	}
-	if ("Deno" in globalThis && !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 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
-export { formatIri as a, haveSameIriOrigin as c, isValidPublicIPv6Address as d, parseGatewayUrl as f, validatePublicUrl as h, expandIPv6Address as i, isGatewayUrl as l, parseJsonLdId as m, arePortableUrisEqual as n, getFe34Origin as o, parseIri as p, canonicalizePortableUri as r, haveSameFe34Origin as s, UrlError as t, isValidPublicIPv4Address as u };