@agntn/registries 0.2.0

package/dist/_chunks/registries.mjs

@@ -0,0 +1,1197 @@
+import { a as register, c as HTTPError, l as InvalidPURLError, t as Registry, u as NotFoundError } from "./registry.mjs";
+import { a as normalizeRepositoryURL, o as combineLicenses, s as normalizeLicense, t as buildPURL } from "./purl.mjs";
+/** npm registry client. */
+var NpmRegistry = class extends Registry {
+	constructor(baseURL, client) {
+		super();
+		this.baseURL = baseURL;
+		this.client = client;
+	}
+	baseURL;
+	client;
+	ecosystem() {
+		return "npm";
+	}
+	async fetchPackage(name, signal) {
+		const encodedName = this.encodeName(name);
+		const url = `${this.baseURL}/${encodedName}`;
+		try {
+			const data = await this.client.getJSON(url, signal);
+			const latestVersion = data["dist-tags"].latest;
+			const latestVersionData = data.versions[latestVersion];
+			const licenses = this.extractLicense(data.license || latestVersionData?.license);
+			const namespace = this.extractNamespace(name);
+			return {
+				name: data.name,
+				description: data.description || "",
+				homepage: data.homepage || "",
+				documentation: "",
+				repository: normalizeRepositoryURL(data.repository || ""),
+				licenses,
+				keywords: data.keywords || [],
+				namespace,
+				latestVersion,
+				metadata: {}
+			};
+		} catch (error) {
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("npm", name);
+			throw error;
+		}
+	}
+	async fetchVersions(name, signal) {
+		const encodedName = this.encodeName(name);
+		const url = `${this.baseURL}/${encodedName}`;
+		try {
+			const data = await this.client.getJSON(url, signal);
+			const versions = [];
+			for (const [versionStr, versionData] of Object.entries(data.versions)) {
+				const licenses = this.extractLicense(versionData.license);
+				const publishedAt = data.time?.[versionStr] ? new Date(data.time[versionStr]) : null;
+				const status = versionData.deprecated ? "deprecated" : "";
+				const integrity = versionData.dist?.integrity ? versionData.dist.integrity : versionData.dist?.shasum ? `sha1-${versionData.dist.shasum}` : "";
+				versions.push({
+					number: versionStr,
+					publishedAt,
+					licenses,
+					integrity,
+					status,
+					metadata: {}
+				});
+			}
+			return versions;
+		} catch (error) {
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("npm", name);
+			throw error;
+		}
+	}
+	async fetchDependencies(name, version, signal) {
+		const encodedName = this.encodeName(name);
+		const url = `${this.baseURL}/${encodedName}/${version}`;
+		try {
+			const versionData = await this.client.getJSON(url, signal);
+			const dependencies = [];
+			if (versionData.dependencies) for (const [depName, requirements] of Object.entries(versionData.dependencies)) {
+				if (versionData.optionalDependencies && Object.hasOwn(versionData.optionalDependencies, depName)) continue;
+				dependencies.push({
+					name: depName,
+					requirements,
+					scope: "runtime",
+					optional: false
+				});
+			}
+			if (versionData.devDependencies) for (const [depName, requirements] of Object.entries(versionData.devDependencies)) dependencies.push({
+				name: depName,
+				requirements,
+				scope: "development",
+				optional: false
+			});
+			if (versionData.optionalDependencies) for (const [depName, requirements] of Object.entries(versionData.optionalDependencies)) dependencies.push({
+				name: depName,
+				requirements,
+				scope: "runtime",
+				optional: true
+			});
+			if (versionData.peerDependencies) for (const [depName, requirements] of Object.entries(versionData.peerDependencies)) dependencies.push({
+				name: depName,
+				requirements,
+				scope: "runtime",
+				optional: false
+			});
+			return dependencies;
+		} catch (error) {
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("npm", name, version);
+			throw error;
+		}
+	}
+	async fetchMaintainers(name, signal) {
+		const encodedName = this.encodeName(name);
+		const url = `${this.baseURL}/${encodedName}`;
+		try {
+			const data = await this.client.getJSON(url, signal);
+			const maintainers = [];
+			const seen = /* @__PURE__ */ new Set();
+			if (data.maintainers) for (const maintainer of data.maintainers) {
+				const key = this.maintainerKey(maintainer.name, maintainer.email);
+				if (!key || seen.has(key)) continue;
+				seen.add(key);
+				maintainers.push({
+					uuid: "",
+					login: maintainer.email ? maintainer.email.split("@")[0] : "",
+					name: maintainer.name || "",
+					email: maintainer.email || "",
+					url: maintainer.url || "",
+					role: ""
+				});
+			}
+			const latestTag = data["dist-tags"].latest;
+			const latestVersion = data.versions[latestTag];
+			if (latestVersion?.author) {
+				const key = this.maintainerKey(latestVersion.author.name, latestVersion.author.email);
+				if (key && !seen.has(key)) {
+					seen.add(key);
+					maintainers.push({
+						uuid: "",
+						login: latestVersion.author.email ? latestVersion.author.email.split("@")[0] : "",
+						name: latestVersion.author.name || "",
+						email: latestVersion.author.email || "",
+						url: latestVersion.author.url || "",
+						role: "author"
+					});
+				}
+			}
+			if (latestVersion?.contributors) for (const contributor of latestVersion.contributors) {
+				const key = this.maintainerKey(contributor.name, contributor.email);
+				if (key && !seen.has(key)) {
+					seen.add(key);
+					maintainers.push({
+						uuid: "",
+						login: contributor.email ? contributor.email.split("@")[0] : "",
+						name: contributor.name || "",
+						email: contributor.email || "",
+						url: contributor.url || "",
+						role: "contributor"
+					});
+				}
+			}
+			return maintainers;
+		} catch (error) {
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("npm", name);
+			throw error;
+		}
+	}
+	urls() {
+		return {
+			registry: (name, version) => {
+				const base = `https://www.npmjs.com/package/${name}`;
+				return version ? `${base}/v/${version}` : base;
+			},
+			download: (name, version) => {
+				return `https://registry.npmjs.org/${this.encodeName(name)}/-/${name.includes("/") ? name.split("/")[1] : name}-${version}.tgz`;
+			},
+			documentation: (name, _version) => {
+				return `https://www.npmjs.com/package/${name}`;
+			},
+			readme: (name, version) => {
+				return `https://cdn.jsdelivr.net/npm/${name}${version ? `@${version}` : ""}/README.md`;
+			},
+			purl: (name, version) => {
+				const namespace = this.extractNamespace(name);
+				return buildPURL({
+					type: "npm",
+					namespace,
+					name: namespace ? name.slice(namespace.length + 1) : name,
+					version
+				});
+			}
+		};
+	}
+	/** Build a stable dedup key. Prefers email (unique per account), falls back to name. */
+	maintainerKey(name, email) {
+		if (email) return email;
+		if (name) return name;
+		return "";
+	}
+	/** Encode package name for URL (handle scoped packages). */
+	encodeName(name) {
+		if (name.startsWith("@")) return name.replace("/", "%2F");
+		return name;
+	}
+	/** Extract namespace from scoped package name. */
+	extractNamespace(name) {
+		if (name.startsWith("@")) return name.split("/")[0] || "";
+		return "";
+	}
+	/** Extract and normalize license. */
+	extractLicense(raw) {
+		if (!raw) return "";
+		if (typeof raw === "string") return normalizeLicense(raw);
+		if (typeof raw === "object" && raw !== null) {
+			const obj = raw;
+			if (typeof obj["type"] === "string") return normalizeLicense(obj["type"]);
+		}
+		return "";
+	}
+};
+register("npm", "https://registry.npmjs.org", NpmRegistry);
+/** Crates.io registry client. */
+var CargoRegistry = class extends Registry {
+	constructor(baseURL, client) {
+		super();
+		this.baseURL = baseURL;
+		this.client = client;
+	}
+	baseURL;
+	client;
+	ecosystem() {
+		return "cargo";
+	}
+	async fetchPackage(name, signal) {
+		const url = `${this.baseURL}/api/v1/crates/${name}`;
+		try {
+			const data = await this.client.getJSON(url, signal);
+			const crateData = data.crate;
+			const latestVersion = crateData.max_stable_version || crateData.max_version;
+			const latestVersionData = data.versions.find((v) => v.num === latestVersion);
+			return {
+				name: crateData.name,
+				description: crateData.description || "",
+				homepage: crateData.homepage || "",
+				documentation: crateData.documentation || "",
+				repository: normalizeRepositoryURL(crateData.repository || ""),
+				licenses: normalizeLicense(latestVersionData ? latestVersionData.license : data.versions[0]?.license ?? ""),
+				keywords: crateData.keywords,
+				namespace: "",
+				latestVersion,
+				metadata: {
+					downloads: crateData.downloads,
+					recentDownloads: crateData.recent_downloads,
+					categories: crateData.categories,
+					newestVersion: crateData.newest_version,
+					defaultVersion: crateData.max_version,
+					updatedAt: crateData.updated_at,
+					createdAt: crateData.created_at
+				}
+			};
+		} catch (error) {
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("cargo", name);
+			throw error;
+		}
+	}
+	async fetchVersions(name, signal) {
+		const url = `${this.baseURL}/api/v1/crates/${name}`;
+		try {
+			const data = await this.client.getJSON(url, signal);
+			const versions = [];
+			for (const versionData of data.versions) {
+				const publishedAt = new Date(versionData.created_at);
+				const status = versionData.yanked ? "yanked" : "";
+				versions.push({
+					number: versionData.num,
+					publishedAt,
+					licenses: normalizeLicense(versionData.license),
+					integrity: `sha256-${versionData.checksum}`,
+					status,
+					metadata: {
+						crateSize: versionData.crate_size,
+						features: versionData.features,
+						downloads: versionData.downloads
+					}
+				});
+			}
+			return versions;
+		} catch (error) {
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("cargo", name);
+			throw error;
+		}
+	}
+	async fetchDependencies(name, version, signal) {
+		const url = `${this.baseURL}/api/v1/crates/${name}/${version}/dependencies`;
+		try {
+			const data = await this.client.getJSON(url, signal);
+			const dependencies = [];
+			for (const dep of data.dependencies) {
+				let scope;
+				if (dep.kind === "dev") scope = "development";
+				else if (dep.kind === "build") scope = "build";
+				else scope = "runtime";
+				dependencies.push({
+					name: dep.crate_id,
+					requirements: dep.req,
+					scope,
+					optional: dep.optional
+				});
+			}
+			return dependencies;
+		} catch (error) {
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("cargo", name, version);
+			throw error;
+		}
+	}
+	async fetchMaintainers(name, signal) {
+		const url = `${this.baseURL}/api/v1/crates/${name}/owner_user`;
+		try {
+			const data = await this.client.getJSON(url, signal);
+			const maintainers = [];
+			for (const user of data.users) maintainers.push({
+				uuid: user.id.toString(),
+				login: user.login,
+				name: user.name,
+				email: "",
+				url: user.url,
+				role: ""
+			});
+			return maintainers;
+		} catch (error) {
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("cargo", name);
+			throw error;
+		}
+	}
+	urls() {
+		return {
+			registry: (name, version) => {
+				const base = `https://crates.io/crates/${name}`;
+				return version ? `${base}/${version}` : base;
+			},
+			download: (name, version) => {
+				return `https://crates.io/api/v1/crates/${name}/${version}/download`;
+			},
+			documentation: (name, version) => {
+				return version ? `https://docs.rs/${name}/${version}` : `https://docs.rs/${name}`;
+			},
+			readme: (name, version) => {
+				return version ? `https://crates.io/api/v1/crates/${name}/${version}/readme` : `https://crates.io/crates/${name}`;
+			},
+			purl: (name, version) => {
+				return buildPURL({
+					type: "cargo",
+					name,
+					version
+				});
+			}
+		};
+	}
+};
+register("cargo", "https://crates.io", CargoRegistry);
+const PYPI_FILENAME_SEPARATORS = [
+	"_",
+	"-",
+	"."
+];
+/** PyPI registry client. */
+var PyPIRegistry = class extends Registry {
+	constructor(baseURL, client) {
+		super();
+		this.baseURL = baseURL;
+		this.client = client;
+	}
+	baseURL;
+	client;
+	downloadUrls = /* @__PURE__ */ new Map();
+	ecosystem() {
+		return "pypi";
+	}
+	async fetchPackage(name, signal) {
+		const normalized = this.normalizeName(name);
+		const url = `${this.baseURL}/pypi/${normalized}/json`;
+		try {
+			const info = (await this.client.getJSON(url, signal)).info;
+			const licenses = normalizeLicense(info.license);
+			const repository = this.extractRepository(info.project_urls);
+			const keywords = this.parseKeywords(info.keywords);
+			return {
+				name: info.name,
+				description: info.summary || info.description || "",
+				homepage: this.findProjectUrl(info.project_urls, ["Homepage"]),
+				documentation: this.findProjectUrl(info.project_urls, ["Documentation"]),
+				repository,
+				licenses,
+				keywords,
+				namespace: "",
+				latestVersion: info.version,
+				metadata: {}
+			};
+		} catch (error) {
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("pypi", name);
+			throw error;
+		}
+	}
+	async fetchVersions(name, signal) {
+		const normalized = this.normalizeName(name);
+		const url = `${this.baseURL}/simple/${normalized}/`;
+		try {
+			const data = await this.client.getJSON(url, signal, { Accept: "application/vnd.pypi.simple.v1+json" });
+			const filesByVersion = /* @__PURE__ */ new Map();
+			for (const version of data.versions) filesByVersion.set(version, []);
+			for (const file of data.files) {
+				const version = this.matchFileVersion(file.filename, normalized, data.versions);
+				if (version) filesByVersion.get(version).push(file);
+			}
+			const versions = [];
+			for (const [versionStr, files] of filesByVersion) {
+				if (files.length === 0) {
+					versions.push({
+						number: versionStr,
+						publishedAt: null,
+						licenses: "",
+						integrity: "",
+						status: "",
+						metadata: {}
+					});
+					continue;
+				}
+				const file = files.find((f) => f.filename.endsWith(".tar.gz")) ?? files[0];
+				const publishedAt = file["upload-time"] ? new Date(file["upload-time"]) : null;
+				const integrity = file.hashes?.sha256 ? `sha256-${file.hashes.sha256}` : "";
+				const status = file.yanked ? "yanked" : "";
+				this.downloadUrls.set(`${normalized}@${versionStr}`, file.url);
+				versions.push({
+					number: versionStr,
+					publishedAt,
+					licenses: "",
+					integrity,
+					status,
+					metadata: {}
+				});
+			}
+			return versions;
+		} catch (error) {
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("pypi", name);
+			throw error;
+		}
+	}
+	async fetchDependencies(name, version, signal) {
+		const normalized = this.normalizeName(name);
+		const url = `${this.baseURL}/pypi/${normalized}/${version}/json`;
+		try {
+			const data = await this.client.getJSON(url, signal);
+			const dependencies = [];
+			if (data.info.requires_dist) for (const depStr of data.info.requires_dist) {
+				const dep = this.parsePEP508(depStr);
+				if (dep) dependencies.push(dep);
+			}
+			return dependencies;
+		} catch (error) {
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("pypi", name, version);
+			throw error;
+		}
+	}
+	async fetchMaintainers(name, signal) {
+		const normalized = this.normalizeName(name);
+		const url = `${this.baseURL}/pypi/${normalized}/json`;
+		try {
+			const data = await this.client.getJSON(url, signal);
+			const maintainers = [];
+			if (data.info.author || data.info.author_email) maintainers.push({
+				uuid: "",
+				login: data.info.author_email ? data.info.author_email.split("@")[0] : "",
+				name: data.info.author || "",
+				email: data.info.author_email || "",
+				url: "",
+				role: "author"
+			});
+			return maintainers;
+		} catch (error) {
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("pypi", name);
+			throw error;
+		}
+	}
+	urls() {
+		return {
+			registry: (name, version) => {
+				const base = `https://pypi.org/project/${this.normalizeName(name)}`;
+				return version ? `${base}/${version}` : base;
+			},
+			download: (name, version) => {
+				const normalized = this.normalizeName(name);
+				return this.downloadUrls.get(`${normalized}@${version}`) ?? `https://pypi.org/project/${normalized}/${version}/`;
+			},
+			documentation: (name, _version) => {
+				return `https://pypi.org/project/${this.normalizeName(name)}`;
+			},
+			readme: (name, version) => {
+				const normalized = this.normalizeName(name);
+				return version ? `https://pypi.org/project/${normalized}/${version}/` : `https://pypi.org/project/${normalized}/`;
+			},
+			purl: (name, version) => {
+				return buildPURL({
+					type: "pypi",
+					name: this.normalizeName(name),
+					version
+				});
+			}
+		};
+	}
+	/** Match a filename to a version from the known versions list. */
+	matchFileVersion(filename, normalizedName, versions) {
+		const lower = filename.toLowerCase();
+		let prefix;
+		for (const separator of PYPI_FILENAME_SEPARATORS) {
+			const candidate = normalizedName.replaceAll("-", separator) + "-";
+			if (lower.startsWith(candidate)) {
+				prefix = candidate;
+				break;
+			}
+		}
+		if (!prefix) return void 0;
+		const afterPrefix = filename.slice(prefix.length);
+		const dashIdx = afterPrefix.indexOf("-");
+		if (dashIdx !== -1) {
+			const candidate = afterPrefix.slice(0, dashIdx);
+			if (versions.includes(candidate)) return candidate;
+		}
+		const stripped = afterPrefix.replace(/\.(tar\.(gz|bz2|xz)|zip)$/i, "");
+		if (versions.includes(stripped)) return stripped;
+	}
+	/** Normalize package name per PEP 503. */
+	normalizeName(name) {
+		return name.toLowerCase().replace(/[-_.]+/g, "-");
+	}
+	/** Extract repository URL from project_urls. */
+	extractRepository(projectUrls) {
+		return normalizeRepositoryURL(this.findProjectUrl(projectUrls, [
+			"Repository",
+			"Source",
+			"Source Code",
+			"GitHub",
+			"Homepage"
+		]));
+	}
+	/** Find a project URL by key, case-insensitive. */
+	findProjectUrl(projectUrls, keys) {
+		if (!projectUrls) return "";
+		const lowered = /* @__PURE__ */ new Map();
+		for (const [k, v] of Object.entries(projectUrls)) lowered.set(k.toLowerCase(), v);
+		for (const key of keys) {
+			const value = lowered.get(key.toLowerCase());
+			if (value) return value;
+		}
+		return "";
+	}
+	/** Parse comma-separated keywords. */
+	parseKeywords(keywords) {
+		if (!keywords) return [];
+		return keywords.split(",").map((k) => k.trim()).filter(Boolean);
+	}
+	/** Parse PEP 508 dependency string into a normalized Dependency. */
+	parsePEP508(depStr) {
+		const semiIdx = depStr.indexOf(";");
+		const mainPart = semiIdx === -1 ? depStr.trim() : depStr.slice(0, semiIdx).trim();
+		const markerStr = semiIdx === -1 ? "" : depStr.slice(semiIdx + 1).trim();
+		const match = mainPart.match(/^([a-zA-Z0-9._-]+)\s*(?:\[.*?\])?\s*(.*)$/);
+		if (!match) return null;
+		const depName = match[1];
+		let versionSpec = match[2].trim();
+		if (versionSpec.startsWith("(") && versionSpec.endsWith(")")) versionSpec = versionSpec.slice(1, -1).trim();
+		let scope = "runtime";
+		let optional = false;
+		if (markerStr) {
+			const extraMatch = markerStr.match(/extra\s*==\s*["']([^"']+)["']/);
+			if (extraMatch) {
+				optional = true;
+				const extraName = extraMatch[1].toLowerCase();
+				if (/^dev(elop(ment)?)?$/.test(extraName)) scope = "development";
+				else if (/^test(s|ing)?$/.test(extraName)) scope = "test";
+			}
+		}
+		return {
+			name: this.normalizeName(depName),
+			requirements: versionSpec,
+			scope,
+			optional
+		};
+	}
+};
+register("pypi", "https://pypi.org", PyPIRegistry);
+/** RubyGems registry client. */
+var RubyGemsRegistry = class extends Registry {
+	constructor(baseURL, client) {
+		super();
+		this.baseURL = baseURL;
+		this.client = client;
+	}
+	baseURL;
+	client;
+	ecosystem() {
+		return "gem";
+	}
+	async fetchPackage(name, signal) {
+		const url = `${this.baseURL}/api/v1/gems/${name}.json`;
+		try {
+			const data = await this.client.getJSON(url, signal);
+			const licenses = data.licenses ? combineLicenses(data.licenses.map((l) => normalizeLicense(l))) : "";
+			const repository = normalizeRepositoryURL(data.source_code_uri || data.metadata?.source_code_uri || data.homepage_uri || "");
+			return {
+				name: data.name,
+				description: data.description || "",
+				homepage: data.homepage_uri || "",
+				documentation: data.documentation_uri || "",
+				repository,
+				licenses,
+				keywords: [],
+				namespace: "",
+				latestVersion: data.version || "",
+				metadata: data.metadata || {}
+			};
+		} catch (error) {
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("gem", name);
+			throw error;
+		}
+	}
+	async fetchVersions(name, signal) {
+		const url = `${this.baseURL}/api/v1/versions/${name}.json`;
+		try {
+			const data = await this.client.getJSON(url, signal);
+			const versions = [];
+			for (const versionData of data) {
+				const publishedAt = versionData.created_at ? new Date(versionData.created_at) : null;
+				const status = versionData.yanked ? "yanked" : "";
+				versions.push({
+					number: versionData.number,
+					publishedAt,
+					licenses: "",
+					integrity: versionData.sha ? `sha256-${versionData.sha}` : "",
+					status,
+					metadata: {}
+				});
+			}
+			return versions;
+		} catch (error) {
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("gem", name);
+			throw error;
+		}
+	}
+	async fetchDependencies(name, version, signal) {
+		const url = `${this.baseURL}/api/v2/rubygems/${name}/versions/${version}.json`;
+		try {
+			const data = await this.client.getJSON(url, signal);
+			const dependencies = [];
+			if (data.dependencies?.runtime) for (const dep of data.dependencies.runtime) dependencies.push({
+				name: dep.name,
+				requirements: dep.requirements,
+				scope: "runtime",
+				optional: false
+			});
+			if (data.dependencies?.development) for (const dep of data.dependencies.development) dependencies.push({
+				name: dep.name,
+				requirements: dep.requirements,
+				scope: "development",
+				optional: false
+			});
+			return dependencies;
+		} catch (error) {
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("gem", name, version);
+			throw error;
+		}
+	}
+	async fetchMaintainers(name, signal) {
+		const url = `${this.baseURL}/api/v1/gems/${name}/owners.json`;
+		try {
+			const data = await this.client.getJSON(url, signal);
+			const maintainers = [];
+			for (const owner of data) maintainers.push({
+				uuid: "",
+				login: owner.handle,
+				name: owner.handle,
+				email: owner.email || "",
+				url: "",
+				role: ""
+			});
+			return maintainers;
+		} catch (error) {
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("gem", name);
+			throw error;
+		}
+	}
+	urls() {
+		return {
+			registry: (name, version) => {
+				const base = `https://rubygems.org/gems/${name}`;
+				return version ? `${base}/versions/${version}` : base;
+			},
+			download: (name, version) => {
+				return `https://rubygems.org/downloads/${name}-${version}.gem`;
+			},
+			documentation: (name, version) => {
+				return `https://www.rubydoc.info/gems/${name}${version ? `/${version}` : ""}`;
+			},
+			readme: (name, version) => {
+				const base = `https://rubygems.org/gems/${name}`;
+				return version ? `${base}/versions/${version}` : base;
+			},
+			purl: (name, version) => {
+				return buildPURL({
+					type: "gem",
+					name,
+					version
+				});
+			}
+		};
+	}
+};
+register("gem", "https://rubygems.org", RubyGemsRegistry);
+/** Packagist registry client. */
+var PackagistRegistry = class extends Registry {
+	constructor(baseURL, client) {
+		super();
+		this.baseURL = baseURL;
+		this.client = client;
+	}
+	baseURL;
+	client;
+	ecosystem() {
+		return "composer";
+	}
+	async fetchPackage(name, signal) {
+		const [vendor, pkg] = this.parseName(name);
+		const url = `${this.baseURL}/packages/${vendor}/${pkg}.json`;
+		try {
+			const packageData = (await this.client.getJSON(url, signal)).package;
+			const versions = Object.keys(packageData.versions);
+			const latestVersion = this.findLatestVersion(versions);
+			const latestVersionData = packageData.versions[latestVersion];
+			const licenses = this.extractLicenses(latestVersionData.license);
+			return {
+				name: packageData.name,
+				description: packageData.description || "",
+				homepage: "",
+				documentation: "",
+				repository: normalizeRepositoryURL(packageData.repository || latestVersionData.source?.url || ""),
+				licenses,
+				keywords: packageData.keywords || [],
+				namespace: vendor,
+				latestVersion,
+				metadata: {}
+			};
+		} catch (error) {
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("composer", name);
+			throw error;
+		}
+	}
+	async fetchVersions(name, signal) {
+		const [vendor, pkg] = this.parseName(name);
+		const url = `${this.baseURL}/packages/${vendor}/${pkg}.json`;
+		try {
+			const data = await this.client.getJSON(url, signal);
+			const versions = [];
+			for (const [versionStr, versionData] of Object.entries(data.package.versions)) {
+				const licenses = this.extractLicenses(versionData.license);
+				const publishedAt = versionData.time ? new Date(versionData.time) : null;
+				versions.push({
+					number: versionStr,
+					publishedAt,
+					licenses,
+					integrity: versionData.dist?.shasum ? `sha1-${versionData.dist.shasum}` : "",
+					status: "",
+					metadata: {}
+				});
+			}
+			return versions;
+		} catch (error) {
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("composer", name);
+			throw error;
+		}
+	}
+	async fetchDependencies(name, version, signal) {
+		const [vendor, pkg] = this.parseName(name);
+		const url = `${this.baseURL}/packages/${vendor}/${pkg}.json`;
+		try {
+			const versionData = (await this.client.getJSON(url, signal)).package.versions[version];
+			if (!versionData) throw new NotFoundError("composer", name, version);
+			const dependencies = [];
+			if (versionData.require) {
+				for (const [depName, requirements] of Object.entries(versionData.require)) if (!this.shouldSkipDependency(depName)) dependencies.push({
+					name: depName,
+					requirements,
+					scope: "runtime",
+					optional: false
+				});
+			}
+			if (versionData["require-dev"]) {
+				for (const [depName, requirements] of Object.entries(versionData["require-dev"])) if (!this.shouldSkipDependency(depName)) dependencies.push({
+					name: depName,
+					requirements,
+					scope: "development",
+					optional: false
+				});
+			}
+			return dependencies;
+		} catch (error) {
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("composer", name, version);
+			throw error;
+		}
+	}
+	async fetchMaintainers(name, signal) {
+		const [vendor, pkg] = this.parseName(name);
+		const url = `${this.baseURL}/packages/${vendor}/${pkg}.json`;
+		try {
+			const data = await this.client.getJSON(url, signal);
+			const maintainers = [];
+			const seen = /* @__PURE__ */ new Set();
+			for (const versionData of Object.values(data.package.versions)) if (versionData.authors) for (const author of versionData.authors) {
+				const key = `${author.name}:${author.email}`;
+				if (!seen.has(key)) {
+					seen.add(key);
+					maintainers.push({
+						uuid: "",
+						login: author.email ? author.email.split("@")[0] : "",
+						name: author.name || "",
+						email: author.email || "",
+						url: author.homepage || "",
+						role: author.role || ""
+					});
+				}
+			}
+			return maintainers;
+		} catch (error) {
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("composer", name);
+			throw error;
+		}
+	}
+	urls() {
+		return {
+			registry: (name, version) => {
+				const [vendor, pkg] = this.parseName(name);
+				const base = `https://packagist.org/packages/${vendor}/${pkg}`;
+				return version ? `${base}#${version}` : base;
+			},
+			download: (name, version) => {
+				const [vendor, pkg] = this.parseName(name);
+				return `https://repo.packagist.org/p/${vendor}/${pkg}/${version}.json`;
+			},
+			documentation: (name, _version) => {
+				const [vendor, pkg] = this.parseName(name);
+				return `https://packagist.org/packages/${vendor}/${pkg}`;
+			},
+			readme: (name, _version) => {
+				const [vendor, pkg] = this.parseName(name);
+				return `https://packagist.org/packages/${vendor}/${pkg}`;
+			},
+			purl: (name, version) => {
+				const [vendor, pkg] = this.parseName(name);
+				return buildPURL({
+					type: "composer",
+					namespace: vendor,
+					name: pkg,
+					version
+				});
+			}
+		};
+	}
+	/** Parse "vendor/package" format. */
+	parseName(name) {
+		const parts = name.split("/");
+		if (parts.length !== 2 || !parts[0] || !parts[1]) throw new InvalidPURLError(`pkg:composer/${name}`, "invalid Composer package name, expected \"vendor/package\" format");
+		return [parts[0], parts[1]];
+	}
+	/** Find the highest non-dev version. */
+	findLatestVersion(versions) {
+		const stable = versions.filter((v) => !v.startsWith("dev-") && !v.endsWith("-dev"));
+		if (stable.length === 0) return versions[0] || "";
+		return stable.sort((a, b) => {
+			const aClean = a.replace(/^v/, "");
+			const bClean = b.replace(/^v/, "");
+			const aParts = aClean.split(".").map((p) => Number.parseInt(p, 10));
+			const bParts = bClean.split(".").map((p) => Number.parseInt(p, 10));
+			for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+				const aPart = aParts[i] ?? 0;
+				const bPart = bParts[i] ?? 0;
+				if (aPart !== bPart) return bPart - aPart;
+			}
+			return 0;
+		})[0] || versions[0] || "";
+	}
+	/** Extract and normalize licenses. */
+	extractLicenses(raw) {
+		if (!raw) return "";
+		return combineLicenses(Array.isArray(raw) ? raw : [raw]);
+	}
+	/** Skip PHP and extension dependencies. */
+	shouldSkipDependency(name) {
+		return name === "php" || name.startsWith("ext-");
+	}
+};
+register("composer", "https://packagist.org", PackagistRegistry);
+const AUR_BASE_URL = "https://aur.archlinux.org";
+/** ALPM registry client — routes to Arch Linux official repos or AUR based on namespace. */
+var AlpmRegistry = class extends Registry {
+	constructor(baseURL, client) {
+		super();
+		this.baseURL = baseURL;
+		this.client = client;
+	}
+	baseURL;
+	client;
+	ecosystem() {
+		return "alpm";
+	}
+	async fetchPackage(name, signal) {
+		const { namespace, pkgName } = this.parseName(name);
+		this.assertSupportedNamespace(namespace, name);
+		if (namespace === "aur") return this.fetchAurPackage(pkgName, signal);
+		return this.fetchOfficialPackage(pkgName, signal);
+	}
+	async fetchVersions(name, signal) {
+		const { namespace, pkgName } = this.parseName(name);
+		this.assertSupportedNamespace(namespace, name);
+		if (namespace === "aur") return this.fetchAurVersions(pkgName, signal);
+		return this.fetchOfficialVersions(pkgName, signal);
+	}
+	async fetchDependencies(name, version, signal) {
+		const { namespace, pkgName } = this.parseName(name);
+		this.assertSupportedNamespace(namespace, name);
+		if (namespace === "aur") return this.fetchAurDependencies(pkgName, version, signal);
+		return this.fetchOfficialDependencies(pkgName, version, signal);
+	}
+	async fetchMaintainers(name, signal) {
+		const { namespace, pkgName } = this.parseName(name);
+		this.assertSupportedNamespace(namespace, name);
+		if (namespace === "aur") return this.fetchAurMaintainers(pkgName, signal);
+		return this.fetchOfficialMaintainers(pkgName, signal);
+	}
+	urls() {
+		return {
+			registry: (name, _version) => {
+				const { namespace, pkgName } = this.parseName(name);
+				if (namespace === "aur") return `https://aur.archlinux.org/packages/${pkgName}`;
+				return `https://archlinux.org/packages/?name=${pkgName}`;
+			},
+			download: (name, _version) => {
+				const { namespace, pkgName } = this.parseName(name);
+				if (namespace === "aur") return `https://aur.archlinux.org/cgit/aur.git/snapshot/${pkgName}.tar.gz`;
+				return `https://archive.archlinux.org/packages/${pkgName.charAt(0)}/${pkgName}/`;
+			},
+			documentation: (name, _version) => {
+				const { namespace, pkgName } = this.parseName(name);
+				if (namespace === "aur") return `https://aur.archlinux.org/packages/${pkgName}`;
+				return `https://wiki.archlinux.org/title/${pkgName}`;
+			},
+			readme: (_name, _version) => {
+				return "";
+			},
+			purl: (name, version) => {
+				const { namespace, pkgName } = this.parseName(name);
+				return buildPURL({
+					type: "alpm",
+					namespace,
+					name: pkgName,
+					version
+				});
+			}
+		};
+	}
+	async fetchOfficialPackage(name, signal) {
+		const result = await this.searchOfficial(name, signal);
+		return {
+			name: result.pkgname,
+			description: result.pkgdesc || "",
+			homepage: result.url || "",
+			documentation: "",
+			repository: "",
+			licenses: combineLicenses(result.licenses),
+			keywords: result.groups,
+			namespace: "arch",
+			latestVersion: this.formatVersion(result),
+			metadata: {
+				repo: result.repo,
+				arch: result.arch,
+				pkgbase: result.pkgbase,
+				compressedSize: result.compressed_size,
+				installedSize: result.installed_size,
+				buildDate: result.build_date,
+				lastUpdate: result.last_update,
+				flagDate: result.flag_date,
+				packager: result.packager,
+				provides: result.provides,
+				conflicts: result.conflicts,
+				replaces: result.replaces
+			}
+		};
+	}
+	async fetchOfficialVersions(name, signal) {
+		const result = await this.searchOfficial(name, signal);
+		return [{
+			number: this.formatVersion(result),
+			publishedAt: result.last_update ? new Date(result.last_update) : null,
+			licenses: combineLicenses(result.licenses),
+			integrity: "",
+			status: result.flag_date ? "deprecated" : "",
+			metadata: {
+				repo: result.repo,
+				arch: result.arch
+			}
+		}];
+	}
+	async fetchOfficialDependencies(name, version, signal) {
+		const result = await this.searchOfficial(name, signal);
+		const currentVersion = this.formatVersion(result);
+		this.assertVersionMatches(name, version, currentVersion);
+		return this.buildDependencies(result.depends, result.makedepends, result.optdepends, result.checkdepends);
+	}
+	async fetchOfficialMaintainers(name, signal) {
+		return (await this.searchOfficial(name, signal)).maintainers.map((m) => ({
+			uuid: "",
+			login: m,
+			name: m,
+			email: "",
+			url: "",
+			role: "maintainer"
+		}));
+	}
+	/** Search official repos by exact package name. Prefers x86_64 results. */
+	async searchOfficial(name, signal) {
+		const url = `${this.baseURL}/packages/search/json/?name=${encodeURIComponent(name)}`;
+		try {
+			const data = await this.client.getJSON(url, signal);
+			if (!data.results || data.results.length === 0) throw new NotFoundError("alpm", name);
+			return data.results.find((r) => r.arch === "x86_64") || data.results[0];
+		} catch (error) {
+			if (error instanceof NotFoundError) throw error;
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("alpm", name);
+			throw error;
+		}
+	}
+	async fetchAurPackage(name, signal) {
+		const result = await this.fetchAurInfo(name, signal);
+		return {
+			name: result.Name,
+			description: result.Description || "",
+			homepage: result.URL || "",
+			documentation: "",
+			repository: "",
+			licenses: combineLicenses(result.License || []),
+			keywords: result.Keywords || [],
+			namespace: "aur",
+			latestVersion: result.Version,
+			metadata: {
+				votes: result.NumVotes,
+				popularity: result.Popularity,
+				outOfDate: result.OutOfDate,
+				pkgbase: result.PackageBase,
+				firstSubmitted: result.FirstSubmitted,
+				lastModified: result.LastModified
+			}
+		};
+	}
+	async fetchAurVersions(name, signal) {
+		const result = await this.fetchAurInfo(name, signal);
+		return [{
+			number: result.Version,
+			publishedAt: result.LastModified ? /* @__PURE__ */ new Date(result.LastModified * 1e3) : null,
+			licenses: combineLicenses(result.License || []),
+			integrity: "",
+			status: result.OutOfDate ? "deprecated" : "",
+			metadata: {
+				votes: result.NumVotes,
+				popularity: result.Popularity
+			}
+		}];
+	}
+	async fetchAurDependencies(name, version, signal) {
+		const result = await this.fetchAurInfo(name, signal);
+		this.assertVersionMatches(`aur/${name}`, version, result.Version);
+		return this.buildDependencies(result.Depends || [], result.MakeDepends || [], result.OptDepends || [], result.CheckDepends || []);
+	}
+	async fetchAurMaintainers(name, signal) {
+		const result = await this.fetchAurInfo(name, signal);
+		if (!result.Maintainer) return [];
+		return [{
+			uuid: "",
+			login: result.Maintainer,
+			name: result.Maintainer,
+			email: "",
+			url: "",
+			role: "maintainer"
+		}];
+	}
+	/** Fetch package info from AUR RPC v5. */
+	async fetchAurInfo(name, signal) {
+		const url = `${AUR_BASE_URL}/rpc/v5/info/${encodeURIComponent(name)}`;
+		try {
+			const data = await this.client.getJSON(url, signal);
+			if (!data.results || data.results.length === 0) throw new NotFoundError("alpm", `aur/${name}`);
+			return data.results[0];
+		} catch (error) {
+			if (error instanceof NotFoundError) throw error;
+			if (error instanceof HTTPError && error.isNotFound()) throw new NotFoundError("alpm", `aur/${name}`);
+			throw error;
+		}
+	}
+	/** Parse "namespace/name" into components. Defaults to "arch" namespace. */
+	parseName(fullName) {
+		const normalized = fullName.trim().toLowerCase();
+		const slashIdx = normalized.indexOf("/");
+		if (slashIdx === -1) return {
+			namespace: "arch",
+			pkgName: normalized
+		};
+		return {
+			namespace: normalized.slice(0, slashIdx),
+			pkgName: normalized.slice(slashIdx + 1)
+		};
+	}
+	assertSupportedNamespace(namespace, requestedName) {
+		if (namespace !== "arch" && namespace !== "aur") throw new NotFoundError("alpm", requestedName);
+	}
+	assertVersionMatches(name, requested, current) {
+		if (requested && requested !== current) throw new NotFoundError("alpm", name, requested);
+	}
+	/** Format ALPM version: epoch:pkgver-pkgrel (epoch omitted when 0). */
+	formatVersion(result) {
+		return `${result.epoch && result.epoch > 0 ? `${result.epoch}:` : ""}${result.pkgver}-${result.pkgrel}`;
+	}
+	/** Build normalized dependency list from ALPM dependency arrays. */
+	buildDependencies(depends, makedepends, optdepends, checkdepends) {
+		const dependencies = [];
+		for (const dep of depends) {
+			const parsed = this.parseDep(dep);
+			dependencies.push({
+				name: parsed.name,
+				requirements: parsed.requirements,
+				scope: "runtime",
+				optional: false
+			});
+		}
+		for (const dep of makedepends) {
+			const parsed = this.parseDep(dep);
+			dependencies.push({
+				name: parsed.name,
+				requirements: parsed.requirements,
+				scope: "build",
+				optional: false
+			});
+		}
+		for (const dep of optdepends) {
+			const parsed = this.parseOptDep(dep);
+			dependencies.push({
+				name: parsed.name,
+				requirements: parsed.requirements,
+				scope: "optional",
+				optional: true
+			});
+		}
+		for (const dep of checkdepends) {
+			const parsed = this.parseDep(dep);
+			dependencies.push({
+				name: parsed.name,
+				requirements: parsed.requirements,
+				scope: "test",
+				optional: false
+			});
+		}
+		return dependencies;
+	}
+	/** Parse a dependency string like "glibc>=2.33" or "bash". */
+	parseDep(dep) {
+		const match = dep.match(/^([a-zA-Z0-9@._+-]+)(.*)$/);
+		if (!match) return {
+			name: dep,
+			requirements: ""
+		};
+		return {
+			name: match[1],
+			requirements: match[2].trim()
+		};
+	}
+	/** Parse optional dependency like "perl-locale-gettext: translation support". */
+	parseOptDep(dep) {
+		const colonIdx = dep.indexOf(":");
+		if (colonIdx === -1) {
+			const parsed = this.parseDep(dep.trim());
+			return {
+				name: parsed.name,
+				requirements: parsed.requirements,
+				description: ""
+			};
+		}
+		const parsed = this.parseDep(dep.slice(0, colonIdx).trim());
+		return {
+			name: parsed.name,
+			requirements: parsed.requirements,
+			description: dep.slice(colonIdx + 1).trim()
+		};
+	}
+};
+register("alpm", "https://archlinux.org", AlpmRegistry);
+export { CargoRegistry as a, PyPIRegistry as i, PackagistRegistry as n, NpmRegistry as o, RubyGemsRegistry as r, AlpmRegistry as t };
+
+//# sourceMappingURL=registries.mjs.map