nameable 0.0.0-stage → 0.1.0

package/dist/dist-kIDsX2Ie.mjs

@@ -0,0 +1,3391 @@
+import { builtinModules } from "node:module";
+import { connect } from "node:net";
+import { domainToASCII, domainToUnicode } from "node:url";
+import { gunzipSync, gzipSync, inflateRawSync } from "node:zlib";
+import { mkdir, readFile, rename, rm, rmdir, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, posix, win32 } from "node:path";
+//#region ../core/dist/index.mjs
+/**
+* Plain whois over TCP port 43. The only code that opens a socket: unit tests inject a fake whois,
+* and the contract and live tests cover this.
+*/
+const tcpWhois = (server, query) => new Promise((resolve, reject) => {
+	const chunks = [];
+	const socket = connect({
+		host: server,
+		port: 43
+	}, () => {
+		socket.write(`${query}\r\n`);
+	});
+	const deadline = setTimeout(() => {
+		socket.destroy();
+		reject(Object.assign(/* @__PURE__ */ new Error(`whois ${server} timed out`), { name: "TimeoutError" }));
+	}, 1e4);
+	socket.on("close", () => clearTimeout(deadline));
+	socket.on("data", (chunk) => chunks.push(chunk));
+	socket.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+	socket.on("error", reject);
+});
+function createContext(opts) {
+	return {
+		fetch: opts.fetch ?? fetch,
+		whois: opts.whois ?? tcpWhois,
+		githubToken: opts.githubToken,
+		cache: /* @__PURE__ */ new Map(),
+		gates: /* @__PURE__ */ new Map(),
+		backoffMs: opts.backoffMs,
+		store: opts.store,
+		refresh: opts.refresh,
+		now: opts.now
+	};
+}
+async function run(name, channel, ctx, onResult) {
+	let result;
+	try {
+		result = await channel.check(name, ctx);
+	} catch (err) {
+		const timedOut = err instanceof Error && err.name === "TimeoutError";
+		result = {
+			channel: channel.id,
+			label: channel.label,
+			status: "unknown",
+			note: timedOut ? "timed out" : `request failed: ${err instanceof Error ? err.message : String(err)}`
+		};
+	}
+	onResult?.(name, result);
+	return result;
+}
+/**
+* Checks every name on every channel concurrently, sharing lookups and per-host limits across names.
+* A channel that throws becomes `unknown`, never `available`.
+*/
+function checkMany(names, channels, opts = {}) {
+	const ctx = createContext(opts);
+	return Promise.all(names.map(async (name) => ({
+		name,
+		results: await Promise.all(channels.map((c) => run(name, c, ctx, opts.onResult)))
+	})));
+}
+/** Every channel is built with this, so validation, result shape and failure handling are uniform. */
+function defineChannel(spec) {
+	return {
+		id: spec.id,
+		label: spec.label,
+		category: spec.category,
+		async check(name, ctx) {
+			const base = {
+				channel: spec.id,
+				label: spec.label
+			};
+			if (/\p{Surrogate}/u.test(name)) return {
+				...base,
+				status: "unavailable",
+				note: "names must be valid Unicode text"
+			};
+			const problem = spec.rules(name);
+			if (problem) return {
+				...base,
+				status: "unavailable",
+				note: problem
+			};
+			const result = {
+				...base,
+				...await spec.lookup(name, ctx)
+			};
+			for (const key of ["url", "note"]) {
+				const value = result[key];
+				if (typeof value !== "string" || !value.trim()) delete result[key];
+			}
+			return result;
+		}
+	};
+}
+/** The finding for a response the channel does not know how to read. */
+function unexpected(service, res) {
+	return {
+		status: "unknown",
+		note: `${service} returned HTTP ${res.status}`
+	};
+}
+/** Limits how many tasks run at once; a finishing task hands its slot straight to the next waiter. */
+var Gate = class {
+	max;
+	#active = 0;
+	#waiting = [];
+	constructor(max) {
+		this.max = max;
+	}
+	async run(task) {
+		if (this.#active < this.max) this.#active++;
+		else await new Promise((resolve) => this.#waiting.push(resolve));
+		try {
+			return await task();
+		} finally {
+			const next = this.#waiting.shift();
+			if (next) next();
+			else this.#active--;
+		}
+	}
+};
+/** Concurrent requests allowed per host. Whois servers ban bursts, so they get one. */
+const LIMITS = {
+	"registry.npmjs.org": 8,
+	"api.github.com": 4
+};
+const DEFAULT_LIMIT = 4;
+function gateFor(gates, host, max) {
+	let gate = gates.get(host);
+	if (!gate) {
+		gate = new Gate(max ?? LIMITS[host] ?? DEFAULT_LIMIT);
+		gates.set(host, gate);
+	}
+	return gate;
+}
+const USER_AGENT = "nameable (+https://www.npmjs.com/package/nameable)";
+function retryable(status) {
+	return status === 429 || status >= 500;
+}
+/**
+* GET with a timeout and retries on network errors, 429 and 5xx (not on timeouts).
+* Returns the last response when retries run out on a retryable status, and throws when every attempt failed
+* at the network level, so callers never mistake a failure for a 404.
+*/
+async function get(ctx, url, opts = {}) {
+	const { retries = 2, timeoutMs = 1e4 } = opts;
+	const backoffMs = ctx.backoffMs ?? 500;
+	const gate = gateFor(ctx.gates, new URL(url).host);
+	let lastError;
+	for (let attempt = 0; attempt <= retries; attempt++) {
+		if (attempt > 0) await new Promise((r) => setTimeout(r, backoffMs * 2 ** (attempt - 1)));
+		try {
+			const res = await gate.run(() => ctx.fetch(url, {
+				headers: {
+					"user-agent": USER_AGENT,
+					...opts.headers
+				},
+				signal: AbortSignal.timeout(timeoutMs)
+			}));
+			if (!retryable(res.status) || attempt === retries) return res;
+			lastError = /* @__PURE__ */ new Error(`HTTP ${res.status}`);
+		} catch (err) {
+			if (err instanceof Error && err.name === "TimeoutError") throw err;
+			lastError = err;
+		}
+	}
+	throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+function memo(ctx, key, load) {
+	let hit = ctx.cache.get(key);
+	if (!hit) {
+		hit = load();
+		ctx.cache.set(key, hit);
+	}
+	return hit;
+}
+/** Every list kept in the store, so clearing the cache removes exactly these files and nothing else. */
+const LIST_KEYS = [
+	"pypi-projects",
+	"homebrew-names",
+	"crates-names"
+];
+const FORMAT = 1;
+/** The first line of a stored list, naming the list and its format. */
+const listHeader = (key) => `#nameable ${key} v${FORMAT}\n`;
+/**
+* A registry-wide list (every PyPI project, every Homebrew alias), from the store when fresh enough,
+* downloaded otherwise. A failed download falls back to an older copy; with no copy at all it throws,
+* and the channel reports that it could not run the check.
+*/
+function cachedList(ctx, key, download) {
+	return memo(ctx, `list:${key}`, async () => {
+		const now = ctx.now?.() ?? Date.now();
+		const stored = await ctx.store?.read(key);
+		const saved = stored?.text.startsWith(listHeader(key)) ? {
+			...stored,
+			text: stored.text.slice(listHeader(key).length)
+		} : void 0;
+		const age = saved ? now - saved.savedAt : -1;
+		if (saved && !ctx.refresh && age >= 0 && age < 864e5) return {
+			...saved,
+			stale: false
+		};
+		try {
+			const text = await download();
+			await ctx.store?.write(key, listHeader(key) + text).catch(() => void 0);
+			return {
+				text,
+				savedAt: now,
+				stale: false
+			};
+		} catch (err) {
+			if (saved) return {
+				...saved,
+				stale: true
+			};
+			throw err;
+		}
+	});
+}
+/** The values on every line of `text` whose first tab-separated field is `key`. */
+function linesFor(text, key) {
+	const found = [];
+	const needle = `\n${key}\t`;
+	for (let at = text.indexOf(needle); at >= 0; at = text.indexOf(needle, at + 1)) {
+		const end = text.indexOf("\n", at + 1);
+		found.push(text.slice(at + needle.length, end < 0 ? void 0 : end).split("	"));
+	}
+	return found;
+}
+/** How old a stale list is, for notes. */
+const asOf = (list) => new Date(list.savedAt).toISOString().slice(0, 10);
+const END = Buffer.from([
+	80,
+	75,
+	5,
+	6
+]);
+const ENTRY = 33639248;
+const LOCAL = 67324752;
+const MAX32 = 4294967295;
+/**
+* Files named `wanted` (matched on their last path segment) from a remote zip archive, read with HTTP
+* range requests, so a few small files come out of a multi-gigabyte archive without downloading it.
+* Throws when the archive cannot be read this way (no range support, zip64, a missing file).
+*/
+async function remoteZipFiles(ctx, url, wanted) {
+	const range = async (spec) => {
+		const res = await get(ctx, url, {
+			headers: { range: `bytes=${spec}` },
+			timeoutMs: 12e4
+		});
+		if (res.status !== 206) throw new Error(`${url} answered a range request with HTTP ${res.status}`);
+		return Buffer.from(await res.arrayBuffer());
+	};
+	const tail = await range("-65557");
+	const end = tail.lastIndexOf(END);
+	if (end < 0) throw new Error(`${url} is not a zip archive`);
+	const count = tail.readUInt16LE(end + 10);
+	const size = tail.readUInt32LE(end + 12);
+	const offset = tail.readUInt32LE(end + 16);
+	if (size === MAX32 || offset === MAX32) throw new Error(`${url} is a zip64 archive`);
+	const dir = await range(`${offset}-${offset + size - 1}`);
+	const entries = [];
+	for (let at = 0, i = 0; i < count; i++) {
+		if (dir.readUInt32LE(at) !== ENTRY) throw new Error(`${url} has a broken central directory`);
+		const nameLength = dir.readUInt16LE(at + 28);
+		const name = dir.toString("utf8", at + 46, at + 46 + nameLength);
+		const file = wanted.find((w) => name === w || name.endsWith(`/${w}`));
+		if (file) entries.push({
+			file,
+			method: dir.readUInt16LE(at + 10),
+			size: dir.readUInt32LE(at + 20),
+			offset: dir.readUInt32LE(at + 42)
+		});
+		at += 46 + nameLength + dir.readUInt16LE(at + 30) + dir.readUInt16LE(at + 32);
+	}
+	const files = /* @__PURE__ */ new Map();
+	for (const e of entries) {
+		if (e.size === MAX32 || e.offset === MAX32) throw new Error(`${url} is a zip64 archive`);
+		const header = await range(`${e.offset}-${e.offset + 29}`);
+		if (header.readUInt32LE(0) !== LOCAL) throw new Error(`${url} has a broken local header`);
+		const start = e.offset + 30 + header.readUInt16LE(26) + header.readUInt16LE(28);
+		const data = e.size ? await range(`${start}-${start + e.size - 1}`) : Buffer.alloc(0);
+		if (e.method === 0) files.set(e.file, data);
+		else if (e.method === 8) files.set(e.file, inflateRawSync(data));
+		else throw new Error(`${url} uses zip compression method ${e.method}`);
+	}
+	const missing = wanted.filter((w) => !files.has(w));
+	if (missing.length) throw new Error(`${url} has no ${missing.join(", ")}`);
+	return files;
+}
+const VALID$2 = /^[a-z][a-z0-9_-]{0,63}$/i;
+const canon = (name) => name.toLowerCase().replace(/-/g, "_");
+const RESERVED = new Set([
+	"alloc",
+	"arena",
+	"ast",
+	"builtins",
+	"collections",
+	"compiler-builtins",
+	"compiler-rt",
+	"compiletest",
+	"core",
+	"coretest",
+	"debug",
+	"driver",
+	"flate",
+	"fmt_macros",
+	"grammar",
+	"graphviz",
+	"macro",
+	"macros",
+	"proc_macro",
+	"rbml",
+	"rust-installer",
+	"rustbook",
+	"rustc",
+	"rustc_back",
+	"rustc_borrowck",
+	"rustc_driver",
+	"rustc_llvm",
+	"rustc_resolve",
+	"rustc_trans",
+	"rustc_typeck",
+	"rustdoc",
+	"rustllvm",
+	"rustuv",
+	"serialize",
+	"std",
+	"syntax",
+	"test",
+	"unicode",
+	"nul",
+	"con",
+	"prn",
+	"aux",
+	"com0",
+	"com1",
+	"com2",
+	"com3",
+	"com4",
+	"com5",
+	"com6",
+	"com7",
+	"com8",
+	"com9",
+	"lpt0",
+	"lpt1",
+	"lpt2",
+	"lpt3",
+	"lpt4",
+	"lpt5",
+	"lpt6",
+	"lpt7",
+	"lpt8",
+	"lpt9"
+].map(canon));
+const DUMP = "https://static.crates.io/db-dump.zip";
+/** RFC 4180 rows as objects keyed by the header row; deletion messages hold commas, quotes and newlines. */
+function csv(text) {
+	const rows = [];
+	let row = [];
+	let field = "";
+	let quoted = false;
+	const endField = () => {
+		row.push(field);
+		field = "";
+	};
+	for (let i = 0; i < text.length; i++) {
+		const c = text[i];
+		if (quoted && c === "\"" && text[i + 1] === "\"") {
+			field += "\"";
+			i++;
+		} else if (c === "\"") quoted = !quoted;
+		else if (!quoted && c === ",") endField();
+		else if (!quoted && c === "\n") {
+			endField();
+			rows.push(row);
+			row = [];
+		} else field += c;
+	}
+	if (field || row.length) {
+		endField();
+		rows.push(row);
+	}
+	const [head = [], ...body] = rows;
+	return body.map((r) => Object.fromEntries(head.map((h, i) => [h, r[i] ?? ""])));
+}
+/** A dump timestamp (`2024-11-18 09:03:35.16643+00`) in ISO form, or undefined when it is not one. */
+const isoTime = (value = "") => /^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2}(?:\.\d+)?)\+00$/.exec(value)?.slice(1).join("T").concat("Z");
+/** Reserved names and names still blocked after a deletion, one `canon\treserved` or `canon\tdeleted\tuntil` line each. */
+async function nameList$1(ctx) {
+	const files = await remoteZipFiles(ctx, DUMP, ["reserved_crate_names.csv", "deleted_crates.csv"]);
+	const reserved = csv(files.get("reserved_crate_names.csv").toString("utf8"));
+	const deleted = csv(files.get("deleted_crates.csv").toString("utf8"));
+	if (!reserved.length || !reserved.every((r) => r.name) || !deleted.length || !deleted.every((d) => d.name && isoTime(d.available_at))) throw new Error("crates.io database dump is not in the expected shape");
+	const now = ctx.now?.() ?? Date.now();
+	const lines = reserved.map((r) => `${canon(r.name)}\treserved`);
+	for (const d of deleted) {
+		const until = isoTime(d.available_at);
+		if (Date.parse(until) > now) lines.push(`${canon(d.name)}\tdeleted\t${until}`);
+	}
+	return `\n${lines.join("\n")}\n`;
+}
+const crates = defineChannel({
+	id: "crates",
+	label: "crates.io",
+	category: "package",
+	rules: (name) => {
+		if (!VALID$2.test(name)) return "crate names start with a letter and use letters, digits, - and _ (max 64)";
+		if (RESERVED.has(canon(name))) return "crates.io reserves this name";
+	},
+	async lookup(name, ctx) {
+		const res = await get(ctx, `https://crates.io/api/v1/crates/${name}`);
+		if (res.status === 404) {
+			let list;
+			try {
+				list = await cachedList(ctx, "crates-names", () => nameList$1(ctx));
+			} catch {
+				return {
+					status: "available",
+					certainty: "probable",
+					note: "could not read crates.io's database dump to check reserved and recently deleted names"
+				};
+			}
+			const now = ctx.now?.() ?? Date.now();
+			for (const [kind, until] of linesFor(list.text, canon(name))) {
+				if (kind === "reserved") return {
+					status: "unavailable",
+					note: "crates.io reserves this name"
+				};
+				if (kind === "deleted" && Date.parse(until) > now) return {
+					status: "unavailable",
+					note: `recently deleted; crates.io frees the name after ${until.slice(0, 16).replace("T", " ")} UTC`
+				};
+			}
+			return list.stale ? {
+				status: "available",
+				certainty: "probable",
+				note: `checked against crates.io's database dump from ${asOf(list)}`
+			} : {
+				status: "available",
+				certainty: "confirmed"
+			};
+		}
+		if (res.status !== 200) return unexpected("crates.io", res);
+		const { crate } = await res.json();
+		return {
+			status: "taken",
+			url: `https://crates.io/crates/${crate.name}`,
+			note: crate.description?.trim() || void 0,
+			meta: {
+				name: crate.name,
+				updated: crate.updated_at,
+				downloads: crate.downloads
+			}
+		};
+	}
+});
+const IANA = "whois.iana.org";
+/** One query, at most one at a time per server: whois servers ban bursts. */
+function whoisQuery(ctx, server, query) {
+	return gateFor(ctx.gates, `whois:${server}`, 1).run(() => ctx.whois(server, query));
+}
+/** The registry's whois server for a TLD, as IANA refers it, or undefined when it lists none. */
+function whoisServer(ctx, tld) {
+	return memo(ctx, `whois-server:${tld}`, async () => {
+		const text = await whoisQuery(ctx, IANA, tld);
+		return /^whois:[ \t]*(\S+)/im.exec(text)?.[1];
+	});
+}
+const FREE = [
+	/^domain not found/im,
+	/^not found/im,
+	/^no match/im,
+	/^no data found/im,
+	/^no entries found/im,
+	/^the queried object does not exist/im,
+	/^status:\s*free\s*$/im,
+	/^status:\s*available\s*$/im
+];
+const REGISTERED = [
+	/^domain name:\s*\S/im,
+	/^domain:\s*\S/im,
+	/^\[domain name\]\s*\S/im
+];
+const NOTICE = /^\s*(%|#|>>>|\[ |NOTICE|TERMS)/;
+function readWhois(text) {
+	const body = text.split(/\r?\n/).filter((line) => !NOTICE.test(line)).map((line) => line.trim()).join("\n");
+	if (FREE.some((re) => re.test(body))) return "free";
+	if (REGISTERED.some((re) => re.test(body))) return "registered";
+	return "unrecognized";
+}
+const BOOTSTRAP = "https://data.iana.org/rdap/dns.json";
+const LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+/** RDAP base URL for a TLD from IANA's bootstrap registry, or undefined when the TLD has no RDAP service. */
+async function rdapBase(ctx, tld) {
+	const service = (await memo(ctx, BOOTSTRAP, async () => {
+		const res = await get(ctx, BOOTSTRAP);
+		if (!res.ok) throw new Error(`IANA RDAP bootstrap returned HTTP ${res.status}`);
+		return await res.json();
+	})).services.find(([tlds]) => tlds.includes(tld));
+	const url = service?.[1].find((u) => u.startsWith("https://")) ?? service?.[1][0];
+	return url && (url.endsWith("/") ? url : `${url}/`);
+}
+async function viaWhois(ctx, fqdn, tld, url) {
+	const base = { url };
+	const server = await whoisServer(ctx, tld);
+	if (!server) return {
+		...base,
+		status: "unknown",
+		note: `.${tld} has neither RDAP nor whois`
+	};
+	const text = await whoisQuery(ctx, server, fqdn);
+	const answer = readWhois(text);
+	if (answer === "free") return {
+		...base,
+		status: "available",
+		certainty: "probable",
+		note: freeNote(tld, " (whois)")
+	};
+	if (answer === "registered") {
+		const registered = /^\s*(?:creation date|created|registered on):\s*(\d{4}-\d{2}-\d{2})/im.exec(text)?.[1];
+		return {
+			...base,
+			status: "taken",
+			note: registered ? `registered ${registered} (whois)` : "registered (whois)",
+			meta: {
+				registered,
+				whois: server
+			}
+		};
+	}
+	return {
+		...base,
+		status: "unknown",
+		note: `unrecognized whois answer from ${server}`
+	};
+}
+/** Why a free answer is still only probable. IDN TLDs (`xn--…`) also limit which scripts they take. */
+const freeNote = (tld, via) => `not registered${via}; premium or reserved names can still be refused` + (tld.startsWith("xn--") ? ", and this TLD accepts only some scripts" : "") + ", confirm at a registrar";
+/** `tld` is in its ASCII (punycode) form; `display` is how to show it. */
+function domain(tld, display = tld) {
+	return defineChannel({
+		id: `domain:${tld}`,
+		label: `.${display}`,
+		category: "domain",
+		rules: (name) => {
+			const ascii = domainToASCII(name);
+			const unicode = domainToUnicode(ascii);
+			if (/\P{ASCII}/u.test(unicode) && /[^\p{L}\p{M}\p{N}-]/u.test(unicode)) return "internationalized domain labels may only use letters, marks and digits (no emoji or symbols)";
+			if (!LABEL.test(ascii)) return "domain labels are letters, digits and inner hyphens (max 63)";
+			if (ascii.slice(2, 4) === "--" && !ascii.startsWith("xn--")) return "domain labels cannot have \"--\" in the 3rd and 4th position";
+		},
+		async lookup(name, ctx) {
+			const fqdn = `${domainToASCII(name)}.${tld}`;
+			const url = `https://lookup.icann.org/en/lookup?name=${fqdn}`;
+			const rdap = await rdapBase(ctx, tld).catch(() => void 0);
+			if (!rdap) return viaWhois(ctx, fqdn, tld, url);
+			const res = await get(ctx, `${rdap}domain/${fqdn}`, { headers: { accept: "application/rdap+json" } });
+			if (res.status === 404) return {
+				status: "available",
+				certainty: "probable",
+				url,
+				note: freeNote(tld, "")
+			};
+			if (res.status !== 200) return {
+				...unexpected("RDAP", res),
+				url
+			};
+			const doc = await res.json();
+			const event = (action) => doc.events?.find((e) => e.eventAction === action)?.eventDate.slice(0, 10);
+			const registered = event("registration");
+			const expires = event("expiration");
+			return {
+				status: "taken",
+				url,
+				note: [registered && `registered ${registered}`, expires && `expires ${expires}`].filter(Boolean).join(", ") || void 0,
+				meta: {
+					registered,
+					expires
+				}
+			};
+		}
+	});
+}
+const VALID$1 = /^[a-z0-9](?:[a-z0-9]|-(?=[a-z0-9])){0,38}$/i;
+const github = defineChannel({
+	id: "github",
+	label: "GitHub user/org",
+	category: "code",
+	rules: (name) => VALID$1.test(name) ? void 0 : "GitHub names are letters, digits and single inner hyphens (max 39)",
+	async lookup(name, ctx) {
+		const headers = { accept: "application/vnd.github+json" };
+		if (ctx.githubToken) headers.authorization = `Bearer ${ctx.githubToken}`;
+		const res = await get(ctx, `https://api.github.com/users/${name}`, { headers });
+		if (res.status === 200) {
+			const user = await res.json();
+			return {
+				status: "taken",
+				url: `https://github.com/${user.login}`,
+				note: `${user.type}, ${user.public_repos} public repos, updated ${user.updated_at.slice(0, 10)}`,
+				meta: {
+					type: user.type,
+					publicRepos: user.public_repos,
+					updated: user.updated_at
+				}
+			};
+		}
+		if (res.status === 404) return {
+			status: "available",
+			certainty: "probable",
+			note: "suspended, deleted or reserved accounts also look free; confirm on GitHub's sign-up page"
+		};
+		if (res.status === 401) return {
+			status: "unknown",
+			note: "GitHub rejected the token (HTTP 401); check GITHUB_TOKEN"
+		};
+		if (res.status === 403 || res.status === 429) return {
+			status: "unknown",
+			note: "rate limited; set GITHUB_TOKEN or log in with `gh auth login`"
+		};
+		return unexpected("GitHub", res);
+	}
+});
+const API = "https://formulae.brew.sh/api";
+function auditorProblem(name) {
+	if (/[A-Z]/.test(name)) return "uppercase letters";
+	if (/\s/.test(name)) return "whitespace";
+	if (/[^\x20-\x7e]/.test(name)) return "non-ASCII characters";
+	if (name.includes("--")) return "double hyphens";
+	if (name.startsWith("@")) return "a leading @";
+	if (name.endsWith("@")) return "a trailing @";
+	if (name.startsWith("-")) return "a leading hyphen";
+	if (name.endsWith("-")) return "a trailing hyphen";
+	if ((name.match(/@/g) ?? []).length > 1) return "multiple @ symbols";
+	if (name.includes("-@")) return "a hyphen followed by an @";
+	if (name.includes("@-")) return "an @ followed by a hyphen";
+}
+const formulaClass = (name) => (name.charAt(0).toUpperCase() + name.slice(1)).replace(/[-_.\s]([a-zA-Z0-9])/g, (_, c) => c.toUpperCase()).replaceAll("+", "x").replace(/(.)@(\d)/, "$1AT$2");
+const CONSTANT = /^[A-Z]\w*$/;
+const DISALLOWED = /^(?:gem|rubygems?|pip|pil|macruby|gsutil|gfortran|play|haskell-platform|mysqldump-secure|ngrok|cargo|cargo-completion|uconv|postgresql|postgres)$/;
+const disallowed = (name) => DISALLOWED.test(name) || /(?:lib)?lzma/.test(name);
+/**
+* Every name homebrew/core and homebrew/cask hold: formulae with their aliases and old names, casks with
+* their old tokens, one `name\tkind\ttarget` line each (about 7 MB to download).
+*/
+async function nameList(ctx) {
+	const load = async (path) => {
+		const res = await get(ctx, `${API}/${path}`, { timeoutMs: 12e4 });
+		if (!res.ok) throw new Error(`Homebrew ${path} returned HTTP ${res.status}`);
+		return res.json();
+	};
+	const [formulae, casks] = await Promise.all([load("formula.json"), load("cask.json")]);
+	const isList = (x, key, arrays) => Array.isArray(x) && x.length > 0 && x.every((e) => typeof e?.[key] === "string" && arrays.every((a) => Array.isArray(e[a])));
+	if (!isList(formulae, "name", ["aliases", "oldnames"]) || !isList(casks, "token", ["old_tokens"])) throw new Error("Homebrew name lists are not in the expected shape");
+	const lines = [];
+	for (const f of formulae) {
+		lines.push(`${f.name}\tformula\t${f.name}`);
+		for (const a of f.aliases) lines.push(`${a}\talias\t${f.name}`);
+		for (const o of f.oldnames) lines.push(`${o}\told name\t${f.name}`);
+	}
+	for (const c of casks) {
+		lines.push(`${c.token}\tcask\t${c.token}`);
+		for (const o of c.old_tokens) lines.push(`${o}\told cask token\t${c.token}`);
+	}
+	return `\n${lines.join("\n")}\n`;
+}
+const homebrew = defineChannel({
+	id: "homebrew",
+	label: "Homebrew",
+	category: "package",
+	rules: (name) => {
+		if (!name) return "Homebrew names cannot be empty";
+		const problem = auditorProblem(name);
+		if (problem) return `Homebrew names must not contain ${problem}`;
+		if (!CONSTANT.test(formulaClass(name))) return "Homebrew formula names start with a letter and use letters, digits, + . _ - and @ before a version";
+		if (disallowed(name)) return "homebrew/core does not allow this name";
+	},
+	async lookup(name, ctx) {
+		const [formula, cask] = await Promise.all([get(ctx, `${API}/formula/${name}.json`), get(ctx, `${API}/cask/${name}.json`)]);
+		for (const [kind, res] of [["formula", formula], ["cask", cask]]) if (res.status === 200) {
+			const { desc } = await res.json();
+			return {
+				status: "taken",
+				url: `https://formulae.brew.sh/${kind}/${name}`,
+				note: desc,
+				meta: { kind }
+			};
+		}
+		if (formula.status !== 404 || cask.status !== 404) return {
+			status: "unknown",
+			note: `Homebrew API returned HTTP ${formula.status}/${cask.status}`
+		};
+		let list;
+		try {
+			list = await cachedList(ctx, "homebrew-names", () => nameList(ctx));
+		} catch {
+			return {
+				status: "available",
+				certainty: "probable",
+				note: "could not download Homebrew's alias list to check aliases and old names"
+			};
+		}
+		const [hit] = linesFor(list.text, name);
+		if (hit) {
+			const [kind, target] = hit;
+			return {
+				status: "taken",
+				url: `https://formulae.brew.sh/${kind.includes("cask") ? "cask" : "formula"}/${target}`,
+				note: target === name ? void 0 : `${kind} of ${target}`,
+				meta: {
+					kind,
+					target
+				}
+			};
+		}
+		return list.stale ? {
+			status: "available",
+			certainty: "probable",
+			note: `checked against Homebrew's names from ${asOf(list)}`
+		} : {
+			status: "available",
+			certainty: "confirmed",
+			note: "no homebrew-core formula or cask"
+		};
+	}
+});
+const REGISTRY = "https://registry.npmjs.org";
+const EXCLUDED = /* @__PURE__ */ new Set(["node_modules", "favicon.ico"]);
+const SCOPED = /^(?:@([^/]+?)[/])?([^/]+?)$/;
+/**
+* validate-npm-package-name's `validForNewPackages` (lib/index.js, v7): a new package must have no
+* errors and no warnings. Returns the first reason, in the validator's order.
+*/
+function problem(name) {
+	if (!name.length) return "npm names cannot be empty";
+	if (name.startsWith(".")) return "npm names cannot start with a period";
+	if (name.startsWith("-")) return "npm names cannot start with a hyphen";
+	if (name.startsWith("_")) return "npm names cannot start with an underscore";
+	if (name.trim() !== name) return "npm names cannot have leading or trailing spaces";
+	if (EXCLUDED.has(name.toLowerCase())) return `${name} is not a valid npm name`;
+	if (builtinModules.includes(name.toLowerCase())) return "npm reserves Node.js core module names";
+	if (name.length > 214) return "npm names are at most 214 characters";
+	if (name.toLowerCase() !== name) return "npm names must be lowercase";
+	if (/[~'!()*]/.test(name.split("/").at(-1))) return "npm names cannot contain ~ ' ! ( ) *";
+	if (encodeURIComponent(name) !== name) {
+		const match = SCOPED.exec(name);
+		const [user, pkg] = [match?.[1], match?.[2]];
+		if (match && pkg?.startsWith(".")) return "npm names cannot start with a period";
+		const urlSafe = (s) => s !== void 0 && encodeURIComponent(s) === s;
+		if (!(match && urlSafe(user) && urlSafe(pkg))) return "npm names may only contain URL-safe characters";
+	}
+}
+const squash = (s) => s.replace(/[-_.]/g, "");
+/**
+* npm refuses an unscoped name that equals an existing package once punctuation is removed
+* (`first-one` vs `firstone`, `babelpresetenv` vs `babel-preset-env`). The registry has no lookup for
+* that, so this catches the common cases: it searches both spellings (search does not surface
+* `firstone` for `first-one`) and, for a name without punctuation, probes every single-hyphen
+* spelling (search never surfaces `lodash-es` for `lodashes`). Spellings with several separators
+* cannot all be probed, so a name that passes is only probably free.
+*/
+const SEARCH_LENGTH = {
+	min: 2,
+	max: 64
+};
+const MAX_PROBED_LENGTH = 40;
+async function similar(ctx, name) {
+	const queries = [.../* @__PURE__ */ new Set([name, squash(name)])].filter((q) => q.length >= SEARCH_LENGTH.min && q.length <= SEARCH_LENGTH.max);
+	const found = (await Promise.all(queries.map(async (q) => {
+		const res = await get(ctx, `${REGISTRY}/-/v1/search?text=${encodeURIComponent(q)}&size=50`);
+		if (!res.ok) throw new Error(`search HTTP ${res.status}`);
+		return (await res.json()).objects;
+	}))).flat().map((o) => o.package.name).find((n) => !n.startsWith("@") && n !== name && squash(n) === squash(name));
+	if (found || name !== squash(name) || name.length > MAX_PROBED_LENGTH) return found;
+	const hyphenated = Array.from({ length: name.length - 1 }, (_, i) => `${name.slice(0, i + 1)}-${name.slice(i + 1)}`);
+	return (await Promise.all(hyphenated.map(async (variant) => {
+		const res = await get(ctx, `${REGISTRY}/${variant}`, { headers: { accept: "application/vnd.npm.install-v1+json" } });
+		if (res.status !== 200 && res.status !== 404) throw new Error(`registry HTTP ${res.status}`);
+		return res.status === 200 ? variant : void 0;
+	}))).find(Boolean);
+}
+/** Only the npm user or organization named after a scope can publish under it. */
+async function scopeNote(ctx, scope) {
+	if ((await get(ctx, `${REGISTRY}/-/org/${encodeURIComponent(scope)}/package`).catch(() => void 0))?.status === 200) return `@${scope} is an npm organization; only its members can publish under it`;
+	return `only the npm user or organization "${scope}" can publish under @${scope}`;
+}
+const npm = defineChannel({
+	id: "npm",
+	label: "npm",
+	category: "package",
+	rules: problem,
+	async lookup(name, ctx) {
+		const url = `https://www.npmjs.com/package/${name}`;
+		const res = await get(ctx, `${REGISTRY}/${name.replace("/", "%2f")}`);
+		if (res.status === 200) {
+			const doc = await res.json();
+			if (!doc.versions && doc.time?.unpublished) {
+				const at = doc.time.unpublished.time;
+				const until = Date.parse(at) + 864e5;
+				if (!((ctx.now?.() ?? Date.now()) >= until)) return {
+					status: "unavailable",
+					url,
+					note: `unpublished on ${at.slice(0, 10)}; npm blocks the name until ${new Date(until).toISOString().slice(0, 16).replace("T", " ")} UTC`
+				};
+				return {
+					status: "reclaimable",
+					url,
+					note: `unpublished on ${at.slice(0, 10)}; anyone can publish it again`
+				};
+			}
+			return {
+				status: "taken",
+				url,
+				note: doc.description,
+				meta: {
+					latest: doc["dist-tags"]?.latest,
+					modified: doc.time?.modified
+				}
+			};
+		}
+		if (res.status !== 404) return unexpected("npm registry", res);
+		const scope = SCOPED.exec(name)?.[1];
+		if (scope) return {
+			status: "available",
+			certainty: "probable",
+			note: await scopeNote(ctx, scope)
+		};
+		try {
+			const clash = await similar(ctx, name);
+			if (clash) return {
+				status: "unavailable",
+				note: `npm rejects names too similar to "${clash}"`
+			};
+			return {
+				status: "available",
+				certainty: "probable",
+				note: "npm also refuses names equal to an existing one without punctuation; not every spelling can be checked"
+			};
+		} catch {
+			return {
+				status: "available",
+				certainty: "probable",
+				note: "could not check npm's similar-name rule"
+			};
+		}
+	}
+});
+const PYPI_STDLIB = /* @__PURE__ */ new Set([
+	"abc",
+	"abcoll",
+	"aepack",
+	"aetools",
+	"aetypes",
+	"aifc",
+	"aix-support",
+	"al",
+	"android-support",
+	"annotationlib",
+	"antigravity",
+	"anydbm",
+	"apple-support",
+	"applesingle",
+	"argparse",
+	"array",
+	"ast",
+	"ast-unparse",
+	"asynchat",
+	"asyncio",
+	"asyncio-base-events",
+	"asyncio-base-futures",
+	"asyncio-base-subprocess",
+	"asyncio-base-tasks",
+	"asyncio-compat",
+	"asyncio-constants",
+	"asyncio-coroutines",
+	"asyncio-events",
+	"asyncio-exceptions",
+	"asyncio-format-helpers",
+	"asyncio-futures",
+	"asyncio-graph",
+	"asyncio-locks",
+	"asyncio-log",
+	"asyncio-main",
+	"asyncio-mixins",
+	"asyncio-proactor-events",
+	"asyncio-protocols",
+	"asyncio-queues",
+	"asyncio-runners",
+	"asyncio-selector-events",
+	"asyncio-sslproto",
+	"asyncio-staggered",
+	"asyncio-streams",
+	"asyncio-subprocess",
+	"asyncio-taskgroups",
+	"asyncio-tasks",
+	"asyncio-test-utils",
+	"asyncio-threads",
+	"asyncio-timeouts",
+	"asyncio-tools",
+	"asyncio-transports",
+	"asyncio-trsock",
+	"asyncio-unix-events",
+	"asyncio-windows-events",
+	"asyncio-windows-utils",
+	"asyncore",
+	"atexit",
+	"audiodev",
+	"audioop",
+	"autogil",
+	"base64",
+	"basehttpserver",
+	"bastion",
+	"bdb",
+	"binascii",
+	"binhex",
+	"bisect",
+	"blake2",
+	"bootlocale",
+	"bootsubprocess",
+	"bsddb",
+	"bsddb-db",
+	"bsddb-dbobj",
+	"bsddb-dbrecio",
+	"bsddb-dbshelve",
+	"bsddb-dbtables",
+	"bsddb-dbutils",
+	"bsddb-test",
+	"bsddb-test-test-all",
+	"bsddb-test-test-associate",
+	"bsddb-test-test-basics",
+	"bsddb-test-test-compare",
+	"bsddb-test-test-compat",
+	"bsddb-test-test-cursor-pget-bug",
+	"bsddb-test-test-db",
+	"bsddb-test-test-dbenv",
+	"bsddb-test-test-dbobj",
+	"bsddb-test-test-dbshelve",
+	"bsddb-test-test-dbtables",
+	"bsddb-test-test-distributed-transactions",
+	"bsddb-test-test-early-close",
+	"bsddb-test-test-fileid",
+	"bsddb-test-test-get-none",
+	"bsddb-test-test-join",
+	"bsddb-test-test-lock",
+	"bsddb-test-test-misc",
+	"bsddb-test-test-pickle",
+	"bsddb-test-test-queue",
+	"bsddb-test-test-recno",
+	"bsddb-test-test-replication",
+	"bsddb-test-test-sequence",
+	"bsddb-test-test-thread",
+	"buildtools",
+	"builtin",
+	"builtins",
+	"bz2",
+	"calendar",
+	"canvas",
+	"carbon",
+	"carbon-ae",
+	"carbon-ah",
+	"carbon-app",
+	"carbon-appearance",
+	"carbon-carbonevents",
+	"carbon-carbonevt",
+	"carbon-cf",
+	"carbon-cg",
+	"carbon-cm",
+	"carbon-components",
+	"carbon-controlaccessor",
+	"carbon-controls",
+	"carbon-corefounation",
+	"carbon-coregraphics",
+	"carbon-ctl",
+	"carbon-dialogs",
+	"carbon-dlg",
+	"carbon-drag",
+	"carbon-dragconst",
+	"carbon-events",
+	"carbon-evt",
+	"carbon-file",
+	"carbon-files",
+	"carbon-fm",
+	"carbon-folder",
+	"carbon-folders",
+	"carbon-fonts",
+	"carbon-help",
+	"carbon-ibcarbon",
+	"carbon-ibcarbonruntime",
+	"carbon-icns",
+	"carbon-icons",
+	"carbon-launch",
+	"carbon-launchservices",
+	"carbon-list",
+	"carbon-lists",
+	"carbon-machelp",
+	"carbon-mediadescr",
+	"carbon-menu",
+	"carbon-menus",
+	"carbon-mlte",
+	"carbon-osa",
+	"carbon-osaconst",
+	"carbon-qd",
+	"carbon-qdoffs",
+	"carbon-qdoffscreen",
+	"carbon-qt",
+	"carbon-quickdraw",
+	"carbon-quicktime",
+	"carbon-res",
+	"carbon-resources",
+	"carbon-scrap",
+	"carbon-snd",
+	"carbon-sound",
+	"carbon-te",
+	"carbon-textedit",
+	"carbon-win",
+	"carbon-windows",
+	"cd",
+	"cfmfile",
+	"cgi",
+	"cgihttpserver",
+	"cgitb",
+	"chunk",
+	"cmath",
+	"cmd",
+	"code",
+	"codecs",
+	"codecs-cn",
+	"codecs-hk",
+	"codecs-iso2022",
+	"codecs-jp",
+	"codecs-kr",
+	"codecs-tw",
+	"codeop",
+	"collections",
+	"collections-abc",
+	"collections-main",
+	"colorize",
+	"colorpicker",
+	"colorsys",
+	"commands",
+	"compat-pickle",
+	"compileall",
+	"compiler",
+	"compiler-ast",
+	"compiler-consts",
+	"compiler-future",
+	"compiler-misc",
+	"compiler-pyassem",
+	"compiler-pycodegen",
+	"compiler-symbols",
+	"compiler-syntax",
+	"compiler-transformer",
+	"compiler-visitor",
+	"compression",
+	"compression-bz2",
+	"compression-common",
+	"compression-common-streams",
+	"compression-gzip",
+	"compression-lzma",
+	"compression-zlib",
+	"compression-zstd",
+	"compression-zstd-zstdfile",
+	"concurrent",
+	"concurrent-futures",
+	"concurrent-futures-base",
+	"concurrent-futures-interpreter",
+	"concurrent-futures-process",
+	"concurrent-futures-thread",
+	"concurrent-interpreters",
+	"concurrent-interpreters-crossinterp",
+	"concurrent-interpreters-queues",
+	"configparser",
+	"contextlib",
+	"contextvars",
+	"cookie",
+	"cookielib",
+	"copy",
+	"copy-reg",
+	"copyreg",
+	"cpickle",
+	"cprofile",
+	"crypt",
+	"cstringio",
+	"csv",
+	"ctypes",
+	"ctypes-aix",
+	"ctypes-endian",
+	"ctypes-layout",
+	"ctypes-macholib",
+	"ctypes-macholib-dyld",
+	"ctypes-macholib-dylib",
+	"ctypes-macholib-framework",
+	"ctypes-test",
+	"ctypes-test-main",
+	"ctypes-test-runtests",
+	"ctypes-test-test-anon",
+	"ctypes-test-test-array-in-pointer",
+	"ctypes-test-test-arrays",
+	"ctypes-test-test-as-parameter",
+	"ctypes-test-test-bitfields",
+	"ctypes-test-test-buffers",
+	"ctypes-test-test-bytes",
+	"ctypes-test-test-byteswap",
+	"ctypes-test-test-callbacks",
+	"ctypes-test-test-cast",
+	"ctypes-test-test-cfuncs",
+	"ctypes-test-test-checkretval",
+	"ctypes-test-test-delattr",
+	"ctypes-test-test-errno",
+	"ctypes-test-test-find",
+	"ctypes-test-test-frombuffer",
+	"ctypes-test-test-funcptr",
+	"ctypes-test-test-functions",
+	"ctypes-test-test-incomplete",
+	"ctypes-test-test-init",
+	"ctypes-test-test-internals",
+	"ctypes-test-test-keeprefs",
+	"ctypes-test-test-libc",
+	"ctypes-test-test-loading",
+	"ctypes-test-test-macholib",
+	"ctypes-test-test-memfunctions",
+	"ctypes-test-test-numbers",
+	"ctypes-test-test-objects",
+	"ctypes-test-test-parameters",
+	"ctypes-test-test-pep3118",
+	"ctypes-test-test-pickling",
+	"ctypes-test-test-pointers",
+	"ctypes-test-test-prototypes",
+	"ctypes-test-test-python-api",
+	"ctypes-test-test-random-things",
+	"ctypes-test-test-refcounts",
+	"ctypes-test-test-repr",
+	"ctypes-test-test-returnfuncptrs",
+	"ctypes-test-test-simplesubclasses",
+	"ctypes-test-test-sizes",
+	"ctypes-test-test-slicing",
+	"ctypes-test-test-stringptr",
+	"ctypes-test-test-strings",
+	"ctypes-test-test-struct-fields",
+	"ctypes-test-test-structures",
+	"ctypes-test-test-unaligned-structures",
+	"ctypes-test-test-unicode",
+	"ctypes-test-test-values",
+	"ctypes-test-test-varsize-struct",
+	"ctypes-test-test-win32",
+	"ctypes-test-test-wintypes",
+	"ctypes-util",
+	"ctypes-wintypes",
+	"curses",
+	"curses-ascii",
+	"curses-has-key",
+	"curses-panel",
+	"curses-textpad",
+	"curses-wrapper",
+	"dataclasses",
+	"datetime",
+	"dbhash",
+	"dbm",
+	"dbm-dumb",
+	"dbm-gnu",
+	"dbm-ndbm",
+	"dbm-sqlite3",
+	"decimal",
+	"device",
+	"dialog",
+	"difflib",
+	"dircache",
+	"dis",
+	"distutils",
+	"distutils-archive-util",
+	"distutils-bcppcompiler",
+	"distutils-ccompiler",
+	"distutils-cmd",
+	"distutils-collections",
+	"distutils-command",
+	"distutils-command-bdist",
+	"distutils-command-bdist-dumb",
+	"distutils-command-bdist-msi",
+	"distutils-command-bdist-packager",
+	"distutils-command-bdist-rpm",
+	"distutils-command-bdist-wininst",
+	"distutils-command-build",
+	"distutils-command-build-clib",
+	"distutils-command-build-ext",
+	"distutils-command-build-py",
+	"distutils-command-build-scripts",
+	"distutils-command-check",
+	"distutils-command-clean",
+	"distutils-command-config",
+	"distutils-command-framework-compat",
+	"distutils-command-install",
+	"distutils-command-install-data",
+	"distutils-command-install-egg-info",
+	"distutils-command-install-headers",
+	"distutils-command-install-lib",
+	"distutils-command-install-scripts",
+	"distutils-command-py37compat",
+	"distutils-command-register",
+	"distutils-command-sdist",
+	"distutils-command-upload",
+	"distutils-config",
+	"distutils-core",
+	"distutils-cygwinccompiler",
+	"distutils-debug",
+	"distutils-dep-util",
+	"distutils-dir-util",
+	"distutils-dist",
+	"distutils-emxccompiler",
+	"distutils-errors",
+	"distutils-extension",
+	"distutils-fancy-getopt",
+	"distutils-file-util",
+	"distutils-filelist",
+	"distutils-functools",
+	"distutils-log",
+	"distutils-macos-compat",
+	"distutils-msvc9compiler",
+	"distutils-msvccompiler",
+	"distutils-mwerkscompiler",
+	"distutils-py38compat",
+	"distutils-py39compat",
+	"distutils-spawn",
+	"distutils-sysconfig",
+	"distutils-tests",
+	"distutils-tests-setuptools-build-ext",
+	"distutils-tests-setuptools-extension",
+	"distutils-tests-support",
+	"distutils-tests-test-archive-util",
+	"distutils-tests-test-bdist",
+	"distutils-tests-test-bdist-dumb",
+	"distutils-tests-test-bdist-msi",
+	"distutils-tests-test-bdist-rpm",
+	"distutils-tests-test-bdist-wininst",
+	"distutils-tests-test-build",
+	"distutils-tests-test-build-clib",
+	"distutils-tests-test-build-ext",
+	"distutils-tests-test-build-py",
+	"distutils-tests-test-build-scripts",
+	"distutils-tests-test-ccompiler",
+	"distutils-tests-test-check",
+	"distutils-tests-test-clean",
+	"distutils-tests-test-cmd",
+	"distutils-tests-test-config",
+	"distutils-tests-test-config-cmd",
+	"distutils-tests-test-core",
+	"distutils-tests-test-cygwinccompiler",
+	"distutils-tests-test-dep-util",
+	"distutils-tests-test-dir-util",
+	"distutils-tests-test-dist",
+	"distutils-tests-test-extension",
+	"distutils-tests-test-file-util",
+	"distutils-tests-test-filelist",
+	"distutils-tests-test-install",
+	"distutils-tests-test-install-data",
+	"distutils-tests-test-install-headers",
+	"distutils-tests-test-install-lib",
+	"distutils-tests-test-install-scripts",
+	"distutils-tests-test-log",
+	"distutils-tests-test-msvc9compiler",
+	"distutils-tests-test-msvccompiler",
+	"distutils-tests-test-register",
+	"distutils-tests-test-sdist",
+	"distutils-tests-test-spawn",
+	"distutils-tests-test-sysconfig",
+	"distutils-tests-test-text-file",
+	"distutils-tests-test-unixccompiler",
+	"distutils-tests-test-upload",
+	"distutils-tests-test-util",
+	"distutils-tests-test-version",
+	"distutils-tests-test-versionpredicate",
+	"distutils-text-file",
+	"distutils-unixccompiler",
+	"distutils-util",
+	"distutils-version",
+	"distutils-versionpredicate",
+	"dl",
+	"doctest",
+	"docxmlrpcserver",
+	"dumbdbm",
+	"dummy-thread",
+	"dummy-threading",
+	"easydialogs",
+	"elementtree",
+	"email",
+	"email-base64mime",
+	"email-charset",
+	"email-contentmanager",
+	"email-encoded-words",
+	"email-encoders",
+	"email-errors",
+	"email-feedparser",
+	"email-generator",
+	"email-header",
+	"email-header-value-parser",
+	"email-headerregistry",
+	"email-iterators",
+	"email-message",
+	"email-mime",
+	"email-mime-application",
+	"email-mime-audio",
+	"email-mime-base",
+	"email-mime-image",
+	"email-mime-message",
+	"email-mime-multipart",
+	"email-mime-nonmultipart",
+	"email-mime-text",
+	"email-parseaddr",
+	"email-parser",
+	"email-policy",
+	"email-policybase",
+	"email-quoprimime",
+	"email-test",
+	"email-test-test-email",
+	"email-test-test-email-codecs",
+	"email-test-test-email-codecs-renamed",
+	"email-test-test-email-renamed",
+	"email-test-test-email-torture",
+	"email-utils",
+	"encodings",
+	"encodings-aliases",
+	"encodings-ascii",
+	"encodings-base64-codec",
+	"encodings-big5",
+	"encodings-big5hkscs",
+	"encodings-builtin",
+	"encodings-bz2-codec",
+	"encodings-charmap",
+	"encodings-codecs",
+	"encodings-cp037",
+	"encodings-cp1006",
+	"encodings-cp1026",
+	"encodings-cp1125",
+	"encodings-cp1140",
+	"encodings-cp1250",
+	"encodings-cp1251",
+	"encodings-cp1252",
+	"encodings-cp1253",
+	"encodings-cp1254",
+	"encodings-cp1255",
+	"encodings-cp1256",
+	"encodings-cp1257",
+	"encodings-cp1258",
+	"encodings-cp273",
+	"encodings-cp424",
+	"encodings-cp437",
+	"encodings-cp500",
+	"encodings-cp65001",
+	"encodings-cp720",
+	"encodings-cp737",
+	"encodings-cp775",
+	"encodings-cp850",
+	"encodings-cp852",
+	"encodings-cp855",
+	"encodings-cp856",
+	"encodings-cp857",
+	"encodings-cp858",
+	"encodings-cp860",
+	"encodings-cp861",
+	"encodings-cp862",
+	"encodings-cp863",
+	"encodings-cp864",
+	"encodings-cp865",
+	"encodings-cp866",
+	"encodings-cp869",
+	"encodings-cp874",
+	"encodings-cp875",
+	"encodings-cp932",
+	"encodings-cp949",
+	"encodings-cp950",
+	"encodings-encodings",
+	"encodings-euc-jis-2004",
+	"encodings-euc-jisx0213",
+	"encodings-euc-jp",
+	"encodings-euc-kr",
+	"encodings-gb18030",
+	"encodings-gb2312",
+	"encodings-gbk",
+	"encodings-hex-codec",
+	"encodings-hp-roman8",
+	"encodings-hz",
+	"encodings-idna",
+	"encodings-iso2022-jp",
+	"encodings-iso2022-jp-1",
+	"encodings-iso2022-jp-2",
+	"encodings-iso2022-jp-2004",
+	"encodings-iso2022-jp-3",
+	"encodings-iso2022-jp-ext",
+	"encodings-iso2022-kr",
+	"encodings-iso8859-1",
+	"encodings-iso8859-10",
+	"encodings-iso8859-11",
+	"encodings-iso8859-13",
+	"encodings-iso8859-14",
+	"encodings-iso8859-15",
+	"encodings-iso8859-16",
+	"encodings-iso8859-2",
+	"encodings-iso8859-3",
+	"encodings-iso8859-4",
+	"encodings-iso8859-5",
+	"encodings-iso8859-6",
+	"encodings-iso8859-7",
+	"encodings-iso8859-8",
+	"encodings-iso8859-9",
+	"encodings-johab",
+	"encodings-koi8-r",
+	"encodings-koi8-t",
+	"encodings-koi8-u",
+	"encodings-kz1048",
+	"encodings-latin-1",
+	"encodings-mac-arabic",
+	"encodings-mac-centeuro",
+	"encodings-mac-croatian",
+	"encodings-mac-cyrillic",
+	"encodings-mac-farsi",
+	"encodings-mac-greek",
+	"encodings-mac-iceland",
+	"encodings-mac-latin2",
+	"encodings-mac-roman",
+	"encodings-mac-romanian",
+	"encodings-mac-turkish",
+	"encodings-mbcs",
+	"encodings-oem",
+	"encodings-palmos",
+	"encodings-ptcp154",
+	"encodings-punycode",
+	"encodings-quopri-codec",
+	"encodings-raw-unicode-escape",
+	"encodings-rot-13",
+	"encodings-shift-jis",
+	"encodings-shift-jis-2004",
+	"encodings-shift-jisx0213",
+	"encodings-string-escape",
+	"encodings-tis-620",
+	"encodings-undefined",
+	"encodings-unicode-escape",
+	"encodings-unicode-internal",
+	"encodings-utf-16",
+	"encodings-utf-16-be",
+	"encodings-utf-16-le",
+	"encodings-utf-32",
+	"encodings-utf-32-be",
+	"encodings-utf-32-le",
+	"encodings-utf-7",
+	"encodings-utf-8",
+	"encodings-utf-8-sig",
+	"encodings-uu-codec",
+	"encodings-win-cp-codecs",
+	"encodings-zlib-codec",
+	"ensurepip",
+	"ensurepip-bundled",
+	"ensurepip-main",
+	"ensurepip-uninstall",
+	"enum",
+	"errno",
+	"exceptions",
+	"faulthandler",
+	"fcntl",
+	"filecmp",
+	"filedialog",
+	"fileinput",
+	"findertools",
+	"fixtk",
+	"fl",
+	"flp",
+	"fm",
+	"fnmatch",
+	"formatter",
+	"fpectl",
+	"fpformat",
+	"fractions",
+	"framework",
+	"frozen-importlib",
+	"frozen-importlib-external",
+	"ftplib",
+	"functools",
+	"future",
+	"future-builtins",
+	"gc",
+	"gdbm",
+	"genericpath",
+	"gensuitemodule",
+	"getopt",
+	"getpass",
+	"gettext",
+	"gl",
+	"glob",
+	"graphlib",
+	"grp",
+	"gzip",
+	"hashlib",
+	"heapq",
+	"hmac",
+	"hotshot",
+	"hotshot-log",
+	"hotshot-stats",
+	"hotshot-stones",
+	"html",
+	"html-entities",
+	"html-parser",
+	"htmlentitydefs",
+	"htmllib",
+	"htmlparser",
+	"http",
+	"http-client",
+	"http-cookiejar",
+	"http-cookies",
+	"http-server",
+	"httplib",
+	"ic",
+	"icopen",
+	"idlelib",
+	"idlelib-aboutdialog",
+	"idlelib-autocomplete",
+	"idlelib-autocomplete-w",
+	"idlelib-autocompletewindow",
+	"idlelib-autoexpand",
+	"idlelib-bindings",
+	"idlelib-browser",
+	"idlelib-calltip",
+	"idlelib-calltip-w",
+	"idlelib-calltips",
+	"idlelib-calltipwindow",
+	"idlelib-classbrowser",
+	"idlelib-codecontext",
+	"idlelib-colordelegator",
+	"idlelib-colorizer",
+	"idlelib-config",
+	"idlelib-config-key",
+	"idlelib-configdialog",
+	"idlelib-confighandler",
+	"idlelib-confighelpsourceedit",
+	"idlelib-configsectionnamedialog",
+	"idlelib-debugger",
+	"idlelib-debugger-r",
+	"idlelib-debugobj",
+	"idlelib-debugobj-r",
+	"idlelib-delegator",
+	"idlelib-dynoption",
+	"idlelib-dynoptionmenuwidget",
+	"idlelib-editor",
+	"idlelib-editorwindow",
+	"idlelib-filelist",
+	"idlelib-format",
+	"idlelib-formatparagraph",
+	"idlelib-grep",
+	"idlelib-grepdialog",
+	"idlelib-help",
+	"idlelib-help-about",
+	"idlelib-history",
+	"idlelib-hyperparser",
+	"idlelib-idle",
+	"idlelib-idle-test",
+	"idlelib-idle-test-htest",
+	"idlelib-idle-test-mock-idle",
+	"idlelib-idle-test-mock-tk",
+	"idlelib-idle-test-template",
+	"idlelib-idle-test-test-autocomplete",
+	"idlelib-idle-test-test-autocomplete-w",
+	"idlelib-idle-test-test-autoexpand",
+	"idlelib-idle-test-test-browser",
+	"idlelib-idle-test-test-calltip",
+	"idlelib-idle-test-test-calltip-w",
+	"idlelib-idle-test-test-calltips",
+	"idlelib-idle-test-test-codecontext",
+	"idlelib-idle-test-test-colorizer",
+	"idlelib-idle-test-test-config",
+	"idlelib-idle-test-test-config-help",
+	"idlelib-idle-test-test-config-key",
+	"idlelib-idle-test-test-config-name",
+	"idlelib-idle-test-test-configdialog",
+	"idlelib-idle-test-test-debugger",
+	"idlelib-idle-test-test-debugger-r",
+	"idlelib-idle-test-test-debugobj",
+	"idlelib-idle-test-test-debugobj-r",
+	"idlelib-idle-test-test-delegator",
+	"idlelib-idle-test-test-editmenu",
+	"idlelib-idle-test-test-editor",
+	"idlelib-idle-test-test-filelist",
+	"idlelib-idle-test-test-format",
+	"idlelib-idle-test-test-formatparagraph",
+	"idlelib-idle-test-test-grep",
+	"idlelib-idle-test-test-help",
+	"idlelib-idle-test-test-help-about",
+	"idlelib-idle-test-test-helpabout",
+	"idlelib-idle-test-test-history",
+	"idlelib-idle-test-test-hyperparser",
+	"idlelib-idle-test-test-idlehistory",
+	"idlelib-idle-test-test-io",
+	"idlelib-idle-test-test-iomenu",
+	"idlelib-idle-test-test-macosx",
+	"idlelib-idle-test-test-mainmenu",
+	"idlelib-idle-test-test-multicall",
+	"idlelib-idle-test-test-outwin",
+	"idlelib-idle-test-test-paragraph",
+	"idlelib-idle-test-test-parenmatch",
+	"idlelib-idle-test-test-pathbrowser",
+	"idlelib-idle-test-test-percolator",
+	"idlelib-idle-test-test-pyparse",
+	"idlelib-idle-test-test-pyshell",
+	"idlelib-idle-test-test-query",
+	"idlelib-idle-test-test-redirector",
+	"idlelib-idle-test-test-replace",
+	"idlelib-idle-test-test-replacedialog",
+	"idlelib-idle-test-test-rpc",
+	"idlelib-idle-test-test-rstrip",
+	"idlelib-idle-test-test-run",
+	"idlelib-idle-test-test-runscript",
+	"idlelib-idle-test-test-scrolledlist",
+	"idlelib-idle-test-test-search",
+	"idlelib-idle-test-test-searchbase",
+	"idlelib-idle-test-test-searchdialog",
+	"idlelib-idle-test-test-searchdialogbase",
+	"idlelib-idle-test-test-searchengine",
+	"idlelib-idle-test-test-sidebar",
+	"idlelib-idle-test-test-squeezer",
+	"idlelib-idle-test-test-stackviewer",
+	"idlelib-idle-test-test-statusbar",
+	"idlelib-idle-test-test-text",
+	"idlelib-idle-test-test-textview",
+	"idlelib-idle-test-test-tooltip",
+	"idlelib-idle-test-test-tree",
+	"idlelib-idle-test-test-undo",
+	"idlelib-idle-test-test-undodelegator",
+	"idlelib-idle-test-test-util",
+	"idlelib-idle-test-test-warning",
+	"idlelib-idle-test-test-widgetredir",
+	"idlelib-idle-test-test-window",
+	"idlelib-idle-test-test-zoomheight",
+	"idlelib-idle-test-test-zzdummy",
+	"idlelib-idle-test-tkinter-testing-utils",
+	"idlelib-idlehistory",
+	"idlelib-idlever",
+	"idlelib-iobinding",
+	"idlelib-iomenu",
+	"idlelib-keybindingdialog",
+	"idlelib-macosx",
+	"idlelib-macosxsupport",
+	"idlelib-main",
+	"idlelib-mainmenu",
+	"idlelib-multicall",
+	"idlelib-multistatusbar",
+	"idlelib-objectbrowser",
+	"idlelib-outputwindow",
+	"idlelib-outwin",
+	"idlelib-paragraph",
+	"idlelib-parenmatch",
+	"idlelib-pathbrowser",
+	"idlelib-percolator",
+	"idlelib-pyclbr",
+	"idlelib-pyparse",
+	"idlelib-pyshell",
+	"idlelib-query",
+	"idlelib-redirector",
+	"idlelib-remotedebugger",
+	"idlelib-remoteobjectbrowser",
+	"idlelib-replace",
+	"idlelib-replacedialog",
+	"idlelib-rpc",
+	"idlelib-rstrip",
+	"idlelib-rstripextension",
+	"idlelib-run",
+	"idlelib-runscript",
+	"idlelib-scriptbinding",
+	"idlelib-scrolledlist",
+	"idlelib-search",
+	"idlelib-searchbase",
+	"idlelib-searchdialog",
+	"idlelib-searchdialogbase",
+	"idlelib-searchengine",
+	"idlelib-sidebar",
+	"idlelib-squeezer",
+	"idlelib-stackviewer",
+	"idlelib-statusbar",
+	"idlelib-tabbedpages",
+	"idlelib-textview",
+	"idlelib-tooltip",
+	"idlelib-tree",
+	"idlelib-treewidget",
+	"idlelib-undo",
+	"idlelib-undodelegator",
+	"idlelib-util",
+	"idlelib-widgetredirector",
+	"idlelib-window",
+	"idlelib-windowlist",
+	"idlelib-zoomheight",
+	"idlelib-zzdummy",
+	"ihooks",
+	"imageop",
+	"imaplib",
+	"imgfile",
+	"imghdr",
+	"imp",
+	"importlib",
+	"importlib-abc",
+	"importlib-adapters",
+	"importlib-bootstrap",
+	"importlib-bootstrap-external",
+	"importlib-common",
+	"importlib-machinery",
+	"importlib-metadata",
+	"importlib-metadata-adapters",
+	"importlib-metadata-collections",
+	"importlib-metadata-diagnose",
+	"importlib-metadata-functools",
+	"importlib-metadata-itertools",
+	"importlib-metadata-meta",
+	"importlib-metadata-text",
+	"importlib-readers",
+	"importlib-resources",
+	"importlib-resources-abc",
+	"importlib-resources-adapters",
+	"importlib-resources-common",
+	"importlib-resources-functional",
+	"importlib-resources-itertools",
+	"importlib-resources-legacy",
+	"importlib-resources-readers",
+	"importlib-resources-simple",
+	"importlib-simple",
+	"importlib-util",
+	"imputil",
+	"inspect",
+	"interpchannels",
+	"interpqueues",
+	"interpreters",
+	"io",
+	"ios-support",
+	"ipaddress",
+	"itertools",
+	"jpeg",
+	"json",
+	"json-decoder",
+	"json-encoder",
+	"json-json",
+	"json-main",
+	"json-re",
+	"json-scanner",
+	"json-struct",
+	"json-sys",
+	"json-tests",
+	"json-tests-test-check-circular",
+	"json-tests-test-decode",
+	"json-tests-test-default",
+	"json-tests-test-dump",
+	"json-tests-test-encode-basestring-ascii",
+	"json-tests-test-fail",
+	"json-tests-test-float",
+	"json-tests-test-indent",
+	"json-tests-test-pass1",
+	"json-tests-test-pass2",
+	"json-tests-test-pass3",
+	"json-tests-test-recursion",
+	"json-tests-test-scanstring",
+	"json-tests-test-separators",
+	"json-tests-test-speedups",
+	"json-tests-test-tool",
+	"json-tests-test-unicode",
+	"json-tool",
+	"keyword",
+	"lib",
+	"lib-libpython3",
+	"lib2to3",
+	"lib2to3-btm-matcher",
+	"lib2to3-btm-utils",
+	"lib2to3-fixer-base",
+	"lib2to3-fixer-util",
+	"lib2to3-fixes",
+	"lib2to3-fixes-fix-apply",
+	"lib2to3-fixes-fix-asserts",
+	"lib2to3-fixes-fix-basestring",
+	"lib2to3-fixes-fix-buffer",
+	"lib2to3-fixes-fix-callable",
+	"lib2to3-fixes-fix-dict",
+	"lib2to3-fixes-fix-except",
+	"lib2to3-fixes-fix-exec",
+	"lib2to3-fixes-fix-execfile",
+	"lib2to3-fixes-fix-exitfunc",
+	"lib2to3-fixes-fix-filter",
+	"lib2to3-fixes-fix-funcattrs",
+	"lib2to3-fixes-fix-future",
+	"lib2to3-fixes-fix-getcwdu",
+	"lib2to3-fixes-fix-has-key",
+	"lib2to3-fixes-fix-idioms",
+	"lib2to3-fixes-fix-import",
+	"lib2to3-fixes-fix-imports",
+	"lib2to3-fixes-fix-imports2",
+	"lib2to3-fixes-fix-input",
+	"lib2to3-fixes-fix-intern",
+	"lib2to3-fixes-fix-isinstance",
+	"lib2to3-fixes-fix-itertools",
+	"lib2to3-fixes-fix-itertools-imports",
+	"lib2to3-fixes-fix-long",
+	"lib2to3-fixes-fix-map",
+	"lib2to3-fixes-fix-metaclass",
+	"lib2to3-fixes-fix-methodattrs",
+	"lib2to3-fixes-fix-ne",
+	"lib2to3-fixes-fix-next",
+	"lib2to3-fixes-fix-nonzero",
+	"lib2to3-fixes-fix-numliterals",
+	"lib2to3-fixes-fix-operator",
+	"lib2to3-fixes-fix-paren",
+	"lib2to3-fixes-fix-print",
+	"lib2to3-fixes-fix-raise",
+	"lib2to3-fixes-fix-raw-input",
+	"lib2to3-fixes-fix-reduce",
+	"lib2to3-fixes-fix-reload",
+	"lib2to3-fixes-fix-renames",
+	"lib2to3-fixes-fix-repr",
+	"lib2to3-fixes-fix-set-literal",
+	"lib2to3-fixes-fix-standarderror",
+	"lib2to3-fixes-fix-sys-exc",
+	"lib2to3-fixes-fix-throw",
+	"lib2to3-fixes-fix-tuple-params",
+	"lib2to3-fixes-fix-types",
+	"lib2to3-fixes-fix-unicode",
+	"lib2to3-fixes-fix-urllib",
+	"lib2to3-fixes-fix-ws-comma",
+	"lib2to3-fixes-fix-xrange",
+	"lib2to3-fixes-fix-xreadlines",
+	"lib2to3-fixes-fix-zip",
+	"lib2to3-main",
+	"lib2to3-patcomp",
+	"lib2to3-pgen2",
+	"lib2to3-pgen2-conv",
+	"lib2to3-pgen2-driver",
+	"lib2to3-pgen2-grammar",
+	"lib2to3-pgen2-literals",
+	"lib2to3-pgen2-parse",
+	"lib2to3-pgen2-pgen",
+	"lib2to3-pgen2-token",
+	"lib2to3-pgen2-tokenize",
+	"lib2to3-pygram",
+	"lib2to3-pytree",
+	"lib2to3-refactor",
+	"lib2to3-tests",
+	"lib2to3-tests-data",
+	"lib2to3-tests-data-bom",
+	"lib2to3-tests-data-crlf",
+	"lib2to3-tests-data-different-encoding",
+	"lib2to3-tests-data-false-encoding",
+	"lib2to3-tests-data-fixers",
+	"lib2to3-tests-data-fixers-bad-order",
+	"lib2to3-tests-data-fixers-myfixes",
+	"lib2to3-tests-data-fixers-myfixes-fix-explicit",
+	"lib2to3-tests-data-fixers-myfixes-fix-first",
+	"lib2to3-tests-data-fixers-myfixes-fix-last",
+	"lib2to3-tests-data-fixers-myfixes-fix-parrot",
+	"lib2to3-tests-data-fixers-myfixes-fix-preorder",
+	"lib2to3-tests-data-fixers-no-fixer-cls",
+	"lib2to3-tests-data-fixers-parrot-example",
+	"lib2to3-tests-data-infinite-recursion",
+	"lib2to3-tests-data-py2-test-grammar",
+	"lib2to3-tests-data-py3-test-grammar",
+	"lib2to3-tests-main",
+	"lib2to3-tests-pytree-idempotency",
+	"lib2to3-tests-support",
+	"lib2to3-tests-test-all-fixers",
+	"lib2to3-tests-test-fixers",
+	"lib2to3-tests-test-main",
+	"lib2to3-tests-test-parser",
+	"lib2to3-tests-test-pytree",
+	"lib2to3-tests-test-refactor",
+	"lib2to3-tests-test-util",
+	"linecache",
+	"linuxaudiodev",
+	"locale",
+	"logging",
+	"logging-config",
+	"logging-handlers",
+	"lsprof",
+	"lwpcookiejar",
+	"lzma",
+	"macerrors",
+	"macos",
+	"macostools",
+	"macpath",
+	"macresource",
+	"macurl2path",
+	"mailbox",
+	"mailcap",
+	"main",
+	"markupbase",
+	"marshal",
+	"math",
+	"md5",
+	"mhlib",
+	"mimetools",
+	"mimetypes",
+	"mimewriter",
+	"mimify",
+	"miniaeframe",
+	"mmap",
+	"modulefinder",
+	"mozillacookiejar",
+	"msi",
+	"msilib",
+	"msvcrt",
+	"multibytecodec",
+	"multifile",
+	"multiprocessing",
+	"multiprocessing-connection",
+	"multiprocessing-context",
+	"multiprocessing-dummy",
+	"multiprocessing-dummy-connection",
+	"multiprocessing-forking",
+	"multiprocessing-forkserver",
+	"multiprocessing-heap",
+	"multiprocessing-managers",
+	"multiprocessing-pool",
+	"multiprocessing-popen-fork",
+	"multiprocessing-popen-forkserver",
+	"multiprocessing-popen-spawn-posix",
+	"multiprocessing-popen-spawn-win32",
+	"multiprocessing-process",
+	"multiprocessing-queues",
+	"multiprocessing-reduction",
+	"multiprocessing-resource-sharer",
+	"multiprocessing-resource-tracker",
+	"multiprocessing-semaphore-tracker",
+	"multiprocessing-shared-memory",
+	"multiprocessing-sharedctypes",
+	"multiprocessing-spawn",
+	"multiprocessing-synchronize",
+	"multiprocessing-util",
+	"mutex",
+	"nav",
+	"netrc",
+	"new",
+	"nis",
+	"nntplib",
+	"nt",
+	"ntpath",
+	"nturl2path",
+	"numbers",
+	"opcode",
+	"opcode-metadata",
+	"operator",
+	"optparse",
+	"os",
+	"os-path",
+	"os2emxpath",
+	"ossaudiodev",
+	"osx-support",
+	"overlapped",
+	"parser",
+	"pathlib",
+	"pathlib-abc",
+	"pathlib-local",
+	"pathlib-os",
+	"pathlib-types",
+	"pdb",
+	"peg-parser",
+	"phello",
+	"phello-foo",
+	"pickle",
+	"pickletools",
+	"pipes",
+	"pixmapwrapper",
+	"pkgutil",
+	"platform",
+	"plistlib",
+	"popen2",
+	"poplib",
+	"posix",
+	"posixfile",
+	"posixpath",
+	"posixshmem",
+	"posixsubprocess",
+	"pprint",
+	"profile",
+	"pstats",
+	"pty",
+	"pwd",
+	"py-abc",
+	"py-compile",
+	"py-warnings",
+	"pyclbr",
+	"pydatetime",
+	"pydecimal",
+	"pydoc",
+	"pydoc-data",
+	"pydoc-data-topics",
+	"pyexpat",
+	"pyexpat-errors",
+	"pyexpat-model",
+	"pyio",
+	"pylong",
+	"pyrepl",
+	"pyrepl-base-eventqueue",
+	"pyrepl-commands",
+	"pyrepl-completing-reader",
+	"pyrepl-console",
+	"pyrepl-curses",
+	"pyrepl-fancy-termios",
+	"pyrepl-historical-reader",
+	"pyrepl-input",
+	"pyrepl-keymap",
+	"pyrepl-main",
+	"pyrepl-minimal-curses",
+	"pyrepl-module-completer",
+	"pyrepl-pager",
+	"pyrepl-reader",
+	"pyrepl-readline",
+	"pyrepl-simple-interact",
+	"pyrepl-terminfo",
+	"pyrepl-threading-handler",
+	"pyrepl-trace",
+	"pyrepl-types",
+	"pyrepl-unix-console",
+	"pyrepl-unix-eventqueue",
+	"pyrepl-utils",
+	"pyrepl-windows-console",
+	"pyrepl-windows-eventqueue",
+	"queue",
+	"quopri",
+	"random",
+	"re",
+	"re-casefix",
+	"re-compiler",
+	"re-constants",
+	"re-parser",
+	"readline",
+	"remote-debugging",
+	"repr",
+	"reprlib",
+	"resource",
+	"rexec",
+	"rfc822",
+	"rlcompleter",
+	"robotparser",
+	"runpy",
+	"sched",
+	"scproxy",
+	"scrolledtext",
+	"secrets",
+	"select",
+	"selectors",
+	"sets",
+	"sgmllib",
+	"sha",
+	"sha1",
+	"sha2",
+	"sha256",
+	"sha3",
+	"sha512",
+	"shelve",
+	"shlex",
+	"shutil",
+	"signal",
+	"simpledialog",
+	"simplehttpserver",
+	"simplexmlrpcserver",
+	"site",
+	"sitebuiltins",
+	"smtpd",
+	"smtplib",
+	"sndhdr",
+	"socket",
+	"socketserver",
+	"spwd",
+	"sqlite3",
+	"sqlite3-dbapi2",
+	"sqlite3-dump",
+	"sqlite3-main",
+	"sqlite3-test",
+	"sqlite3-test-backup",
+	"sqlite3-test-dbapi",
+	"sqlite3-test-dump",
+	"sqlite3-test-factory",
+	"sqlite3-test-hooks",
+	"sqlite3-test-py25tests",
+	"sqlite3-test-regression",
+	"sqlite3-test-transactions",
+	"sqlite3-test-types",
+	"sqlite3-test-userfunctions",
+	"sre",
+	"sre-compile",
+	"sre-constants",
+	"sre-parse",
+	"ssl",
+	"stat",
+	"statistics",
+	"statvfs",
+	"string",
+	"string-templatelib",
+	"stringio",
+	"stringold",
+	"stringprep",
+	"strop",
+	"strptime",
+	"struct",
+	"subprocess",
+	"suggestions",
+	"sunau",
+	"sunaudio",
+	"sunaudiodev",
+	"symbol",
+	"symtable",
+	"sys",
+	"sysconfig",
+	"sysconfig-main",
+	"sysconfigdata",
+	"sysconfigdata-x86-64-conda-cos6-linux-gnu",
+	"sysconfigdata-x86-64-conda-linux-gnu",
+	"syslog",
+	"tabnanny",
+	"tarfile",
+	"telnetlib",
+	"tempfile",
+	"termios",
+	"test",
+	"test-ann-module",
+	"test-ann-module2",
+	"test-ann-module3",
+	"test-ann-module5",
+	"test-ann-module6",
+	"test-ann-module7",
+	"test-audiotests",
+	"test-audit-tests",
+	"test-autotest",
+	"test-bad-coding",
+	"test-bad-coding2",
+	"test-bad-coding3",
+	"test-bad-getattr",
+	"test-bad-getattr2",
+	"test-bad-getattr3",
+	"test-badsyntax-3131",
+	"test-badsyntax-async1",
+	"test-badsyntax-async2",
+	"test-badsyntax-async3",
+	"test-badsyntax-async4",
+	"test-badsyntax-async5",
+	"test-badsyntax-async6",
+	"test-badsyntax-async7",
+	"test-badsyntax-async8",
+	"test-badsyntax-future10",
+	"test-badsyntax-future3",
+	"test-badsyntax-future4",
+	"test-badsyntax-future5",
+	"test-badsyntax-future6",
+	"test-badsyntax-future7",
+	"test-badsyntax-future8",
+	"test-badsyntax-future9",
+	"test-badsyntax-nocaret",
+	"test-badsyntax-pep3120",
+	"test-bisect",
+	"test-bisect-cmd",
+	"test-buffer-tests",
+	"test-bytecode-helper",
+	"test-coding20731",
+	"test-curses-tests",
+	"test-dataclass-module-1",
+	"test-dataclass-module-1-str",
+	"test-dataclass-module-2",
+	"test-dataclass-module-2-str",
+	"test-dataclass-textanno",
+	"test-datetimetester",
+	"test-dis-module",
+	"test-doctest-aliases",
+	"test-double-const",
+	"test-dtracedata",
+	"test-dtracedata-call-stack",
+	"test-dtracedata-gc",
+	"test-dtracedata-instance",
+	"test-dtracedata-line",
+	"test-eintrdata",
+	"test-eintrdata-eintr-tester",
+	"test-encoded-modules",
+	"test-encoded-modules-module-iso-8859-1",
+	"test-encoded-modules-module-koi8-r",
+	"test-final-a",
+	"test-final-b",
+	"test-fork-wait",
+	"test-future-test1",
+	"test-future-test2",
+	"test-gdb-sample",
+	"test-good-getattr",
+	"test-imp-dummy",
+	"test-infinite-reload",
+	"test-inspect-fodder",
+	"test-inspect-fodder2",
+	"test-libregrtest",
+	"test-libregrtest-cmdline",
+	"test-libregrtest-main",
+	"test-libregrtest-pgo",
+	"test-libregrtest-refleak",
+	"test-libregrtest-runtest",
+	"test-libregrtest-runtest-mp",
+	"test-libregrtest-save-env",
+	"test-libregrtest-setup",
+	"test-libregrtest-utils",
+	"test-libregrtest-win-utils",
+	"test-list-tests",
+	"test-lock-tests",
+	"test-main",
+	"test-make-ssl-certs",
+	"test-mapping-tests",
+	"test-memory-watchdog",
+	"test-mock-backport",
+	"test-mock-socket",
+	"test-mod-generics-cache",
+	"test-mp-fork-bomb",
+	"test-mp-preload",
+	"test-multibytecodec-support",
+	"test-outstanding-bugs",
+	"test-pickletester",
+	"test-profilee",
+	"test-pyclbr-input",
+	"test-pydoc-mod",
+	"test-pydocfodder",
+	"test-pystone",
+	"test-pythoninfo",
+	"test-re-tests",
+	"test-regrtest",
+	"test-relimport",
+	"test-reperf",
+	"test-sample-doctest",
+	"test-sample-doctest-no-docstrings",
+	"test-sample-doctest-no-doctests",
+	"test-script-helper",
+	"test-seq-tests",
+	"test-signalinterproctester",
+	"test-sortperf",
+	"test-ssl-servers",
+	"test-ssltests",
+	"test-string-tests",
+	"test-subprocessdata",
+	"test-subprocessdata-fd-status",
+	"test-subprocessdata-input-reader",
+	"test-subprocessdata-qcat",
+	"test-subprocessdata-qgrep",
+	"test-subprocessdata-sigchild-ignore",
+	"test-support",
+	"test-support-bytecode-helper",
+	"test-support-hashlib-helper",
+	"test-support-logging-helper",
+	"test-support-script-helper",
+	"test-support-socket-helper",
+	"test-support-testresult",
+	"test-support-warnings-helper",
+	"test-symlink-support",
+	"test-test-abc",
+	"test-test-abstract-numbers",
+	"test-test-aepack",
+	"test-test-aifc",
+	"test-test-al",
+	"test-test-all",
+	"test-test-anydbm",
+	"test-test-applesingle",
+	"test-test-argparse",
+	"test-test-array",
+	"test-test-ascii-formatd",
+	"test-test-asdl-parser",
+	"test-test-ast",
+	"test-test-asyncgen",
+	"test-test-asynchat",
+	"test-test-asyncio",
+	"test-test-asyncio-echo",
+	"test-test-asyncio-echo2",
+	"test-test-asyncio-echo3",
+	"test-test-asyncio-functional",
+	"test-test-asyncio-main",
+	"test-test-asyncio-test-asyncio-waitfor",
+	"test-test-asyncio-test-base-events",
+	"test-test-asyncio-test-buffered-proto",
+	"test-test-asyncio-test-context",
+	"test-test-asyncio-test-events",
+	"test-test-asyncio-test-futures",
+	"test-test-asyncio-test-futures2",
+	"test-test-asyncio-test-locks",
+	"test-test-asyncio-test-pep492",
+	"test-test-asyncio-test-proactor-events",
+	"test-test-asyncio-test-protocols",
+	"test-test-asyncio-test-queues",
+	"test-test-asyncio-test-runners",
+	"test-test-asyncio-test-selector-events",
+	"test-test-asyncio-test-sendfile",
+	"test-test-asyncio-test-server",
+	"test-test-asyncio-test-sock-lowlevel",
+	"test-test-asyncio-test-sslproto",
+	"test-test-asyncio-test-streams",
+	"test-test-asyncio-test-subprocess",
+	"test-test-asyncio-test-tasks",
+	"test-test-asyncio-test-threads",
+	"test-test-asyncio-test-transports",
+	"test-test-asyncio-test-unix-events",
+	"test-test-asyncio-test-waitfor",
+	"test-test-asyncio-test-windows-events",
+	"test-test-asyncio-test-windows-utils",
+	"test-test-asyncio-utils",
+	"test-test-asyncore",
+	"test-test-atexit",
+	"test-test-audioop",
+	"test-test-audit",
+	"test-test-augassign",
+	"test-test-base64",
+	"test-test-baseexception",
+	"test-test-bastion",
+	"test-test-bdb",
+	"test-test-bigaddrspace",
+	"test-test-bigmem",
+	"test-test-binascii",
+	"test-test-binhex",
+	"test-test-binop",
+	"test-test-bisect",
+	"test-test-bool",
+	"test-test-bsddb",
+	"test-test-bsddb185",
+	"test-test-bsddb3",
+	"test-test-buffer",
+	"test-test-bufio",
+	"test-test-builtin",
+	"test-test-bytes",
+	"test-test-bz2",
+	"test-test-c-locale-coercion",
+	"test-test-calendar",
+	"test-test-call",
+	"test-test-capi",
+	"test-test-cd",
+	"test-test-cfgparser",
+	"test-test-cgi",
+	"test-test-cgitb",
+	"test-test-charmapcodec",
+	"test-test-check-c-globals",
+	"test-test-cl",
+	"test-test-class",
+	"test-test-clinic",
+	"test-test-cmath",
+	"test-test-cmd",
+	"test-test-cmd-line",
+	"test-test-cmd-line-script",
+	"test-test-code",
+	"test-test-code-module",
+	"test-test-codeccallbacks",
+	"test-test-codecencodings-cn",
+	"test-test-codecencodings-hk",
+	"test-test-codecencodings-iso2022",
+	"test-test-codecencodings-jp",
+	"test-test-codecencodings-kr",
+	"test-test-codecencodings-tw",
+	"test-test-codecmaps-cn",
+	"test-test-codecmaps-hk",
+	"test-test-codecmaps-jp",
+	"test-test-codecmaps-kr",
+	"test-test-codecmaps-tw",
+	"test-test-codecs",
+	"test-test-codeop",
+	"test-test-coercion",
+	"test-test-collections",
+	"test-test-colorsys",
+	"test-test-commands",
+	"test-test-compare",
+	"test-test-compile",
+	"test-test-compileall",
+	"test-test-compiler",
+	"test-test-complex",
+	"test-test-complex-args",
+	"test-test-concurrent-futures",
+	"test-test-configparser",
+	"test-test-contains",
+	"test-test-context",
+	"test-test-contextlib",
+	"test-test-contextlib-async",
+	"test-test-cookie",
+	"test-test-cookielib",
+	"test-test-copy",
+	"test-test-copy-reg",
+	"test-test-copyreg",
+	"test-test-coroutines",
+	"test-test-cpickle",
+	"test-test-cprofile",
+	"test-test-crashers",
+	"test-test-crypt",
+	"test-test-csv",
+	"test-test-ctypes",
+	"test-test-curses",
+	"test-test-dataclasses",
+	"test-test-datetime",
+	"test-test-dbm",
+	"test-test-dbm-dumb",
+	"test-test-dbm-gnu",
+	"test-test-dbm-ndbm",
+	"test-test-decimal",
+	"test-test-decorators",
+	"test-test-defaultdict",
+	"test-test-deque",
+	"test-test-descr",
+	"test-test-descrtut",
+	"test-test-devpoll",
+	"test-test-dict",
+	"test-test-dict-version",
+	"test-test-dictcomps",
+	"test-test-dictviews",
+	"test-test-difflib",
+	"test-test-dircache",
+	"test-test-dis",
+	"test-test-distutils",
+	"test-test-dl",
+	"test-test-doctest",
+	"test-test-doctest2",
+	"test-test-docxmlrpc",
+	"test-test-dtrace",
+	"test-test-dumbdbm",
+	"test-test-dummy-thread",
+	"test-test-dummy-threading",
+	"test-test-dynamic",
+	"test-test-dynamicclassattribute",
+	"test-test-eintr",
+	"test-test-email",
+	"test-test-email-codecs",
+	"test-test-email-main",
+	"test-test-email-renamed",
+	"test-test-email-test-asian-codecs",
+	"test-test-email-test-contentmanager",
+	"test-test-email-test-defect-handling",
+	"test-test-email-test-email",
+	"test-test-email-test-encoded-words",
+	"test-test-email-test-generator",
+	"test-test-email-test-header-value-parser",
+	"test-test-email-test-headerregistry",
+	"test-test-email-test-inversion",
+	"test-test-email-test-message",
+	"test-test-email-test-parser",
+	"test-test-email-test-pickleable",
+	"test-test-email-test-policy",
+	"test-test-email-test-utils",
+	"test-test-email-torture-test",
+	"test-test-embed",
+	"test-test-ensurepip",
+	"test-test-enum",
+	"test-test-enumerate",
+	"test-test-eof",
+	"test-test-epoll",
+	"test-test-errno",
+	"test-test-exception-hierarchy",
+	"test-test-exception-variations",
+	"test-test-exceptions",
+	"test-test-extcall",
+	"test-test-faulthandler",
+	"test-test-fcntl",
+	"test-test-file",
+	"test-test-file-eintr",
+	"test-test-file2k",
+	"test-test-filecmp",
+	"test-test-fileinput",
+	"test-test-fileio",
+	"test-test-finalization",
+	"test-test-float",
+	"test-test-flufl",
+	"test-test-fnmatch",
+	"test-test-fork1",
+	"test-test-format",
+	"test-test-fpformat",
+	"test-test-fractions",
+	"test-test-frame",
+	"test-test-frozen",
+	"test-test-fstring",
+	"test-test-ftplib",
+	"test-test-funcattrs",
+	"test-test-functools",
+	"test-test-future",
+	"test-test-future-builtins",
+	"test-test-future1",
+	"test-test-future2",
+	"test-test-future3",
+	"test-test-future4",
+	"test-test-future5",
+	"test-test-gc",
+	"test-test-gdb",
+	"test-test-gdbm",
+	"test-test-generator-stop",
+	"test-test-generators",
+	"test-test-genericalias",
+	"test-test-genericclass",
+	"test-test-genericpath",
+	"test-test-genexps",
+	"test-test-getargs",
+	"test-test-getargs2",
+	"test-test-getopt",
+	"test-test-getpass",
+	"test-test-gettext",
+	"test-test-gl",
+	"test-test-glob",
+	"test-test-global",
+	"test-test-grammar",
+	"test-test-graphlib",
+	"test-test-grp",
+	"test-test-gzip",
+	"test-test-hash",
+	"test-test-hashlib",
+	"test-test-heapq",
+	"test-test-hmac",
+	"test-test-hotshot",
+	"test-test-html",
+	"test-test-htmllib",
+	"test-test-htmlparser",
+	"test-test-http-cookiejar",
+	"test-test-http-cookies",
+	"test-test-httplib",
+	"test-test-httpservers",
+	"test-test-idle",
+	"test-test-imageop",
+	"test-test-imaplib",
+	"test-test-imgfile",
+	"test-test-imghdr",
+	"test-test-imp",
+	"test-test-import",
+	"test-test-import-data",
+	"test-test-import-data-circular-imports",
+	"test-test-import-data-circular-imports-basic",
+	"test-test-import-data-circular-imports-basic2",
+	"test-test-import-data-circular-imports-binding",
+	"test-test-import-data-circular-imports-binding2",
+	"test-test-import-data-circular-imports-from-cycle1",
+	"test-test-import-data-circular-imports-from-cycle2",
+	"test-test-import-data-circular-imports-indirect",
+	"test-test-import-data-circular-imports-rebinding",
+	"test-test-import-data-circular-imports-rebinding2",
+	"test-test-import-data-circular-imports-source",
+	"test-test-import-data-circular-imports-subpackage",
+	"test-test-import-data-circular-imports-subpkg",
+	"test-test-import-data-circular-imports-subpkg-subpackage2",
+	"test-test-import-data-circular-imports-subpkg-util",
+	"test-test-import-data-circular-imports-use",
+	"test-test-import-data-circular-imports-util",
+	"test-test-import-data-package",
+	"test-test-import-data-package-submodule",
+	"test-test-import-data-package2",
+	"test-test-import-data-package2-submodule1",
+	"test-test-import-data-package2-submodule2",
+	"test-test-import-magic",
+	"test-test-import-main",
+	"test-test-importhooks",
+	"test-test-importlib",
+	"test-test-importlib-abc",
+	"test-test-importlib-builtin",
+	"test-test-importlib-builtin-main",
+	"test-test-importlib-builtin-test-finder",
+	"test-test-importlib-builtin-test-loader",
+	"test-test-importlib-builtin-util",
+	"test-test-importlib-data",
+	"test-test-importlib-data01",
+	"test-test-importlib-data01-subdirectory",
+	"test-test-importlib-data02",
+	"test-test-importlib-data02-one",
+	"test-test-importlib-data02-two",
+	"test-test-importlib-data03",
+	"test-test-importlib-data03-namespace",
+	"test-test-importlib-data03-namespace-portion1",
+	"test-test-importlib-data03-namespace-portion2",
+	"test-test-importlib-extension",
+	"test-test-importlib-extension-main",
+	"test-test-importlib-extension-test-case-sensitivity",
+	"test-test-importlib-extension-test-finder",
+	"test-test-importlib-extension-test-loader",
+	"test-test-importlib-extension-test-path-hook",
+	"test-test-importlib-extension-util",
+	"test-test-importlib-fixtures",
+	"test-test-importlib-frozen",
+	"test-test-importlib-frozen-main",
+	"test-test-importlib-frozen-test-finder",
+	"test-test-importlib-frozen-test-loader",
+	"test-test-importlib-import",
+	"test-test-importlib-import-main",
+	"test-test-importlib-import-test-api",
+	"test-test-importlib-import-test-caching",
+	"test-test-importlib-import-test-fromlist",
+	"test-test-importlib-import-test-loader",
+	"test-test-importlib-import-test-meta-path",
+	"test-test-importlib-import-test-package",
+	"test-test-importlib-import-test-packages",
+	"test-test-importlib-import-test-path",
+	"test-test-importlib-import-test-relative-imports",
+	"test-test-importlib-import-util",
+	"test-test-importlib-main",
+	"test-test-importlib-namespace-pkgs",
+	"test-test-importlib-namespace-pkgs-both-portions",
+	"test-test-importlib-namespace-pkgs-both-portions-foo",
+	"test-test-importlib-namespace-pkgs-both-portions-foo-one",
+	"test-test-importlib-namespace-pkgs-both-portions-foo-two",
+	"test-test-importlib-namespace-pkgs-module-and-namespace-package",
+	"test-test-importlib-namespace-pkgs-module-and-namespace-package-a-test",
+	"test-test-importlib-namespace-pkgs-not-a-namespace-pkg",
+	"test-test-importlib-namespace-pkgs-not-a-namespace-pkg-foo",
+	"test-test-importlib-namespace-pkgs-not-a-namespace-pkg-foo-one",
+	"test-test-importlib-namespace-pkgs-portion1",
+	"test-test-importlib-namespace-pkgs-portion1-foo",
+	"test-test-importlib-namespace-pkgs-portion1-foo-one",
+	"test-test-importlib-namespace-pkgs-portion2",
+	"test-test-importlib-namespace-pkgs-portion2-foo",
+	"test-test-importlib-namespace-pkgs-portion2-foo-two",
+	"test-test-importlib-namespace-pkgs-project1",
+	"test-test-importlib-namespace-pkgs-project1-parent",
+	"test-test-importlib-namespace-pkgs-project1-parent-child",
+	"test-test-importlib-namespace-pkgs-project1-parent-child-one",
+	"test-test-importlib-namespace-pkgs-project2",
+	"test-test-importlib-namespace-pkgs-project2-parent",
+	"test-test-importlib-namespace-pkgs-project2-parent-child",
+	"test-test-importlib-namespace-pkgs-project2-parent-child-two",
+	"test-test-importlib-namespace-pkgs-project3",
+	"test-test-importlib-namespace-pkgs-project3-parent",
+	"test-test-importlib-namespace-pkgs-project3-parent-child",
+	"test-test-importlib-namespace-pkgs-project3-parent-child-three",
+	"test-test-importlib-regrtest",
+	"test-test-importlib-source",
+	"test-test-importlib-source-main",
+	"test-test-importlib-source-test-case-sensitivity",
+	"test-test-importlib-source-test-file-loader",
+	"test-test-importlib-source-test-finder",
+	"test-test-importlib-source-test-path-hook",
+	"test-test-importlib-source-test-source-encoding",
+	"test-test-importlib-source-util",
+	"test-test-importlib-stubs",
+	"test-test-importlib-test-abc",
+	"test-test-importlib-test-api",
+	"test-test-importlib-test-files",
+	"test-test-importlib-test-lazy",
+	"test-test-importlib-test-locks",
+	"test-test-importlib-test-main",
+	"test-test-importlib-test-metadata-api",
+	"test-test-importlib-test-namespace-pkgs",
+	"test-test-importlib-test-open",
+	"test-test-importlib-test-path",
+	"test-test-importlib-test-pkg-import",
+	"test-test-importlib-test-read",
+	"test-test-importlib-test-resource",
+	"test-test-importlib-test-spec",
+	"test-test-importlib-test-threaded-import",
+	"test-test-importlib-test-util",
+	"test-test-importlib-test-windows",
+	"test-test-importlib-test-zip",
+	"test-test-importlib-threaded-import-hangers",
+	"test-test-importlib-util",
+	"test-test-importlib-zipdata01",
+	"test-test-importlib-zipdata02",
+	"test-test-index",
+	"test-test-inspect",
+	"test-test-int",
+	"test-test-int-literal",
+	"test-test-io",
+	"test-test-ioctl",
+	"test-test-ipaddress",
+	"test-test-isinstance",
+	"test-test-iter",
+	"test-test-iterlen",
+	"test-test-itertools",
+	"test-test-json",
+	"test-test-json-main",
+	"test-test-json-test-decode",
+	"test-test-json-test-default",
+	"test-test-json-test-dump",
+	"test-test-json-test-encode-basestring-ascii",
+	"test-test-json-test-enum",
+	"test-test-json-test-fail",
+	"test-test-json-test-float",
+	"test-test-json-test-indent",
+	"test-test-json-test-pass1",
+	"test-test-json-test-pass2",
+	"test-test-json-test-pass3",
+	"test-test-json-test-recursion",
+	"test-test-json-test-scanstring",
+	"test-test-json-test-separators",
+	"test-test-json-test-speedups",
+	"test-test-json-test-tool",
+	"test-test-json-test-unicode",
+	"test-test-keyword",
+	"test-test-keywordonlyarg",
+	"test-test-kqueue",
+	"test-test-largefile",
+	"test-test-lib2to3",
+	"test-test-linecache",
+	"test-test-linuxaudiodev",
+	"test-test-list",
+	"test-test-listcomps",
+	"test-test-lltrace",
+	"test-test-locale",
+	"test-test-logging",
+	"test-test-long",
+	"test-test-long-future",
+	"test-test-longexp",
+	"test-test-lzma",
+	"test-test-macos",
+	"test-test-macostools",
+	"test-test-macpath",
+	"test-test-macurl2path",
+	"test-test-mailbox",
+	"test-test-mailcap",
+	"test-test-marshal",
+	"test-test-math",
+	"test-test-md5",
+	"test-test-memoryio",
+	"test-test-memoryview",
+	"test-test-metaclass",
+	"test-test-mhlib",
+	"test-test-mimetools",
+	"test-test-mimetypes",
+	"test-test-mimewriter",
+	"test-test-minidom",
+	"test-test-mmap",
+	"test-test-module",
+	"test-test-modulefinder",
+	"test-test-msilib",
+	"test-test-multibytecodec",
+	"test-test-multifile",
+	"test-test-multiprocessing",
+	"test-test-multiprocessing-fork",
+	"test-test-multiprocessing-forkserver",
+	"test-test-multiprocessing-main-handling",
+	"test-test-multiprocessing-spawn",
+	"test-test-mutants",
+	"test-test-mutex",
+	"test-test-named-expressions",
+	"test-test-netrc",
+	"test-test-new",
+	"test-test-nis",
+	"test-test-nntplib",
+	"test-test-normalization",
+	"test-test-ntpath",
+	"test-test-numeric-tower",
+	"test-test-old-mailbox",
+	"test-test-opcode",
+	"test-test-opcodes",
+	"test-test-openpty",
+	"test-test-operator",
+	"test-test-optparse",
+	"test-test-ordered-dict",
+	"test-test-os",
+	"test-test-ossaudiodev",
+	"test-test-osx-env",
+	"test-test-osx-support",
+	"test-test-parser",
+	"test-test-pathlib",
+	"test-test-pdb",
+	"test-test-peepholer",
+	"test-test-peg-generator",
+	"test-test-peg-generator-main",
+	"test-test-peg-generator-test-c-parser",
+	"test-test-peg-generator-test-first-sets",
+	"test-test-peg-generator-test-pegen",
+	"test-test-peg-parser",
+	"test-test-pep247",
+	"test-test-pep277",
+	"test-test-pep292",
+	"test-test-pep3120",
+	"test-test-pep3131",
+	"test-test-pep3151",
+	"test-test-pep352",
+	"test-test-pep380",
+	"test-test-pep479",
+	"test-test-pickle",
+	"test-test-picklebuffer",
+	"test-test-pickletools",
+	"test-test-pipes",
+	"test-test-pkg",
+	"test-test-pkgimport",
+	"test-test-pkgutil",
+	"test-test-platform",
+	"test-test-plistlib",
+	"test-test-poll",
+	"test-test-popen",
+	"test-test-popen2",
+	"test-test-poplib",
+	"test-test-positional-only-arg",
+	"test-test-posix",
+	"test-test-posixpath",
+	"test-test-pow",
+	"test-test-pprint",
+	"test-test-print",
+	"test-test-profile",
+	"test-test-property",
+	"test-test-pstats",
+	"test-test-pty",
+	"test-test-pulldom",
+	"test-test-pwd",
+	"test-test-py-compile",
+	"test-test-py3kwarn",
+	"test-test-pyclbr",
+	"test-test-pydoc",
+	"test-test-pyexpat",
+	"test-test-queue",
+	"test-test-quopri",
+	"test-test-raise",
+	"test-test-random",
+	"test-test-range",
+	"test-test-re",
+	"test-test-readline",
+	"test-test-regrtest",
+	"test-test-repl",
+	"test-test-repr",
+	"test-test-reprlib",
+	"test-test-resource",
+	"test-test-rfc822",
+	"test-test-richcmp",
+	"test-test-rlcompleter",
+	"test-test-robotparser",
+	"test-test-runpy",
+	"test-test-sax",
+	"test-test-sched",
+	"test-test-scope",
+	"test-test-script-helper",
+	"test-test-scriptpackages",
+	"test-test-secrets",
+	"test-test-select",
+	"test-test-selectors",
+	"test-test-set",
+	"test-test-setcomps",
+	"test-test-sets",
+	"test-test-sgmllib",
+	"test-test-sha",
+	"test-test-shelve",
+	"test-test-shlex",
+	"test-test-shutil",
+	"test-test-signal",
+	"test-test-simplehttpserver",
+	"test-test-site",
+	"test-test-slice",
+	"test-test-smtpd",
+	"test-test-smtplib",
+	"test-test-smtpnet",
+	"test-test-sndhdr",
+	"test-test-socket",
+	"test-test-socketserver",
+	"test-test-softspace",
+	"test-test-sort",
+	"test-test-source-encoding",
+	"test-test-spwd",
+	"test-test-sqlite",
+	"test-test-ssl",
+	"test-test-startfile",
+	"test-test-stat",
+	"test-test-statistics",
+	"test-test-str",
+	"test-test-strftime",
+	"test-test-string",
+	"test-test-string-literals",
+	"test-test-stringio",
+	"test-test-stringprep",
+	"test-test-strlit",
+	"test-test-strop",
+	"test-test-strptime",
+	"test-test-strtod",
+	"test-test-struct",
+	"test-test-structmembers",
+	"test-test-structseq",
+	"test-test-subclassinit",
+	"test-test-subprocess",
+	"test-test-sunau",
+	"test-test-sunaudiodev",
+	"test-test-sundry",
+	"test-test-super",
+	"test-test-support",
+	"test-test-symbol",
+	"test-test-symtable",
+	"test-test-syntax",
+	"test-test-sys",
+	"test-test-sys-setprofile",
+	"test-test-sys-settrace",
+	"test-test-sysconfig",
+	"test-test-syslog",
+	"test-test-tabnanny",
+	"test-test-tarfile",
+	"test-test-tcl",
+	"test-test-telnetlib",
+	"test-test-tempfile",
+	"test-test-test-support",
+	"test-test-textwrap",
+	"test-test-thread",
+	"test-test-threaded-import",
+	"test-test-threadedtempfile",
+	"test-test-threading",
+	"test-test-threading-local",
+	"test-test-threadsignals",
+	"test-test-time",
+	"test-test-timeit",
+	"test-test-timeout",
+	"test-test-tix",
+	"test-test-tk",
+	"test-test-tokenize",
+	"test-test-tools",
+	"test-test-tools-main",
+	"test-test-tools-test-fixcid",
+	"test-test-tools-test-gprof2html",
+	"test-test-tools-test-i18n",
+	"test-test-tools-test-lll",
+	"test-test-tools-test-md5sum",
+	"test-test-tools-test-pathfix",
+	"test-test-tools-test-pdeps",
+	"test-test-tools-test-pindent",
+	"test-test-tools-test-reindent",
+	"test-test-tools-test-sundry",
+	"test-test-tools-test-unparse",
+	"test-test-trace",
+	"test-test-traceback",
+	"test-test-tracemalloc",
+	"test-test-transformer",
+	"test-test-ttk-guionly",
+	"test-test-ttk-textonly",
+	"test-test-tuple",
+	"test-test-turtle",
+	"test-test-type-comments",
+	"test-test-typechecks",
+	"test-test-types",
+	"test-test-typing",
+	"test-test-ucn",
+	"test-test-unary",
+	"test-test-undocumented-details",
+	"test-test-unicode",
+	"test-test-unicode-file",
+	"test-test-unicode-file-functions",
+	"test-test-unicode-identifiers",
+	"test-test-unicodedata",
+	"test-test-unittest",
+	"test-test-univnewlines",
+	"test-test-univnewlines2k",
+	"test-test-unpack",
+	"test-test-unpack-ex",
+	"test-test-unparse",
+	"test-test-urllib",
+	"test-test-urllib-response",
+	"test-test-urllib2",
+	"test-test-urllib2-localnet",
+	"test-test-urllib2net",
+	"test-test-urllibnet",
+	"test-test-urlparse",
+	"test-test-userdict",
+	"test-test-userlist",
+	"test-test-userstring",
+	"test-test-utf8-mode",
+	"test-test-utf8source",
+	"test-test-uu",
+	"test-test-uuid",
+	"test-test-venv",
+	"test-test-wait3",
+	"test-test-wait4",
+	"test-test-warnings",
+	"test-test-warnings-data",
+	"test-test-warnings-data-import-warning",
+	"test-test-warnings-data-stacklevel",
+	"test-test-warnings-main",
+	"test-test-wave",
+	"test-test-weakref",
+	"test-test-weakset",
+	"test-test-webbrowser",
+	"test-test-whichdb",
+	"test-test-winconsoleio",
+	"test-test-winreg",
+	"test-test-winsound",
+	"test-test-with",
+	"test-test-wsgiref",
+	"test-test-xdrlib",
+	"test-test-xml-dom-minicompat",
+	"test-test-xml-etree",
+	"test-test-xml-etree-c",
+	"test-test-xmllib",
+	"test-test-xmlrpc",
+	"test-test-xmlrpc-net",
+	"test-test-xpickle",
+	"test-test-xrange",
+	"test-test-xxsubinterpreters",
+	"test-test-xxtestfuzz",
+	"test-test-yield-from",
+	"test-test-zipapp",
+	"test-test-zipfile",
+	"test-test-zipfile64",
+	"test-test-zipimport",
+	"test-test-zipimport-support",
+	"test-test-zlib",
+	"test-test-zoneinfo",
+	"test-test-zoneinfo-main",
+	"test-test-zoneinfo-support",
+	"test-test-zoneinfo-test-zoneinfo",
+	"test-testall",
+	"test-testcodec",
+	"test-tf-inherit-check",
+	"test-threaded-import-hangers",
+	"test-time-hashlib",
+	"test-tracedmodules",
+	"test-tracedmodules-testmod",
+	"test-typed-dict-helper",
+	"test-warning-tests",
+	"test-win-console-handler",
+	"test-xmltests",
+	"test-ziptestdata",
+	"test-ziptestdata-testdata-module-inside-zip",
+	"testbuffer",
+	"testcapi",
+	"testimportmultiple",
+	"testinternalcapi",
+	"testmultiphase",
+	"textwrap",
+	"this",
+	"thread",
+	"threading",
+	"threading-local",
+	"time",
+	"timeit",
+	"tix",
+	"tkcolorchooser",
+	"tkcommondialog",
+	"tkconstants",
+	"tkdnd",
+	"tkfiledialog",
+	"tkfont",
+	"tkinter",
+	"tkinter-colorchooser",
+	"tkinter-commondialog",
+	"tkinter-constants",
+	"tkinter-dialog",
+	"tkinter-dnd",
+	"tkinter-filedialog",
+	"tkinter-fix",
+	"tkinter-font",
+	"tkinter-main",
+	"tkinter-messagebox",
+	"tkinter-scrolledtext",
+	"tkinter-simpledialog",
+	"tkinter-test",
+	"tkinter-test-runtktests",
+	"tkinter-test-support",
+	"tkinter-test-test-tkinter",
+	"tkinter-test-test-tkinter-test-colorchooser",
+	"tkinter-test-test-tkinter-test-font",
+	"tkinter-test-test-tkinter-test-geometry-managers",
+	"tkinter-test-test-tkinter-test-images",
+	"tkinter-test-test-tkinter-test-loadtk",
+	"tkinter-test-test-tkinter-test-messagebox",
+	"tkinter-test-test-tkinter-test-misc",
+	"tkinter-test-test-tkinter-test-simpledialog",
+	"tkinter-test-test-tkinter-test-text",
+	"tkinter-test-test-tkinter-test-variables",
+	"tkinter-test-test-tkinter-test-widgets",
+	"tkinter-test-test-ttk",
+	"tkinter-test-test-ttk-test-extensions",
+	"tkinter-test-test-ttk-test-functions",
+	"tkinter-test-test-ttk-test-style",
+	"tkinter-test-test-ttk-test-widgets",
+	"tkinter-test-widget-tests",
+	"tkinter-tix",
+	"tkinter-ttk",
+	"tkmessagebox",
+	"tksimpledialog",
+	"toaiff",
+	"token",
+	"tokenize",
+	"tomllib",
+	"tomllib-parser",
+	"tomllib-re",
+	"tomllib-types",
+	"trace",
+	"traceback",
+	"tracemalloc",
+	"ttk",
+	"tty",
+	"turtle",
+	"turtledemo",
+	"turtledemo-bytedesign",
+	"turtledemo-chaos",
+	"turtledemo-clock",
+	"turtledemo-colormixer",
+	"turtledemo-forest",
+	"turtledemo-fractalcurves",
+	"turtledemo-lindenmayer",
+	"turtledemo-main",
+	"turtledemo-minimal-hanoi",
+	"turtledemo-nim",
+	"turtledemo-paint",
+	"turtledemo-peace",
+	"turtledemo-penrose",
+	"turtledemo-planet-and-moon",
+	"turtledemo-rosette",
+	"turtledemo-round-dance",
+	"turtledemo-sorting-animate",
+	"turtledemo-tree",
+	"turtledemo-two-canvases",
+	"turtledemo-wikipedia",
+	"turtledemo-yinyang",
+	"types",
+	"typing",
+	"typing-io",
+	"typing-re",
+	"unicodedata",
+	"unittest",
+	"unittest-async-case",
+	"unittest-case",
+	"unittest-loader",
+	"unittest-log",
+	"unittest-main",
+	"unittest-mock",
+	"unittest-result",
+	"unittest-runner",
+	"unittest-signals",
+	"unittest-suite",
+	"unittest-test",
+	"unittest-test-dummy",
+	"unittest-test-main",
+	"unittest-test-support",
+	"unittest-test-test-assertions",
+	"unittest-test-test-async-case",
+	"unittest-test-test-break",
+	"unittest-test-test-case",
+	"unittest-test-test-discovery",
+	"unittest-test-test-functiontestcase",
+	"unittest-test-test-loader",
+	"unittest-test-test-program",
+	"unittest-test-test-result",
+	"unittest-test-test-runner",
+	"unittest-test-test-setups",
+	"unittest-test-test-skipping",
+	"unittest-test-test-suite",
+	"unittest-test-test-warnings",
+	"unittest-test-testmock",
+	"unittest-test-testmock-main",
+	"unittest-test-testmock-support",
+	"unittest-test-testmock-testasync",
+	"unittest-test-testmock-testcallable",
+	"unittest-test-testmock-testhelpers",
+	"unittest-test-testmock-testmagicmethods",
+	"unittest-test-testmock-testmock",
+	"unittest-test-testmock-testpatch",
+	"unittest-test-testmock-testsealable",
+	"unittest-test-testmock-testsentinel",
+	"unittest-test-testmock-testwith",
+	"unittest-util",
+	"urllib",
+	"urllib-error",
+	"urllib-parse",
+	"urllib-request",
+	"urllib-response",
+	"urllib-robotparser",
+	"urllib2",
+	"urlparse",
+	"user",
+	"userdict",
+	"userlist",
+	"userstring",
+	"uu",
+	"uuid",
+	"venv",
+	"venv-main",
+	"videoreader",
+	"w",
+	"warnings",
+	"wave",
+	"weakref",
+	"weakrefset",
+	"webbrowser",
+	"whichdb",
+	"winapi",
+	"winreg",
+	"winsound",
+	"wmi",
+	"wsgiref",
+	"wsgiref-handlers",
+	"wsgiref-headers",
+	"wsgiref-simple-server",
+	"wsgiref-types",
+	"wsgiref-util",
+	"wsgiref-validate",
+	"xdrlib",
+	"xml",
+	"xml-dom",
+	"xml-dom-domreg",
+	"xml-dom-expatbuilder",
+	"xml-dom-minicompat",
+	"xml-dom-minidom",
+	"xml-dom-nodefilter",
+	"xml-dom-pulldom",
+	"xml-dom-xmlbuilder",
+	"xml-etree",
+	"xml-etree-celementtree",
+	"xml-etree-elementinclude",
+	"xml-etree-elementpath",
+	"xml-etree-elementtree",
+	"xml-parsers",
+	"xml-parsers-expat",
+	"xml-parsers-expat-errors",
+	"xml-parsers-expat-errors-dom",
+	"xml-parsers-expat-errors-etree",
+	"xml-parsers-expat-errors-parsers",
+	"xml-parsers-expat-errors-sax",
+	"xml-parsers-expat-model",
+	"xml-parsers-expat-model-dom",
+	"xml-parsers-expat-model-etree",
+	"xml-parsers-expat-model-parsers",
+	"xml-parsers-expat-model-sax",
+	"xml-sax",
+	"xml-sax-exceptions",
+	"xml-sax-expatreader",
+	"xml-sax-handler",
+	"xml-sax-saxutils",
+	"xml-sax-xmlreader",
+	"xmllib",
+	"xmlrpc",
+	"xmlrpc-client",
+	"xmlrpc-server",
+	"xmlrpclib",
+	"xxlimited",
+	"xxsubinterpreters",
+	"xxsubtype",
+	"xxtestfuzz",
+	"zipapp",
+	"zipfile",
+	"zipfile-main",
+	"zipfile-path",
+	"zipfile-path-glob",
+	"zipimport",
+	"zlib",
+	"zoneinfo",
+	"zoneinfo-common",
+	"zoneinfo-tzpath",
+	"zoneinfo-zoneinfo",
+	"zstd"
+]);
+/** PEP 503: case-insensitive, runs of `-`, `_` and `.` are equivalent. */
+const normalizePypi = (name) => name.toLowerCase().replace(/[-_.]+/g, "-");
+/**
+* Warehouse's `ultranormalize_name`: drops `. _ -`, then maps l/L/i/I to 1 and o/O to 0, so `f1ask`
+* collides with `flask`. PyPI refuses a new name whose ultranormalized form matches an existing project.
+*/
+const ultranormalizePypi = (name) => name.replace(/[._-]/g, "").replace(/[lLiI]/g, "1").replace(/[oO]/g, "0").toLowerCase();
+const VALID = /^([a-z0-9]|[a-z0-9][a-z0-9._-]*[a-z0-9])$/i;
+const SIMPLE_JSON = "application/vnd.pypi.simple.v1+json";
+/** Every project on PyPI, one `ultranormalized\tname` line each, from the simple index (about 10 MB). */
+async function projectList(ctx) {
+	const res = await get(ctx, "https://pypi.org/simple/", {
+		headers: { accept: SIMPLE_JSON },
+		timeoutMs: 12e4
+	});
+	if (!res.ok) throw new Error(`PyPI simple index returned HTTP ${res.status}`);
+	const { projects } = await res.json();
+	if (!Array.isArray(projects) || !projects.length || typeof projects[0]?.name !== "string") throw new Error("PyPI simple index is not in the expected shape");
+	return `\n${projects.map((p) => `${ultranormalizePypi(p.name)}\t${p.name}`).join("\n")}\n`;
+}
+const pypi = defineChannel({
+	id: "pypi",
+	label: "PyPI",
+	category: "package",
+	rules: (name) => {
+		if (!VALID.test(name)) return "PyPI names are letters, digits, and inner . _ -";
+		if (PYPI_STDLIB.has(normalizePypi(name))) return "PyPI reserves Python standard library names";
+	},
+	async lookup(name, ctx) {
+		const normalized = normalizePypi(name);
+		const url = `https://pypi.org/project/${normalized}/`;
+		const res = await get(ctx, `https://pypi.org/pypi/${normalized}/json`);
+		if (res.status === 200) {
+			const { info } = await res.json();
+			return {
+				status: "taken",
+				url,
+				note: info.summary || void 0,
+				meta: {
+					name: info.name,
+					latest: info.version
+				}
+			};
+		}
+		if (res.status !== 404) return unexpected("PyPI", res);
+		const simple = await get(ctx, `https://pypi.org/simple/${normalized}/`, { headers: { accept: SIMPLE_JSON } });
+		if (simple.status === 200) {
+			const doc = await simple.json();
+			const state = doc["project-status"]?.status;
+			return {
+				status: "taken",
+				url,
+				note: state && state !== "active" ? `the project exists but is ${state}` : "the project exists but has no installable release",
+				meta: {
+					name: doc.name,
+					state
+				}
+			};
+		}
+		if (simple.status !== 404) return unexpected("PyPI", simple);
+		let list;
+		try {
+			list = await cachedList(ctx, "pypi-projects", () => projectList(ctx));
+		} catch {
+			return {
+				status: "available",
+				certainty: "probable",
+				note: "could not download PyPI's project list to check its similar-name rule"
+			};
+		}
+		const matches = linesFor(list.text, ultranormalizePypi(name)).map(([n]) => n);
+		if (matches[0]) return {
+			status: "unavailable",
+			note: `PyPI rejects names too similar to "${matches[0]}"`
+		};
+		return list.stale ? {
+			status: "available",
+			certainty: "probable",
+			note: `checked against PyPI's project list from ${asOf(list)}`
+		} : {
+			status: "available",
+			certainty: "confirmed"
+		};
+	}
+});
+const DEFAULT_TLDS = ["com", "dev"];
+const fixed = [
+	npm,
+	pypi,
+	crates,
+	homebrew,
+	github
+];
+function channelIds() {
+	return [
+		...fixed.map((c) => c.id),
+		"domain",
+		"domain:<tld>"
+	];
+}
+/** A domain channel for a TLD as typed (`.dev`, `COM`, `рф`), or an error for one it cannot check. */
+function domainFor(raw) {
+	const display = raw.trim().replace(/^\./, "").toLowerCase();
+	if (!display) throw new Error("a domain channel needs a TLD, as in domain:dev");
+	if (display.includes(".")) throw new Error(`"${display}" has several labels; only top-level domains are supported`);
+	const ascii = domainToASCII(display);
+	if (!ascii) throw new Error(`"${display}" is not a valid TLD`);
+	return domain(ascii, display);
+}
+const unique = (channels) => channels.filter((c, i) => channels.findIndex((p) => p.id === c.id) === i);
+function selectChannels({ only, tlds = DEFAULT_TLDS } = {}) {
+	const all = unique([...fixed, ...tlds.map(domainFor)]);
+	if (!only?.length) return all;
+	const picked = [];
+	for (const raw of only) {
+		const id = raw.trim().toLowerCase();
+		if (id === "domain") picked.push(...all.filter((c) => c.category === "domain"));
+		else if (id.startsWith("domain:")) picked.push(domainFor(raw.trim().slice(7)));
+		else {
+			const channel = fixed.find((c) => c.id === id);
+			if (!channel) throw new Error(`unknown channel "${raw}"; expected one of: ${channelIds().join(", ")}`);
+			picked.push(channel);
+		}
+	}
+	return unique(picked);
+}
+/** The OS cache directory: ~/Library/Caches on macOS, XDG on Linux, LOCALAPPDATA on Windows. */
+function defaultCacheDir(env = process.env, platform = process.platform, home = homedir()) {
+	if (env.NAMEABLE_CACHE_DIR) return env.NAMEABLE_CACHE_DIR;
+	const path = platform === "win32" ? win32 : posix;
+	const base = (value) => value && path.isAbsolute(value) ? value : void 0;
+	if (platform === "darwin") return path.join(home, "Library", "Caches", "nameable");
+	if (platform === "win32") return path.join(base(env.LOCALAPPDATA) ?? path.join(home, "AppData", "Local"), "nameable", "Cache");
+	return path.join(base(env.XDG_CACHE_HOME) ?? path.join(home, ".cache"), "nameable");
+}
+/** Gzipped files in `dir`, one per key; a file's modification time is when it was saved. */
+function fileStore(dir) {
+	const path = (key) => join(dir, `${key}.gz`);
+	return {
+		async read(key) {
+			try {
+				const [data, info] = await Promise.all([readFile(path(key)), stat(path(key))]);
+				return {
+					text: gunzipSync(data).toString("utf8"),
+					savedAt: info.mtimeMs
+				};
+			} catch {
+				return;
+			}
+		},
+		async write(key, text) {
+			await mkdir(dir, { recursive: true });
+			const partial = `${path(key)}.${process.pid}.partial`;
+			await writeFile(partial, gzipSync(text));
+			await rename(partial, path(key));
+		}
+	};
+}
+/** Deletes the lists this tool saves in `dir`, and `dir` itself only when nothing else is left in it. */
+async function clearStore(dir) {
+	await Promise.all(LIST_KEYS.map((key) => rm(join(dir, `${key}.gz`), { force: true })));
+	await rmdir(dir).catch(() => void 0);
+}
+//#endregion
+export { defaultCacheDir as a, clearStore as i, channelIds as n, fileStore as o, checkMany as r, selectChannels as s, DEFAULT_TLDS as t };
+
+//# sourceMappingURL=dist-kIDsX2Ie.mjs.map