@fedify/vocab-runtime 2.4.0-pr.936.41 → 2.5.0-dev.2271

package/dist/url-DD4F0ULf.cjs

@@ -1,483 +0,0 @@
-
-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 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 = (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, "arePortableUrisEqual", {
-	enumerable: true,
-	get: function() {
-		return arePortableUrisEqual;
-	}
-});
-Object.defineProperty(exports, "canonicalizePortableUri", {
-	enumerable: true,
-	get: function() {
-		return canonicalizePortableUri;
-	}
-});
-Object.defineProperty(exports, "expandIPv6Address", {
-	enumerable: true,
-	get: function() {
-		return expandIPv6Address;
-	}
-});
-Object.defineProperty(exports, "formatIri", {
-	enumerable: true,
-	get: function() {
-		return formatIri;
-	}
-});
-Object.defineProperty(exports, "getFe34Origin", {
-	enumerable: true,
-	get: function() {
-		return getFe34Origin;
-	}
-});
-Object.defineProperty(exports, "haveSameFe34Origin", {
-	enumerable: true,
-	get: function() {
-		return haveSameFe34Origin;
-	}
-});
-Object.defineProperty(exports, "haveSameIriOrigin", {
-	enumerable: true,
-	get: function() {
-		return haveSameIriOrigin;
-	}
-});
-Object.defineProperty(exports, "isGatewayUrl", {
-	enumerable: true,
-	get: function() {
-		return isGatewayUrl;
-	}
-});
-Object.defineProperty(exports, "isValidPublicIPv4Address", {
-	enumerable: true,
-	get: function() {
-		return isValidPublicIPv4Address;
-	}
-});
-Object.defineProperty(exports, "isValidPublicIPv6Address", {
-	enumerable: true,
-	get: function() {
-		return isValidPublicIPv6Address;
-	}
-});
-Object.defineProperty(exports, "parseGatewayUrl", {
-	enumerable: true,
-	get: function() {
-		return parseGatewayUrl;
-	}
-});
-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;
-	}
-});