@mark1russell7/site-pages 0.0.0-bootstrap.0 → 0.1.0

package/build/build-vAps0mRE.js

@@ -0,0 +1,2267 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, posix, resolve } from "node:path";
+import { parseArgs } from "node:util";
+//#region src/data/versions.ts
+const SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+/** This function gives the parts of a version, or null when the text is not a SemVer version. */
+function parseVersion(version) {
+	const match = SEMVER.exec(version);
+	if (!match) return null;
+	return {
+		major: Number(match[1]),
+		minor: Number(match[2]),
+		patch: Number(match[3]),
+		prerelease: match[4] ? match[4].split(".") : []
+	};
+}
+/**
+* This function compares two versions by the SemVer precedence. It gives a negative number when `a`
+* is older, a positive number when `a` is newer, and 0 for the same version. A text that is not a
+* version comes before each version.
+*/
+function compareVersions(a, b) {
+	const x = parseVersion(a);
+	const y = parseVersion(b);
+	if (!x || !y) return x ? 1 : y ? -1 : a.localeCompare(b);
+	const core = x.major - y.major || x.minor - y.minor || x.patch - y.patch;
+	if (core !== 0) return core;
+	if (x.prerelease.length === 0 || y.prerelease.length === 0) return y.prerelease.length - x.prerelease.length;
+	for (let index = 0; index < Math.max(x.prerelease.length, y.prerelease.length); index++) {
+		const p = x.prerelease[index];
+		const q = y.prerelease[index];
+		if (p === void 0) return -1;
+		if (q === void 0) return 1;
+		if (p === q) continue;
+		const pNumber = /^\d+$/.test(p);
+		const qNumber = /^\d+$/.test(q);
+		if (pNumber && qNumber) return Number(p) - Number(q);
+		if (pNumber !== qNumber) return pNumber ? -1 : 1;
+		return p < q ? -1 : 1;
+	}
+	return 0;
+}
+/**
+* This function gives the kind of a version. The oldest version of the list is "first". The caller
+* tells if the version is the oldest.
+*/
+function kindOf(version, oldest) {
+	if (oldest) return "first";
+	const parsed = parseVersion(version);
+	if (!parsed) return "patch";
+	if (parsed.major > 0 && parsed.minor === 0 && parsed.patch === 0) return "major";
+	return parsed.patch === 0 ? "minor" : "patch";
+}
+/**
+* This function reads the version of a git tag. It knows `1.2.3`, `v1.2.3` and the tags of Changesets:
+* `name@1.2.3` and `@scope/name@1.2.3`. It gives null for another tag.
+*/
+function versionOfTag(tag) {
+	const match = /^(?:(.+)@)?v?(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.+-]*)?)$/.exec(tag.trim());
+	if (!match || match[2] === void 0 || !parseVersion(match[2])) return null;
+	return {
+		version: match[2],
+		package: match[1] ?? null
+	};
+}
+//#endregion
+//#region src/data/changelog.ts
+const VERSION_HEADING = /^##\s+\[?v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\]?(?:\s.*)?$/;
+const COMMIT_ENTRY = /^([0-9a-f]{7,40}):\s+([\s\S]*)$/;
+const DEPENDENCY_ENTRY = /^(?:Updated dependencies\b|@?[\w.-]+(?:\/[\w.-]+)?@\S+\s*$)/;
+const GENERATED_NOTE = /\s+by\s+@[\w-]+(?:\[bot\])?\s+in\s+(https:\/\/github\.com\/[\w.-]+\/[\w.-]+\/pull\/(\d+))\s*$/;
+const FIRST_CONTRIBUTION = /\bmade their first contribution\b/;
+/**
+* This function gives the first sentence of a text. A full stop, a question mark or an exclamation
+* mark ends the sentence when a space and no lowercase letter follow it.
+*
+* @remarks A mark in a code span does not end the sentence. A text that ends with a colon (a list
+* follows) ends with a full stop.
+*/
+function firstSentence(text) {
+	const clean = text.replace(/\s+/g, " ").trim();
+	let code = false;
+	for (let index = 0; index < clean.length; index++) {
+		const char = clean[index];
+		if (char === "`") {
+			code = !code;
+			continue;
+		}
+		if (code || char !== "." && char !== "?" && char !== "!") continue;
+		const next = clean[index + 1];
+		if (next === void 0) break;
+		if (next === " " && !/^[a-z]/.test(clean.slice(index + 2))) return clean.slice(0, index + 1);
+	}
+	return clean.replace(/:$/, ".");
+}
+/**
+* This function makes one entry from the lines of a list item. The text is the first paragraph: the
+* lines before an empty line or a nested list. It gives null for an entry that is not a change.
+*/
+function entryOf(lines) {
+	const paragraph = [];
+	for (const [index, line] of lines.entries()) {
+		if (index > 0 && (line.trim() === "" || /^\s+[-*+]\s/.test(line))) break;
+		paragraph.push(line.trim());
+	}
+	const text = paragraph.join(" ");
+	const commit = COMMIT_ENTRY.exec(text);
+	let body = (commit ? commit[2] : text) ?? "";
+	if (body.trim() === "" || DEPENDENCY_ENTRY.test(body.trim()) || FIRST_CONTRIBUTION.test(body)) return null;
+	body = body.replace(GENERATED_NOTE, (_match, url, number) => ` ([#${number}](${url}))`);
+	return {
+		commit: commit?.[1] ?? null,
+		text: firstSentence(body)
+	};
+}
+/**
+* This function gives the entries of each version of a changelog, in the sequence of the file.
+*
+* @remarks An entry is a line that starts with "- " and the indented lines under it. An entry for a
+* new dependency version is not a change.
+*/
+function parseChangelog(markdown) {
+	const sections = [];
+	let section = null;
+	let entry = null;
+	const close = () => {
+		if (entry && section) section.raw.push(entry);
+		entry = null;
+	};
+	for (const line of markdown.split(/\r?\n/)) {
+		const heading = VERSION_HEADING.exec(line);
+		if (heading?.[1] !== void 0) {
+			close();
+			section = {
+				version: heading[1],
+				heading: line.replace(/^##\s+/, "").trim(),
+				raw: []
+			};
+			sections.push(section);
+			continue;
+		}
+		if (section === null) continue;
+		if (line.startsWith("- ")) {
+			close();
+			entry = [line.slice(2)];
+		} else if (entry && (line.trim() === "" || /^\s/.test(line))) entry.push(line);
+		else {
+			close();
+			if (/^#{1,2}\s/.test(line)) section = null;
+		}
+	}
+	close();
+	return sections.map(({ version, heading, raw }) => ({
+		version,
+		heading,
+		entries: raw.map(entryOf).filter((change) => change !== null)
+	}));
+}
+/**
+* This function gives the changes of the text of a GitHub release: one change for each top-level
+* list item. Fenced code is not read.
+*/
+function releaseBodyEntries(body) {
+	const entries = [];
+	let entry = null;
+	let fence = null;
+	const close = () => {
+		const change = entry ? entryOf(entry) : null;
+		if (change) entries.push(change);
+		entry = null;
+	};
+	for (const line of body.split(/\r?\n/)) {
+		const fenceMark = /^\s*(`{3,}|~{3,})/.exec(line)?.[1];
+		if (fenceMark !== void 0) {
+			close();
+			if (fence === null) fence = fenceMark[0] ?? null;
+			else if (fenceMark[0] === fence) fence = null;
+			continue;
+		}
+		if (fence !== null) continue;
+		const item = /^[-*+]\s+(.*)$/.exec(line);
+		if (item?.[1] !== void 0) {
+			close();
+			entry = [item[1]];
+		} else if (entry && (line.trim() === "" || /^\s/.test(line))) entry.push(line);
+		else close();
+	}
+	close();
+	return entries;
+}
+/**
+* This function gives the anchor of a heading on GitHub: lowercase, no punctuation, and a hyphen
+* for each space. The anchor of "0.13.2" is "0132".
+*/
+function headingAnchor(heading) {
+	return heading.toLowerCase().trim().replace(/[^\p{L}\p{N}\s_-]/gu, "").replace(/\s/g, "-");
+}
+//#endregion
+//#region src/data/github.ts
+/** The GraphQL endpoint of GitHub. */
+const GITHUB_GRAPHQL = "https://api.github.com/graphql";
+/** The REST endpoint of GitHub. */
+const GITHUB_API = "https://api.github.com";
+const USER_AGENT = "site-pages";
+const OPEN_WORK_QUERY = `query OpenWork($owner: String!, $repo: String!, $first: Int!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequests(states: OPEN, first: $first, orderBy: {field: UPDATED_AT, direction: DESC}) {
+      totalCount
+      nodes {
+        number title url isDraft createdAt updatedAt headRefName
+        author { login }
+        labels(first: 10) { nodes { name } }
+        commits(last: 1) { nodes { commit { statusCheckRollup { state } } } }
+      }
+    }
+    issues(states: OPEN, first: $first, orderBy: {field: UPDATED_AT, direction: DESC}) {
+      totalCount
+      nodes {
+        number title url createdAt updatedAt
+        author { login }
+        labels(first: 10) { nodes { name } }
+      }
+    }
+  }
+}`;
+/** This function gives the combined check state of a commit: success, failure, pending or none. */
+function checkStateOf(rollup) {
+	switch (rollup?.state) {
+		case "SUCCESS": return "success";
+		case "FAILURE":
+		case "ERROR": return "failure";
+		case "PENDING":
+		case "EXPECTED": return "pending";
+		default: return "none";
+	}
+}
+const object$1 = (value) => value !== null && typeof value === "object" ? value : {};
+const list = (value) => Array.isArray(value) ? value : [];
+const text = (value, fallback = "") => typeof value === "string" ? value : fallback;
+const labelsOf = (node) => list(object$1(node["labels"])["nodes"]).map((label) => object$1(label)["name"]).filter((name) => typeof name === "string");
+const authorOf = (node) => text(object$1(node["author"])["login"], "ghost");
+function failure(error, timeoutMs) {
+	if (object$1(error)["name"] === "TimeoutError") return {
+		available: false,
+		reason: `GitHub did not answer in ${timeoutMs / 1e3} s`
+	};
+	return {
+		available: false,
+		reason: `the request failed: ${error instanceof Error ? error.message : String(error)}`
+	};
+}
+function precheck(options) {
+	if (!options.owner || !options.repo) return {
+		available: false,
+		reason: "no repository was given"
+	};
+	if (!options.token) return {
+		available: false,
+		reason: "the build had no GitHub token"
+	};
+	if (typeof (options.fetch ?? globalThis.fetch) !== "function") return {
+		available: false,
+		reason: "this Node has no fetch"
+	};
+	return null;
+}
+/**
+* This function reads the open pull requests and issues of a repository with one GraphQL request,
+* the most recently updated first. It gives `{ available: false, reason }` without a token or after
+* an error. It does not throw.
+*/
+async function githubOpenWork(options) {
+	const stop = precheck(options);
+	if (stop) return stop;
+	const { owner, repo, token, endpoint = GITHUB_GRAPHQL, first = 50, timeoutMs = 15e3 } = options;
+	const fetcher = options.fetch ?? globalThis.fetch;
+	try {
+		const response = await fetcher(endpoint, {
+			method: "POST",
+			headers: {
+				authorization: `bearer ${token}`,
+				"content-type": "application/json",
+				"user-agent": USER_AGENT
+			},
+			body: JSON.stringify({
+				query: OPEN_WORK_QUERY,
+				variables: {
+					owner,
+					repo,
+					first
+				}
+			}),
+			signal: AbortSignal.timeout(timeoutMs)
+		});
+		if (!response.ok) return {
+			available: false,
+			reason: `GitHub answered with HTTP ${response.status}`
+		};
+		const body = object$1(await response.json());
+		const errors = list(body["errors"]);
+		if (errors.length > 0) return {
+			available: false,
+			reason: `GitHub gave an error: ${text(object$1(errors[0])["message"], "no message")}`
+		};
+		const repository = object$1(body["data"])["repository"];
+		if (repository === null || typeof repository !== "object") return {
+			available: false,
+			reason: `GitHub has no repository ${owner}/${repo}`
+		};
+		const pulls = object$1(repository["pullRequests"]);
+		const open = object$1(repository["issues"]);
+		const pullRequests = list(pulls["nodes"]).filter((node) => node !== null && typeof node === "object").map((value) => {
+			const node = object$1(value);
+			const lastCommit = object$1(object$1(list(object$1(node["commits"])["nodes"])[0])["commit"]);
+			return {
+				number: Number(node["number"]),
+				title: text(node["title"]),
+				url: text(node["url"]),
+				author: authorOf(node),
+				branch: text(node["headRefName"]),
+				draft: node["isDraft"] === true,
+				createdAt: text(node["createdAt"]),
+				updatedAt: text(node["updatedAt"]),
+				labels: labelsOf(node),
+				checks: checkStateOf(object$1(lastCommit["statusCheckRollup"]))
+			};
+		});
+		const issues = list(open["nodes"]).filter((node) => node !== null && typeof node === "object").map((value) => {
+			const node = object$1(value);
+			return {
+				number: Number(node["number"]),
+				title: text(node["title"]),
+				url: text(node["url"]),
+				author: authorOf(node),
+				createdAt: text(node["createdAt"]),
+				updatedAt: text(node["updatedAt"]),
+				labels: labelsOf(node)
+			};
+		});
+		const total = (value, fallback) => typeof value === "number" ? value : fallback;
+		return {
+			available: true,
+			pullRequests,
+			issues,
+			totals: {
+				pullRequests: total(pulls["totalCount"], pullRequests.length),
+				issues: total(open["totalCount"], issues.length)
+			}
+		};
+	} catch (error) {
+		return failure(error, timeoutMs);
+	}
+}
+/** This function gives the URL of the next page from a `Link` header of GitHub, or null. */
+function nextPage(link) {
+	if (!link) return null;
+	for (const part of link.split(",")) {
+		const match = /<([^>]+)>\s*;\s*rel="next"/.exec(part);
+		if (match?.[1]) return match[1];
+	}
+	return null;
+}
+/**
+* This function reads the published releases of a repository with the REST API, the newest first.
+* It skips the drafts. It gives `{ available: false, reason }` without a token or after an error.
+* It does not throw.
+*
+* @remarks The function reads 100 releases on each page, and at most `maxPages` pages (default 10).
+*/
+async function githubReleases(options) {
+	const stop = precheck(options);
+	if (stop) return stop;
+	const { owner, repo, token, endpoint = GITHUB_API, maxPages = 10, timeoutMs = 15e3 } = options;
+	const fetcher = options.fetch ?? globalThis.fetch;
+	const releases = [];
+	let url = `${endpoint}/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/releases?per_page=100`;
+	try {
+		for (let page = 0; url !== null && page < maxPages; page++) {
+			const response = await fetcher(url, {
+				headers: {
+					accept: "application/vnd.github+json",
+					authorization: `Bearer ${token}`,
+					"user-agent": USER_AGENT,
+					"x-github-api-version": "2022-11-28"
+				},
+				signal: AbortSignal.timeout(timeoutMs)
+			});
+			if (response.status === 404) return {
+				available: false,
+				reason: `GitHub has no repository ${owner}/${repo}`
+			};
+			if (!response.ok) return {
+				available: false,
+				reason: `GitHub answered with HTTP ${response.status}`
+			};
+			const body = await response.json();
+			if (!Array.isArray(body)) return {
+				available: false,
+				reason: "GitHub gave no list of releases"
+			};
+			for (const value of body) {
+				const release = object$1(value);
+				const tag = release["tag_name"];
+				if (release["draft"] === true || typeof tag !== "string") continue;
+				releases.push({
+					tag,
+					name: text(release["name"]) || tag,
+					body: text(release["body"]),
+					publishedAt: text(release["published_at"]) || text(release["created_at"]),
+					url: text(release["html_url"]),
+					prerelease: release["prerelease"] === true
+				});
+			}
+			url = nextPage(response.headers.get("link"));
+		}
+		return {
+			available: true,
+			releases
+		};
+	} catch (error) {
+		return failure(error, timeoutMs);
+	}
+}
+//#endregion
+//#region src/data/npm.ts
+/** The public npm registry. */
+const NPM_REGISTRY = "https://registry.npmjs.org";
+const object = (value) => value !== null && typeof value === "object" ? value : {};
+function message(error) {
+	if (object(error)["name"] === "TimeoutError") return "npm did not answer in time";
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* This function reads the publication time of each version of the packages from the npm registry.
+* A scope (`@name`) gives each package of the scope. It does not throw. Each failure gives a
+* message in `problems`.
+*/
+async function npmPublishTimes(options) {
+	const { registry = NPM_REGISTRY, timeoutMs = 15e3 } = options;
+	const fetcher = options.fetch ?? globalThis.fetch;
+	const problems = [];
+	const times = [];
+	if (typeof fetcher !== "function") return {
+		times,
+		problems: ["this Node has no fetch"]
+	};
+	const get = async (url) => {
+		const response = await fetcher(url, {
+			headers: { accept: "application/json" },
+			signal: AbortSignal.timeout(timeoutMs)
+		});
+		if (!response.ok) throw new Error(`HTTP ${response.status}`);
+		return response.json();
+	};
+	const names = /* @__PURE__ */ new Set();
+	for (const entry of options.packages.map((name) => name.trim()).filter(Boolean)) {
+		if (!/^@[^/]+$/.test(entry)) {
+			names.add(entry);
+			continue;
+		}
+		try {
+			const found = object(await get(`${registry}/-/v1/search?text=scope:${encodeURIComponent(entry.slice(1))}&size=250`));
+			const objects = Array.isArray(found["objects"]) ? found["objects"] : [];
+			const before = names.size;
+			for (const item of objects) {
+				const name = object(object(item)["package"])["name"];
+				if (typeof name === "string" && name.startsWith(`${entry}/`)) names.add(name);
+			}
+			if (names.size === before) problems.push(`npm has no package in the scope ${entry}`);
+		} catch (error) {
+			problems.push(`npm did not give the packages of ${entry}: ${message(error)}`);
+		}
+	}
+	const queue = [...names].sort();
+	const worker = async () => {
+		for (let name = queue.shift(); name !== void 0; name = queue.shift()) try {
+			const packument = object(await get(`${registry}/${name.replace("/", "%2f")}`));
+			const published = object(packument["versions"]);
+			for (const [version, date] of Object.entries(object(packument["time"]))) {
+				if (version === "created" || version === "modified" || typeof date !== "string") continue;
+				if (!(version in published)) continue;
+				times.push({
+					name,
+					version,
+					date
+				});
+			}
+		} catch (error) {
+			problems.push(`npm did not give the versions of ${name}: ${message(error)}`);
+		}
+	};
+	await Promise.all(Array.from({ length: 4 }, worker));
+	times.sort((a, b) => a.name.localeCompare(b.name) || a.date.localeCompare(b.date));
+	return {
+		times,
+		problems
+	};
+}
+//#endregion
+//#region src/data/git.ts
+/**
+* The git source: the tags with their dates, the commit of the build and the GitHub remote. Each
+* function gives an empty result when git or the repository is not available.
+*/
+/** This function starts git in a folder and gives its output, or null when git fails. */
+function git(repoDir, ...args) {
+	try {
+		return execFileSync("git", args, {
+			cwd: repoDir,
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			],
+			windowsHide: true
+		});
+	} catch {
+		return null;
+	}
+}
+/** This function tells if the clone is shallow. A shallow clone has not all the tags and commits. */
+function isShallow(repoDir) {
+	return git(repoDir, "rev-parse", "--is-shallow-repository")?.trim() === "true";
+}
+/** This function gives each tag of the repository with its date. An annotated tag has its own date. */
+function gitTagDates(repoDir) {
+	const output = git(repoDir, "for-each-ref", "--format=%(refname:strip=2) %(creatordate:iso-strict)", "refs/tags");
+	if (!output) return [];
+	const tags = [];
+	for (const line of output.split(/\r?\n/)) {
+		const match = /^(\S+) (\S+)$/.exec(line.trim());
+		if (match?.[1] && match[2]) tags.push({
+			tag: match[1],
+			date: match[2]
+		});
+	}
+	return tags;
+}
+/**
+* This function gives the date of the oldest commit that added a version heading to a changelog,
+* or null. The path of the changelog starts at `repoDir`.
+*/
+function headingDate(repoDir, version, file) {
+	const dates = (git(repoDir, "log", "--format=%cI", `-S## ${version}`, "--", file) ?? "").trim().split(/\r?\n/).filter(Boolean);
+	return dates[dates.length - 1] ?? null;
+}
+/** This function gives the full SHA of `HEAD`, or null. */
+function headCommit(repoDir) {
+	const sha = git(repoDir, "rev-parse", "HEAD")?.trim();
+	return sha && /^[0-9a-f]{40}$/.test(sha) ? sha : null;
+}
+/** This function gives "owner/name" of the GitHub remote "origin", or null. */
+function originRepository(repoDir) {
+	const url = git(repoDir, "remote", "get-url", "origin")?.trim() ?? "";
+	const match = /github\.com[:/]([^/]+)\/(.+?)(?:\.git)?\/?$/.exec(url);
+	return match ? `${match[1]}/${match[2]}` : null;
+}
+//#endregion
+//#region src/data/glob.ts
+/**
+* A small glob for the changelog files. The syntax has `*` and `?` in one path segment, and `**` for
+* zero or more folders.
+*/
+function segmentPattern(segment) {
+	const source = segment.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]");
+	return new RegExp(`^${source}$`);
+}
+const SKIP = /* @__PURE__ */ new Set(["node_modules", ".git"]);
+/**
+* This function gives the files under `root` that match a pattern, as paths with `/` that start at
+* `root`, sorted. It does not go into `node_modules` or `.git`.
+*/
+function globFiles(root, pattern) {
+	const segments = pattern.replace(/\\/g, "/").replace(/^\.\//, "").split("/").filter(Boolean);
+	const found = /* @__PURE__ */ new Set();
+	const walk = (dir, prefix, index) => {
+		const segment = segments[index];
+		if (segment === void 0) return;
+		const last = index === segments.length - 1;
+		if (segment === "**") {
+			walk(dir, prefix, index + 1);
+			for (const entry of safeList(dir)) if (entry.isDirectory() && !SKIP.has(entry.name)) walk(join(dir, entry.name), `${prefix}${entry.name}/`, index);
+			return;
+		}
+		if (!/[*?]/.test(segment)) {
+			const path = join(dir, segment);
+			if (!existsSync(path)) return;
+			if (last) {
+				if (statSync(path).isFile()) found.add(`${prefix}${segment}`);
+			} else if (statSync(path).isDirectory()) walk(path, `${prefix}${segment}/`, index + 1);
+			return;
+		}
+		const matcher = segmentPattern(segment);
+		for (const entry of safeList(dir)) {
+			if (!matcher.test(entry.name) || SKIP.has(entry.name)) continue;
+			if (last && entry.isFile()) found.add(`${prefix}${entry.name}`);
+			else if (!last && entry.isDirectory()) walk(join(dir, entry.name), `${prefix}${entry.name}/`, index + 1);
+		}
+	};
+	walk(root, "", 0);
+	return [...found].sort();
+}
+function safeList(dir) {
+	try {
+		return readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+}
+//#endregion
+//#region src/data/releases.ts
+/**
+* The release data: one entry for each version. The sources are the changelogs of Changesets, the
+* GitHub releases, the git tags and the publication times on npm.
+*/
+/** An error in the release sources, for example a group without a changelog. */
+var ReleaseDataError = class extends Error {};
+function addChange(changes, entry, packageName) {
+	const key = entry.commit ?? `text:${entry.text}`;
+	const change = changes.get(key) ?? {
+		commit: entry.commit,
+		text: entry.text,
+		packages: []
+	};
+	if (packageName && !change.packages.includes(packageName)) change.packages.push(packageName);
+	changes.set(key, change);
+}
+function sortedChanges(changes) {
+	return [...changes?.values() ?? []].map((change) => ({
+		...change,
+		packages: [...change.packages].sort()
+	})).sort((a, b) => b.packages.length - a.packages.length || a.text.localeCompare(b.text));
+}
+/** The earliest of some ISO dates, or null. */
+function earliest(dates) {
+	let best = null;
+	for (const date of dates) {
+		if (!date || !Number.isFinite(Date.parse(date))) continue;
+		if (best === null || Date.parse(date) < Date.parse(best)) best = date;
+	}
+	return best;
+}
+/** The URL path of a git ref: each character that a URL cannot hold is encoded, and "@" and "/" stay. */
+function refPath(ref) {
+	return encodeURI(ref).replace(/#/g, "%23").replace(/\?/g, "%3F");
+}
+/**
+* This function merges the release sources into one entry for each version, the newest first.
+*
+* - The versions: the changelog of `group`, or else each changelog version and each GitHub release.
+* - The date: the git tag, else the GitHub release, else npm, else the commit of the changelog heading.
+* - The changes: the changelog entries, else the list items of the GitHub release text.
+*
+* @throws ReleaseDataError when `group` has no changelog and other changelogs exist
+*/
+function mergeReleases(sources) {
+	const { group, repository, ref = "HEAD", warn = () => {} } = sources;
+	const changelogs = sources.changelogs ?? [];
+	const inGroup = (packageName) => !group || packageName === null || packageName === group;
+	const parsed = changelogs.map((source) => ({
+		source,
+		sections: parseChangelog(source.markdown)
+	}));
+	const groupChangelog = group ? parsed.find((entry) => entry.source.name === group) : void 0;
+	if (group && parsed.length > 0 && !groupChangelog) throw new ReleaseDataError(`no changelog of ${group}`);
+	const githubByVersion = /* @__PURE__ */ new Map();
+	for (const release of sources.githubReleases ?? []) {
+		const tag = versionOfTag(release.tag);
+		if (!tag) continue;
+		const list = githubByVersion.get(tag.version) ?? [];
+		list.push({
+			release,
+			package: tag.package
+		});
+		githubByVersion.set(tag.version, list);
+	}
+	const versions = /* @__PURE__ */ new Set();
+	if (groupChangelog) for (const section of groupChangelog.sections) versions.add(section.version);
+	else {
+		for (const { sections } of parsed) for (const section of sections) versions.add(section.version);
+		for (const [version, list] of githubByVersion) if (list.some((entry) => inGroup(entry.package))) versions.add(version);
+	}
+	const ordered = [...versions].sort((a, b) => compareVersions(b, a));
+	if (ordered.length === 0) return [];
+	const changelogChanges = /* @__PURE__ */ new Map();
+	const changelogOf = /* @__PURE__ */ new Map();
+	const groupFirst = groupChangelog ? [groupChangelog, ...parsed.filter((entry) => entry !== groupChangelog)] : parsed;
+	for (const { source, sections } of groupFirst) for (const section of sections) {
+		if (!versions.has(section.version)) continue;
+		if (!changelogOf.has(section.version)) changelogOf.set(section.version, {
+			source,
+			heading: section.heading
+		});
+		const changes = changelogChanges.get(section.version) ?? /* @__PURE__ */ new Map();
+		for (const entry of section.entries) addChange(changes, entry, source.name);
+		changelogChanges.set(section.version, changes);
+	}
+	const tagsByVersion = /* @__PURE__ */ new Map();
+	for (const tag of sources.tags ?? []) {
+		const parsedTag = versionOfTag(tag.tag);
+		if (!parsedTag || !inGroup(parsedTag.package)) continue;
+		const list = tagsByVersion.get(parsedTag.version) ?? [];
+		list.push(tag);
+		tagsByVersion.set(parsedTag.version, list);
+	}
+	const npmByVersion = /* @__PURE__ */ new Map();
+	for (const time of sources.npm ?? []) {
+		const list = npmByVersion.get(time.version) ?? [];
+		list.push(time);
+		npmByVersion.set(time.version, list);
+	}
+	const dates = /* @__PURE__ */ new Map();
+	const missing = [];
+	for (const version of ordered) {
+		const github = (githubByVersion.get(version) ?? []).filter((entry) => inGroup(entry.package));
+		const npm = npmByVersion.get(version) ?? [];
+		const npmGroup = group ? npm.filter((time) => time.name === group) : [];
+		const changelog = changelogOf.get(version);
+		const date = earliest((tagsByVersion.get(version) ?? []).map((tag) => tag.date)) ?? earliest(github.map((entry) => entry.release.publishedAt)) ?? earliest((npmGroup.length > 0 ? npmGroup : npm).map((time) => time.date)) ?? (changelog && sources.headingDate ? sources.headingDate(version, changelog.source.file) : null);
+		if (date) dates.set(version, date);
+		else missing.push(version);
+	}
+	if (missing.length > 0) {
+		warn(`no source gives a date for ${missing.join(", ")}. The page shows an approximate date.`);
+		let newer = sources.now ?? (/* @__PURE__ */ new Date()).toISOString();
+		for (const version of ordered) {
+			const date = dates.get(version);
+			if (date) newer = date;
+			else dates.set(version, newer);
+		}
+	}
+	const oldest = ordered[ordered.length - 1];
+	return ordered.map((version) => {
+		const github = githubByVersion.get(version) ?? [];
+		let changes = changelogChanges.get(version);
+		if (!changes) {
+			changes = /* @__PURE__ */ new Map();
+			for (const { release, package: packageName } of github) for (const entry of releaseBodyEntries(release.body)) addChange(changes, entry, packageName ?? (group || null));
+		}
+		const links = [];
+		const githubRelease = github.find((entry) => entry.package === group) ?? github.find((entry) => entry.package === null) ?? github[0];
+		if (githubRelease?.release.url) links.push({
+			label: "GitHub release",
+			url: githubRelease.release.url
+		});
+		else if (repository) {
+			const tag = (tagsByVersion.get(version) ?? [])[0];
+			if (tag) links.push({
+				label: "Tag",
+				url: `https://github.com/${repository}/releases/tag/${refPath(tag.tag)}`
+			});
+		}
+		const changelog = changelogOf.get(version);
+		if (changelog && repository) links.push({
+			label: "Changelog",
+			url: `https://github.com/${repository}/blob/${refPath(ref)}/${changelog.source.file}#${headingAnchor(changelog.heading)}`
+		});
+		const npm = npmByVersion.get(version) ?? [];
+		const npmPackage = npm.find((time) => time.name === group) ?? npm[0];
+		if (npmPackage) links.push({
+			label: "npm",
+			url: `https://www.npmjs.com/package/${npmPackage.name}/v/${version}`
+		});
+		return {
+			version,
+			date: dates.get(version) ?? sources.now ?? (/* @__PURE__ */ new Date()).toISOString(),
+			kind: kindOf(version, version === oldest),
+			changes: sortedChanges(changes),
+			links
+		};
+	});
+}
+/** The default patterns of the changelog files: the first pattern that finds a file wins. */
+const DEFAULT_CHANGELOGS = ["packages/*/CHANGELOG.md", "CHANGELOG.md"];
+/**
+* This function reads the changelog files of a repository. The npm name of each changelog comes from
+* the `package.json` next to it, else from its folder.
+*/
+function readChangelogs(repoDir, pattern) {
+	const patterns = pattern ? [pattern] : DEFAULT_CHANGELOGS;
+	for (const candidate of patterns) {
+		const files = globFiles(repoDir, candidate);
+		if (files.length === 0) continue;
+		return files.map((file) => {
+			const path = join(repoDir, ...file.split("/"));
+			const manifest = join(dirname(path), "package.json");
+			let name = basename(dirname(path));
+			if (existsSync(manifest)) try {
+				const parsed = JSON.parse(readFileSync(manifest, "utf8"));
+				if (typeof parsed.name === "string" && parsed.name) name = parsed.name;
+			} catch {}
+			return {
+				name,
+				file,
+				markdown: readFileSync(path, "utf8")
+			};
+		});
+	}
+	return [];
+}
+/**
+* This function reads all the release sources of a repository and merges them. A failure of GitHub
+* or npm does not stop it, but gives a warning.
+*
+* @throws ReleaseDataError when `group` has no changelog and other changelogs exist
+*/
+async function readReleases(options) {
+	const { repoDir, repository, warn = () => {} } = options;
+	const changelogs = readChangelogs(repoDir, options.changesets);
+	const tags = gitTagDates(repoDir);
+	if (isShallow(repoDir)) warn("the clone is shallow, so the release dates are not exact. Check out the full history (fetch-depth 0).");
+	let releases = [];
+	const [owner = "", repo = ""] = (repository ?? "").split("/");
+	if (owner && repo) {
+		const result = await githubReleases({
+			owner,
+			repo,
+			token: options.token,
+			...options.fetch ? { fetch: options.fetch } : {}
+		});
+		if (result.available) releases = result.releases;
+		else warn(`the releases page has no GitHub releases: ${result.reason}.`);
+	}
+	let npm = [];
+	if (options.packages && options.packages.length > 0) {
+		const result = await npmPublishTimes({
+			packages: options.packages,
+			...options.fetch ? { fetch: options.fetch } : {}
+		});
+		npm = result.times;
+		for (const problem of result.problems) warn(problem);
+	}
+	return mergeReleases({
+		changelogs,
+		githubReleases: releases,
+		tags,
+		npm,
+		group: options.group,
+		repository,
+		ref: options.ref,
+		headingDate: (version, file) => headingDate(repoDir, version, file),
+		now: options.now,
+		warn
+	});
+}
+//#endregion
+//#region src/data/status.ts
+/**
+* The status data: the open work of a roadmap file, and the open pull requests and issues of a
+* GitHub repository. The build reads both, so the page shows the state at the time of the build.
+*
+* @remarks The roadmap parser reads each Markdown table with an `ID` column and a `Status` column.
+* It is strict: a row whose cells do not match the header stops the build with the file and the line.
+*/
+/** The classes of a status, in the sequence of the board. The open work comes first. */
+const STATUS_CLASSES = [
+	"waiting",
+	"blocked",
+	"progress",
+	"open",
+	"later",
+	"done"
+];
+/** The open classes, in the sequence of the board. */
+const OPEN_CLASSES = [
+	"waiting",
+	"blocked",
+	"progress",
+	"open",
+	"later"
+];
+/** An error in the roadmap file, with the file and the line. */
+var RoadmapParseError = class extends Error {};
+const STATUS_KEYWORDS = [
+	["open", /\bnot\s+(?:yet\s+)?(?:started|done|fixed|merged|shipped|released)\b|\bto[ -]?do\b/],
+	["done", /\b(?:done|shipped|merged|fixed|released|complete|completed|closed)\b/],
+	["progress", /\bin[ -]progress\b|\b(?:active|ongoing|started|wip)\b/],
+	["waiting", /\b(?:waiting|waits|awaiting|needs)\b/],
+	["blocked", /\bblocked\b/],
+	["later", /\b(?:later|deferred|postponed|someday)\b/]
+];
+/**
+* This function gives the class of a free-text status: done, progress, waiting, blocked, later or
+* open. The first keyword of the text decides. A text without a keyword ("next", "open") is open.
+*/
+function statusClassOf(text) {
+	const lower = String(text ?? "").toLowerCase();
+	let best = {
+		index: Infinity,
+		value: "open"
+	};
+	for (const [value, pattern] of STATUS_KEYWORDS) {
+		const match = pattern.exec(lower);
+		if (match && match.index < best.index) best = {
+			index: match.index,
+			value
+		};
+	}
+	return best.value;
+}
+/** This function gives the cells of a table row. A "|" in a code span or after "\" is text. */
+function splitRow(line) {
+	const cells = [];
+	let cell = "";
+	let code = false;
+	const text = line.trim().replace(/^\|/, "").replace(/\|$/, "");
+	for (let index = 0; index < text.length; index++) {
+		const char = text[index];
+		if (char === "\\" && text[index + 1] === "|") {
+			cell += "|";
+			index++;
+		} else if (char === "`") {
+			code = !code;
+			cell += char;
+		} else if (char === "|" && !code) {
+			cells.push(cell.trim());
+			cell = "";
+		} else cell += char;
+	}
+	cells.push(cell.trim());
+	return cells;
+}
+/** This function gives the plain text of inline Markdown: no code marks, no emphasis, the text of each link. */
+function plainText(markdown) {
+	return String(markdown ?? "").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/[`*_]/g, "").replace(/\s+/g, " ").trim();
+}
+/** A cell with no value: empty, or a dash. */
+function isEmpty(cell) {
+	return cell === void 0 || /^\s*(?:[-–—]|n\/a)?\s*$/i.test(cell);
+}
+/**
+* This function gives the tables of a Markdown file. Each table has its header names in lowercase
+* plain text, the nearest heading above it, the line of its header and its rows. Fenced code is not read.
+*/
+function markdownTables(markdown) {
+	const lines = String(markdown).split(/\r?\n/);
+	const tables = [];
+	let section = "";
+	let fence = null;
+	for (let index = 0; index < lines.length; index++) {
+		const line = lines[index] ?? "";
+		const fenceMark = /^\s*(`{3,}|~{3,})/.exec(line)?.[1];
+		if (fenceMark !== void 0) {
+			if (fence === null) fence = fenceMark[0] ?? null;
+			else if (fenceMark[0] === fence) fence = null;
+			continue;
+		}
+		if (fence !== null) continue;
+		const heading = /^#{1,6}\s+(.*?)\s*#*\s*$/.exec(line);
+		if (heading) {
+			section = plainText(heading[1]);
+			continue;
+		}
+		if (!line.trim().startsWith("|")) continue;
+		const separator = lines[index + 1] ?? "";
+		if (!/^\s*\|?\s*:?-{3,}/.test(separator)) continue;
+		const header = splitRow(line).map((name) => plainText(name).toLowerCase());
+		const rows = [];
+		let next = index + 2;
+		for (; next < lines.length && (lines[next] ?? "").trim().startsWith("|"); next++) rows.push({
+			line: next + 1,
+			cells: splitRow(lines[next] ?? "")
+		});
+		tables.push({
+			section,
+			line: index + 1,
+			header,
+			rows
+		});
+		index = next - 1;
+	}
+	return tables;
+}
+/** The columns whose cells hold the links of an item. */
+const LINK_COLUMNS = [
+	"where",
+	"commit",
+	"commits",
+	"link",
+	"links",
+	"pr",
+	"prs"
+];
+/** Words before a reference that do not name a repository. */
+const NOT_REPOSITORIES = new Set("a an and also at by commit commits done fixed for from in into issue issues merged of on or plus pr prs run see the then to via with".split(" "));
+/** The URL of a link target of the roadmap file: an absolute URL stays, and a relative one goes to GitHub. */
+function linkUrl(target, { file = "", repository = "", ref = "HEAD" }) {
+	if (/^[a-z][a-z0-9+.-]*:/i.test(target)) return target;
+	if (!repository) return null;
+	const [path = "", anchor = ""] = target.split("#", 2);
+	const resolved = path === "" ? file : posix.normalize(posix.join(posix.dirname(file), path));
+	if (resolved.startsWith("..")) return null;
+	return `https://github.com/${repository}/blob/${ref}/${resolved}${anchor ? `#${anchor}` : ""}`;
+}
+/**
+* This function gives the links of a cell: each Markdown link, then each bare reference in the rest
+* of the text. A reference is a pull request ("PR #12", "#12") or a commit hash in a code span.
+*
+* @remarks A repository name right before a reference ("systems PR #16") applies to it and to the
+* next references of the cell. Without a name, a reference belongs to `repository`.
+*/
+function linksOf(cell, options = {}) {
+	const { repository = "" } = options;
+	const links = [];
+	const seen = /* @__PURE__ */ new Set();
+	const add = (label, url) => {
+		if (!url || seen.has(url)) return;
+		seen.add(url);
+		links.push({
+			label,
+			url
+		});
+	};
+	const rest = String(cell ?? "").replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_match, label, target) => {
+		add(plainText(label), linkUrl(target, options));
+		return " ";
+	});
+	if (!repository) return links;
+	const [owner, defaultRepo] = repository.split("/");
+	let current = defaultRepo;
+	let pulls = false;
+	const reference = /\bPRs?\s*#(\d+)|(?<![\w/&])#(\d+)\b|`([0-9a-f]{7,40})`/g;
+	for (let match = reference.exec(rest); match; match = reference.exec(rest)) {
+		const word = /([A-Za-z][\w.-]*)\s+$/.exec(rest.slice(0, match.index))?.[1];
+		if (word && !NOT_REPOSITORIES.has(word.toLowerCase())) current = word;
+		const prefix = current === defaultRepo ? "" : `${current} `;
+		if (match[1] !== void 0) pulls = true;
+		const number = match[1] ?? match[2];
+		if (number !== void 0) add(`${prefix}#${number}`, `https://github.com/${owner}/${current}/${pulls ? "pull" : "issues"}/${number}`);
+		else if (match[3] !== void 0) add(`${prefix}${match[3].slice(0, 7)}`, `https://github.com/${owner}/${current}/commit/${match[3]}`);
+	}
+	return links;
+}
+/**
+* This function gives the items of a roadmap file: one item for each row of each table with an `ID`
+* column and a `Status` column. The header names match without case.
+*
+* @remarks The title comes from `Item`, else from `Title`. `Owner`, `Area` and `Needs` are optional.
+* `Where`, `Commit` and `Links` give the links.
+* @throws RoadmapParseError when the cells of a row do not match the header
+*/
+function roadmapItems(markdown, options = {}) {
+	const { file = "ROADMAP.md" } = options;
+	const items = [];
+	for (const table of markdownTables(markdown)) {
+		const column = (...names) => names.map((name) => table.header.indexOf(name)).find((index) => index >= 0) ?? -1;
+		const id = column("id");
+		const status = column("status");
+		if (id < 0 || status < 0) continue;
+		const title = column("item", "title");
+		const owner = column("owner");
+		const area = column("area");
+		const needs = column("needs");
+		const linkColumns = LINK_COLUMNS.map((name) => table.header.indexOf(name)).filter((index) => index >= 0);
+		for (const row of table.rows) {
+			if (row.cells.length !== table.header.length) throw new RoadmapParseError(`${file}:${row.line}: the row has ${row.cells.length} cells, and the header has ${table.header.length}`);
+			const idText = plainText(row.cells[id]);
+			if (isEmpty(idText)) continue;
+			const statusText = row.cells[status] ?? "";
+			const item = {
+				id: idText,
+				title: title >= 0 ? row.cells[title] ?? "" : "",
+				status: statusText,
+				statusClass: statusClassOf(plainText(statusText)),
+				section: table.section,
+				line: row.line,
+				links: linkColumns.flatMap((index) => linksOf(row.cells[index], {
+					...options,
+					file
+				}))
+			};
+			const optional = (index) => index >= 0 && !isEmpty(row.cells[index]) ? row.cells[index] : void 0;
+			const ownerText = optional(owner);
+			const areaText = optional(area);
+			const needsText = optional(needs);
+			if (ownerText !== void 0) item.owner = ownerText;
+			if (areaText !== void 0) item.area = areaText;
+			if (needsText !== void 0) item.needs = needsText;
+			items.push(item);
+		}
+	}
+	return items;
+}
+/** This function puts the roadmap items and the GitHub part into the shape of `status.json`. */
+function buildStatusBoard(input) {
+	const { items, github, roadmap, repository, commit = null, generatedAt = (/* @__PURE__ */ new Date()).toISOString() } = input;
+	return {
+		generatedAt,
+		commit,
+		source: {
+			roadmap,
+			github: repository
+		},
+		items,
+		pullRequests: github.available ? github.pullRequests : [],
+		issues: github.available ? github.issues : [],
+		github: github.available ? {
+			available: true,
+			totals: github.totals
+		} : {
+			available: false,
+			reason: github.reason
+		}
+	};
+}
+/**
+* This function reads the board of a repository on disk: the roadmap file, and the open work on GitHub.
+*
+* @throws RoadmapParseError when the roadmap has an incorrect row, or no table with an ID and a Status column
+*/
+async function readStatusBoard(options) {
+	const { repoDir, roadmap = null, owner, repo, token, commit = null } = options;
+	const repository = `${owner}/${repo}`;
+	let items = [];
+	if (roadmap) {
+		items = roadmapItems(readFileSync(join(repoDir, ...roadmap.split("/")), "utf8"), {
+			file: roadmap,
+			repository,
+			ref: commit ?? "HEAD"
+		});
+		if (items.length === 0) throw new RoadmapParseError(`${roadmap}: no table with an ID column and a Status column`);
+	}
+	const github = await githubOpenWork({
+		owner,
+		repo,
+		token,
+		...options.fetch ? { fetch: options.fetch } : {}
+	});
+	return buildStatusBoard({
+		items,
+		github,
+		roadmap: roadmap || null,
+		repository,
+		commit,
+		...options.generatedAt ? { generatedAt: options.generatedAt } : {}
+	});
+}
+//#endregion
+//#region src/render/html.ts
+/**
+* The HTML helpers of the pages: the escape functions and a small inline Markdown renderer.
+*/
+const ESCAPES = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+};
+/** This function escapes a text for HTML content and for an attribute value in double quotes. */
+function escapeHtml(text) {
+	return String(text).replace(/[&<>"']/g, (char) => ESCAPES[char] ?? char);
+}
+/**
+* This function gives a URL that a link can hold, or null. It accepts `http:`, `https:` and
+* `mailto:` URLs, and relative URLs. It refuses each other scheme, for example `javascript:`.
+*/
+function safeUrl(url) {
+	const trimmed = url.trim();
+	if (/^(?:https?:|mailto:)/i.test(trimmed)) return trimmed;
+	if (/^[a-z][a-z0-9+.-]*:/i.test(trimmed) || trimmed.startsWith("//")) return null;
+	return trimmed;
+}
+/** This function gives an `<a>` element, or the escaped text when the URL is not safe. */
+function link(url, html, attributes = "") {
+	const href = safeUrl(url);
+	return href === null ? html : `<a href="${escapeHtml(href)}"${attributes ? ` ${attributes}` : ""}>${html}</a>`;
+}
+/** The emphasis of a text without code spans or links. The text is already escaped. */
+function emphasis(escaped) {
+	return escaped.replace(/\*\*([^*]+?)\*\*/g, "<strong>$1</strong>").replace(/(^|[^\w*])\*([^*\s][^*]*?)\*(?![\w*])/g, "$1<em>$2</em>").replace(/(^|[^\w])_([^_\s][^_]*?)_(?![\w])/g, "$1<em>$2</em>");
+}
+const INLINE = "`([^`]+)`|\\[((?:[^\\]`]|`[^`]*`)+)\\]\\(([^)\\s]+)\\)";
+/**
+* This function renders inline Markdown as HTML: code spans, links, strong text and emphasis. It
+* escapes all other text, so the result is safe.
+*/
+function inlineMarkdown(markdown) {
+	const text = String(markdown ?? "");
+	const pattern = new RegExp(INLINE, "g");
+	let html = "";
+	let last = 0;
+	for (let match = pattern.exec(text); match; match = pattern.exec(text)) {
+		html += emphasis(escapeHtml(text.slice(last, match.index)));
+		if (match[1] !== void 0) html += `<code>${escapeHtml(match[1])}</code>`;
+		else html += link(match[3] ?? "", inlineMarkdown(match[2] ?? ""));
+		last = match.index + match[0].length;
+	}
+	return html + emphasis(escapeHtml(text.slice(last)));
+}
+/** This function gives "1 item" or "2 items". */
+function plural(count, word, many = `${word}s`) {
+	return `${count} ${count === 1 ? word : many}`;
+}
+/** This function gives "a", "a and b" or "a, b and c". */
+function listText(parts) {
+	if (parts.length <= 1) return parts.join("");
+	return `${parts.slice(0, -1).join(", ")} and ${parts[parts.length - 1]}`;
+}
+//#endregion
+//#region src/render/dates.ts
+/**
+* The dates of the pages. The pages show each date in UTC, so the build and the browser agree.
+*/
+/** The milliseconds of one day. */
+const DAY_MS = 864e5;
+const MONTHS = [
+	"Jan",
+	"Feb",
+	"Mar",
+	"Apr",
+	"May",
+	"Jun",
+	"Jul",
+	"Aug",
+	"Sep",
+	"Oct",
+	"Nov",
+	"Dec"
+];
+/** This function gives the start of the UTC day of a time. */
+function utcDay(time) {
+	return Math.floor(time / DAY_MS) * DAY_MS;
+}
+/** This function gives "Oct 18": the UTC day of a time or of an ISO date. */
+function shortDate(date) {
+	const day = new Date(date);
+	return `${MONTHS[day.getUTCMonth()]} ${day.getUTCDate()}`;
+}
+/** This function gives "Oct 18, 2026, 19:34 UTC", or "an unknown time" for a date that is not valid. */
+function longDate(date) {
+	const day = new Date(date);
+	if (Number.isNaN(day.getTime())) return "an unknown time";
+	const time = `${String(day.getUTCHours()).padStart(2, "0")}:${String(day.getUTCMinutes()).padStart(2, "0")}`;
+	return `${shortDate(date)}, ${day.getUTCFullYear()}, ${time} UTC`;
+}
+/** This function gives "Oct 13–15", or "Sep 30–Oct 2" over the end of a month. */
+function dayRange(start, end) {
+	if (utcDay(start) === utcDay(end)) return shortDate(start);
+	const first = new Date(start);
+	const last = new Date(end);
+	return first.getUTCMonth() === last.getUTCMonth() ? `${shortDate(start)}–${last.getUTCDate()}` : `${shortDate(start)}–${shortDate(end)}`;
+}
+//#endregion
+//#region src/render/theme.ts
+/**
+* The page shell and the CSS of the standalone pages. The CSS uses variables (`--sp-bg`, `--sp-fg`,
+* `--sp-accent` and the others), so a site can change the colors and the fonts with `extraCss`.
+*/
+const DARK = `color-scheme:dark;--sp-bg:#0e1220;--sp-surface:#151a2b;--sp-sunken:#1c2236;--sp-fg:#e6e9f3;--sp-fg-2:#b3bad0;
+--sp-muted:#949cb3;--sp-rule:#2b3350;--sp-rule-strong:#46507a;--sp-accent:#93abff;--sp-accent-strong:#bccbff;--sp-accent-wash:#1f2a4f;
+--sp-good-ink:#4cc94c;--sp-warn-ink:#fab219;--sp-bad-ink:#ff8a8a;--sp-grid:#232a40;--sp-axis:#5d6683;`;
+/** The default CSS of the pages: the variables, the light and dark themes, and the parts of both pages. */
+const BASE_CSS = `
+:root{color-scheme:light;--sp-bg:#f5f6f9;--sp-surface:#ffffff;--sp-sunken:#eef1f6;--sp-fg:#151c2e;--sp-fg-2:#454f67;
+--sp-muted:#5f6880;--sp-rule:#d6dbe5;--sp-rule-strong:#aeb6c7;--sp-accent:#2346c4;--sp-accent-strong:#172f8f;--sp-accent-wash:#e7ecfd;
+--sp-good:#0ca30c;--sp-good-ink:#006300;--sp-warn:#fab219;--sp-warn-ink:#7a5200;--sp-bad:#d03b3b;--sp-bad-ink:#a3262a;
+--sp-neutral:#8a91a3;--sp-grid:#e6e9f0;--sp-axis:#9aa1b3;
+--sp-font:system-ui,-apple-system,"Segoe UI",Roboto,"Helvetica Neue",Arial,sans-serif;
+--sp-mono:ui-monospace,"Cascadia Mono","SFMono-Regular",Menlo,Consolas,monospace;--sp-radius:6px;--sp-width:64rem}
+:root[data-theme="dark"]{${DARK}}
+@media (prefers-color-scheme:dark){:root:not([data-theme="light"]){${DARK}}}
+*,*::before,*::after{box-sizing:border-box}
+[hidden]{display:none!important}
+html{-webkit-text-size-adjust:100%;text-size-adjust:100%}
+body{margin:0;background:var(--sp-bg);color:var(--sp-fg);font-family:var(--sp-font);font-size:1rem;line-height:1.55}
+a{color:var(--sp-accent);text-underline-offset:2px}
+a:hover{color:var(--sp-accent-strong)}
+:focus-visible{outline:2px solid var(--sp-accent);outline-offset:2px}
+code{font-family:var(--sp-mono);font-size:.9em;background:var(--sp-sunken);border-radius:3px;padding:0 .25em;overflow-wrap:anywhere}
+h1{font-size:2rem;line-height:1.2;margin:.5rem 0 .75rem}
+h2{font-size:1.35rem;line-height:1.3;margin:0 0 .5rem}
+h3{font-size:1.1rem;line-height:1.3}
+p{margin:0 0 .75rem}
+button{font:inherit;color:inherit}
+.sp-skip{position:absolute;left:-9999px;top:0}
+.sp-skip:focus{left:16px;top:8px;z-index:10;background:var(--sp-surface);padding:.25rem .5rem}
+.sp-header{background:var(--sp-surface);border-bottom:1px solid var(--sp-rule)}
+.sp-header nav{max-width:var(--sp-width);margin:0 auto;padding:.6rem 16px;display:flex;flex-wrap:wrap;align-items:baseline;gap:.25rem 1.25rem}
+.sp-home{margin-right:auto;font-weight:700;color:var(--sp-fg);text-decoration:none;overflow-wrap:anywhere}
+.sp-header a[aria-current="page"]{color:var(--sp-fg);font-weight:600;text-decoration:none}
+.sp-main{max-width:var(--sp-width);margin:0 auto;padding:16px;min-width:0;overflow-wrap:break-word}
+.sp-footer{max-width:var(--sp-width);margin:2rem auto 0;padding:16px;border-top:1px solid var(--sp-rule);color:var(--sp-muted);font-size:.875rem}
+.sp-lead{font-size:1.2rem;max-width:70ch}
+.sp-small{font-size:.875rem}
+.sp-muted{color:var(--sp-muted)}
+.sp-panel{background:var(--sp-surface);border:1px solid var(--sp-rule);border-radius:var(--sp-radius);padding:16px;min-width:0}
+.sp-pill{display:inline-block;border:1px solid var(--sp-rule-strong);border-radius:999px;padding:0 .5rem;font-size:.8125rem;line-height:1.5;color:var(--sp-fg-2);white-space:nowrap}
+.sp-pill.sp-accent{border-color:var(--sp-accent);background:var(--sp-accent-wash);color:var(--sp-accent-strong)}
+.sp-pill.sp-good{border-color:var(--sp-good);color:var(--sp-good-ink)}
+.sp-pill.sp-strong{border-color:var(--sp-accent-strong);background:var(--sp-accent-strong);color:var(--sp-surface);font-weight:700}
+.sp-chip{display:inline-flex;align-items:center;gap:.3rem;background:var(--sp-surface);border:1px solid var(--sp-rule-strong);border-radius:999px;padding:.1rem .7rem;font-size:.875rem;color:var(--sp-fg-2);cursor:pointer}
+.sp-chip:hover{border-color:var(--sp-accent)}
+.sp-chip[aria-pressed="true"]{background:var(--sp-accent-wash);border-color:var(--sp-tone,var(--sp-accent));box-shadow:inset 0 0 0 1px var(--sp-tone,var(--sp-accent));color:var(--sp-fg)}
+.sp-count{font-family:var(--sp-mono);font-size:.8125rem;color:var(--sp-muted)}
+.sp-ghost{background:none;border:0;padding:.15rem 0;color:var(--sp-accent);text-decoration:underline;text-underline-offset:2px;cursor:pointer;font-size:.875rem}
+.sp-callout{background:var(--sp-sunken);border-left:3px solid var(--sp-rule-strong);border-radius:var(--sp-radius);padding:.6rem .8rem}
+.sp-visually-hidden{position:absolute;width:1px;height:1px;overflow:hidden;clip-path:inset(50%);white-space:nowrap}
+.sp-section{margin-top:2rem}
+
+/* The releases page */
+.sp-legend{display:flex;flex-wrap:wrap;gap:.25rem 1rem;margin:0 0 .5rem;padding:0;list-style:none;color:var(--sp-fg-2);font-size:.875rem}
+.sp-legend li{display:inline-flex;align-items:center;gap:.25rem}
+.sp-legend svg{flex:none;overflow:visible}
+.sp-timeline-box{overflow-x:auto;overflow-y:hidden;max-width:100%;overscroll-behavior-x:contain}
+.sp-timeline-box svg{display:block;overflow:visible;max-width:none}
+.sp-timeline-wide{display:none}
+@media (min-width:1000px){.sp-timeline-narrow{display:none}.sp-timeline-wide{display:block}}
+.sp-gap{fill:var(--sp-sunken)}
+.sp-grid{stroke:var(--sp-grid);stroke-width:1}
+.sp-axis{stroke:var(--sp-axis);stroke-width:1}
+.sp-day{fill:var(--sp-fg-2);font-family:var(--sp-font);font-size:12px;font-weight:600}
+.sp-day-count{fill:var(--sp-muted);font-family:var(--sp-font);font-size:11px}
+.sp-mark{cursor:pointer;outline:none}
+.sp-hit{fill:transparent}
+.sp-dot{fill:var(--sp-accent);stroke:var(--sp-surface);stroke-width:1.5}
+.sp-ring{fill:var(--sp-surface);stroke:var(--sp-accent);stroke-width:2}
+.sp-kind-first .sp-dot{fill:var(--sp-good)}
+.sp-kind-major .sp-dot{fill:var(--sp-accent-strong)}
+.sp-halo{fill:none;stroke:var(--sp-accent);stroke-width:2;pointer-events:none;display:none}
+.sp-mark.sp-selected .sp-halo{display:inline}
+.sp-label{fill:var(--sp-fg-2);font-family:var(--sp-mono);font-size:12px;paint-order:stroke;stroke:var(--sp-surface);stroke-width:3px;stroke-linejoin:round}
+.sp-mark:hover .sp-label,.sp-mark.sp-selected .sp-label{fill:var(--sp-accent-strong)}
+.sp-mark.sp-selected .sp-label{font-weight:700}
+.sp-mark:focus-visible .sp-hit{stroke:var(--sp-accent);stroke-width:2}
+.sp-release{margin:.75rem 0 1rem}
+.sp-release-head{display:flex;flex-wrap:wrap;align-items:baseline;gap:.25rem .75rem;margin-bottom:.5rem}
+.sp-release-head h2{margin:0;font-family:var(--sp-mono);font-size:1.5rem}
+.sp-release-links{display:inline-flex;flex-wrap:wrap;gap:.25rem .75rem;margin-left:auto}
+.sp-changes{list-style:none;margin:.5rem 0 0;padding:0}
+.sp-change{padding:.5rem 0;border-top:1px solid var(--sp-rule);min-width:0}
+.sp-change p{margin:0 0 .25rem;overflow-wrap:anywhere}
+.sp-change-meta{display:flex;flex-wrap:wrap;align-items:center;gap:.25rem .75rem}
+.sp-commit code{font-size:.8125rem}
+.sp-chips{display:inline-flex;flex-wrap:wrap;align-items:center;gap:.25rem}
+.sp-chips .sp-ghost{font-size:.8125rem}
+@media (max-width:560px){.sp-release-links{margin-left:0;width:100%}}
+
+/* The status page: each class has a tone, and the page always shows the tone with an icon and a label */
+.sp-c-waiting{--sp-tone:var(--sp-warn);--sp-ink:var(--sp-warn-ink)}
+.sp-c-blocked{--sp-tone:var(--sp-bad);--sp-ink:var(--sp-bad-ink)}
+.sp-c-progress{--sp-tone:var(--sp-accent);--sp-ink:var(--sp-accent-strong)}
+.sp-c-open{--sp-tone:var(--sp-neutral);--sp-ink:var(--sp-fg-2)}
+.sp-c-later{--sp-tone:var(--sp-rule-strong);--sp-ink:var(--sp-muted)}
+.sp-c-done{--sp-tone:var(--sp-good);--sp-ink:var(--sp-good-ink)}
+.sp-meter{display:flex;gap:2px;height:12px;border-radius:6px;overflow:hidden;background:var(--sp-rule);margin-top:.75rem}
+.sp-meter span{display:block;min-width:4px;background:var(--sp-tone)}
+.sp-meter-legend{display:flex;flex-wrap:wrap;gap:.25rem 1rem;list-style:none;margin:.5rem 0 1rem;padding:0;color:var(--sp-fg-2);font-size:.875rem}
+.sp-meter-legend li{display:inline-flex;align-items:center;gap:.25rem}
+.sp-meter-legend strong{font-family:var(--sp-mono);color:var(--sp-ink)}
+.sp-swatch{display:inline-block;width:12px;height:10px;border-radius:2px;background:var(--sp-tone)}
+.sp-filters{display:flex;flex-wrap:wrap;align-items:center;gap:.5rem 1rem;margin-bottom:.5rem}
+.sp-filters>span{display:inline-flex;flex-wrap:wrap;gap:.25rem}
+.sp-group{margin-top:1.5rem}
+.sp-group h3{display:flex;align-items:center;gap:.5rem;margin:0;padding-bottom:.25rem;color:var(--sp-ink);border-bottom:2px solid var(--sp-tone)}
+.sp-group-count{font-family:var(--sp-mono);font-size:.875rem;font-weight:600;color:var(--sp-fg-2);background:var(--sp-sunken);border-radius:999px;padding:0 .5rem}
+.sp-table-box{max-width:100%;overflow-x:auto}
+table.sp-table{width:100%;border-collapse:collapse;font-size:.9rem}
+.sp-table th,.sp-table td{text-align:left;vertical-align:top;padding:.5rem;border-bottom:1px solid var(--sp-rule)}
+.sp-table thead th{font-size:.75rem;text-transform:uppercase;letter-spacing:.05em;color:var(--sp-muted)}
+.sp-table th[scope="row"]{font-family:var(--sp-mono);font-weight:600;white-space:nowrap;border-left:3px solid var(--sp-tone)}
+.sp-item{min-width:16rem;overflow-wrap:anywhere}
+.sp-item-meta{display:block;margin-top:2px}
+.sp-status{color:var(--sp-ink);overflow-wrap:anywhere}
+.sp-links{display:inline-flex;flex-wrap:wrap;gap:2px .5rem;overflow-wrap:anywhere}
+.sp-done{margin-top:1rem}
+.sp-done>summary{cursor:pointer;color:var(--sp-good-ink)}
+@media (max-width:760px){
+.sp-table thead{position:absolute;width:1px;height:1px;overflow:hidden;clip-path:inset(50%)}
+.sp-table,.sp-table tbody,.sp-table tr,.sp-table th,.sp-table td{display:block;width:100%}
+.sp-table tr{border:1px solid var(--sp-rule);border-left:4px solid var(--sp-tone);border-radius:var(--sp-radius);padding:.5rem .75rem;margin-top:.5rem;background:var(--sp-surface)}
+.sp-table th,.sp-table td{border:0;padding:2px 0}
+.sp-table th[scope="row"]{border-left:0}
+.sp-table td{display:grid;grid-template-columns:4.5rem minmax(0,1fr);align-items:baseline;gap:.5rem}
+.sp-table td::before{content:attr(data-label);font-size:.75rem;color:var(--sp-muted)}
+.sp-table td.sp-item{display:block;min-width:0}
+.sp-table td.sp-item::before{content:none}
+}
+.sp-cards{list-style:none;margin:.75rem 0 0;padding:0;display:flex;flex-direction:column;gap:.5rem}
+.sp-card{background:var(--sp-surface);border:1px solid var(--sp-rule);border-radius:var(--sp-radius);padding:.5rem .75rem;min-width:0}
+.sp-card-title{display:block;font-weight:600;overflow-wrap:anywhere}
+.sp-number{font-family:var(--sp-mono);font-weight:400;color:var(--sp-muted)}
+.sp-card-meta{display:flex;flex-wrap:wrap;align-items:center;gap:.25rem .75rem;margin-top:.25rem;color:var(--sp-fg-2);font-size:.875rem}
+.sp-branch{font-size:.8125rem;min-width:0}
+.sp-check{display:inline-flex;align-items:center;gap:.25rem;white-space:nowrap}
+.sp-dot-state{display:inline-block;width:9px;height:9px;border-radius:50%;background:var(--sp-neutral)}
+.sp-check-success .sp-dot-state{background:var(--sp-good)}
+.sp-check-failure .sp-dot-state{background:var(--sp-bad)}
+.sp-check-pending .sp-dot-state{background:var(--sp-warn)}
+.sp-check-none .sp-dot-state{background:transparent;border:1.5px solid var(--sp-neutral)}
+.sp-labels{display:inline-flex;flex-wrap:wrap;gap:4px}
+@media (prefers-reduced-motion:reduce){*{scroll-behavior:auto!important}}
+`;
+const NO_SCRIPT_CSS = `.sp-release[hidden],.sp-extra[hidden]{display:block!important}li.sp-extra[hidden]{display:list-item!important}
+.sp-chips>.sp-extra[hidden]{display:inline-block!important}[data-sp-js]{display:none!important}`;
+/** This function gives the name of the repository: "client" for "mark1russell7/client". */
+function repositoryName(repository) {
+	return repository.split("/").pop() || repository;
+}
+/** This function makes the complete HTML document of a page. */
+function pageShell(parts, options) {
+	const base = options.base.endsWith("/") ? options.base : `${options.base}/`;
+	const name = options.siteName || repositoryName(options.repository);
+	const nav = (page, label) => `<a href="${escapeHtml(`${base}${page}/`)}"${parts.current === page ? " aria-current=\"page\"" : ""}>${label}</a>`;
+	const commit = options.commit ? ` from ${link(`https://github.com/${options.repository}/commit/${options.commit}`, `<code>${escapeHtml(options.commit.slice(0, 7))}</code>`)}` : "";
+	const data = `${base}data/${parts.current}.json`;
+	return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="color-scheme" content="light dark">
+<title>${escapeHtml(`${parts.title} · ${name}`)}</title>
+<meta name="description" content="${escapeHtml(parts.description)}">
+<style>${BASE_CSS}${options.extraCss ? `\n${options.extraCss}` : ""}</style>
+<noscript><style>${NO_SCRIPT_CSS}</style></noscript>
+</head>
+<body>
+<a class="sp-skip" href="#main">Skip to the content</a>
+<header class="sp-header"><nav aria-label="Site"><a class="sp-home" href="${escapeHtml(base)}">${escapeHtml(name)}</a>${nav("releases", "Releases")}${nav("status", "Status")}</nav></header>
+<main id="main" class="sp-main">
+${parts.main}
+</main>
+<footer class="sp-footer"><p>The build made this page at ${escapeHtml(longDate(options.generatedAt))}${commit}. The data is in <a href="${escapeHtml(data)}"><code>${escapeHtml(`data/${parts.current}.json`)}</code></a>.</p></footer>
+<script type="module">${parts.script}<\/script>
+</body>
+</html>
+`;
+}
+//#endregion
+//#region src/render/timeline.ts
+/**
+* The layout of the release timeline: one mark for each version on a time axis.
+*
+* @remarks The axis has one band for each day with a release. A run of days without a release
+* becomes one narrow band, so the busy days get the width. In a day band, the time is linear. Marks
+* that are near each other go into lanes, so that no two labels overlap.
+*/
+/** This function counts the versions and the kinds. The first release counts as a version only. */
+function releaseSummary(releases) {
+	const times = releases.map((release) => Date.parse(release.date)).filter(Number.isFinite);
+	const count = (kind) => releases.filter((release) => release.kind === kind).length;
+	return {
+		versions: releases.length,
+		major: count("major"),
+		minor: count("minor"),
+		patch: count("patch"),
+		first: times.length > 0 ? new Date(Math.min(...times)).toISOString() : null,
+		last: times.length > 0 ? new Date(Math.max(...times)).toISOString() : null
+	};
+}
+/** This function sorts the versions from the oldest to the newest: the sequence of the marks and of the arrow keys. */
+function oldestFirst(releases) {
+	return [...releases].sort((a, b) => Date.parse(a.date) - Date.parse(b.date) || compareVersions(a.version, b.version));
+}
+/** This function gives the y of the center line of a lane. */
+function laneCenter(layout, lane) {
+	return layout.plotBottom - (lane + .5) * layout.laneHeight;
+}
+/** This function calculates the layout of the timeline at a width. */
+function timelineLayout(releases, options) {
+	const { width, padX = 30, laneHeight = 38, charWidth = 7.4, gap = 8, emptyWeight = .6 } = options;
+	const ordered = oldestFirst(releases).filter((release) => Number.isFinite(Date.parse(release.date)));
+	const first = ordered[0];
+	const last = ordered[ordered.length - 1];
+	if (!first || !last) return {
+		width,
+		height: 6 + laneHeight + 46,
+		plotTop: 6,
+		plotBottom: 6 + laneHeight,
+		laneHeight,
+		lanes: 0,
+		bands: [],
+		marks: []
+	};
+	const counts = /* @__PURE__ */ new Map();
+	for (const release of ordered) {
+		const day = utcDay(Date.parse(release.date));
+		counts.set(day, (counts.get(day) ?? 0) + 1);
+	}
+	const raw = [];
+	for (let day = utcDay(Date.parse(first.date)); day <= utcDay(Date.parse(last.date)); day += DAY_MS) {
+		const count = counts.get(day) ?? 0;
+		const previous = raw[raw.length - 1];
+		if (count === 0 && previous?.empty) previous.end = day + DAY_MS;
+		else raw.push({
+			start: day,
+			end: day + DAY_MS,
+			count,
+			empty: count === 0,
+			weight: count === 0 ? emptyWeight : 1
+		});
+	}
+	const unit = (width - 2 * padX) / raw.reduce((sum, band) => sum + band.weight, 0);
+	let cursor = padX;
+	const bands = raw.map((band) => {
+		const x0 = cursor;
+		cursor += band.weight * unit;
+		return {
+			start: band.start,
+			end: band.end,
+			x0,
+			x1: cursor,
+			label: dayRange(band.start, band.end - 1),
+			count: band.count,
+			empty: band.empty
+		};
+	});
+	const xOf = (time) => {
+		const band = bands.find((candidate) => time >= candidate.start && time < candidate.end) ?? bands[bands.length - 1];
+		if (!band) return padX;
+		return band.x0 + (time - band.start) / (band.end - band.start) * (band.x1 - band.x0);
+	};
+	const laneEnds = [];
+	const marks = ordered.map((release) => {
+		const time = Date.parse(release.date);
+		const x = xOf(time);
+		const half = Math.max(release.version.length * charWidth, 24) / 2;
+		let lane = laneEnds.findIndex((end) => end + gap <= x - half);
+		if (lane === -1) {
+			lane = laneEnds.length;
+			laneEnds.push(0);
+		}
+		laneEnds[lane] = x + half;
+		return {
+			release,
+			time,
+			x,
+			lane,
+			half
+		};
+	});
+	const lanes = laneEnds.length;
+	const plotBottom = 6 + lanes * laneHeight;
+	return {
+		width,
+		height: plotBottom + 46,
+		plotTop: 6,
+		plotBottom,
+		laneHeight,
+		lanes,
+		bands,
+		marks
+	};
+}
+//#endregion
+//#region src/render/releases.ts
+/** The changes and the package chips that the page shows before "Show all". */
+const FIRST_CHANGES = 8;
+const FIRST_CHIPS = 4;
+/** The y of the mark below the center line of its lane. The label is above the line. */
+const MARK_Y = 9;
+/** The widths of the two timelines: the narrow one for a phone or a tablet, the wide one for a desktop. */
+const NARROW_WIDTH = 640;
+const WIDE_WIDTH = 920;
+const KIND_INFO = {
+	first: {
+		label: "First release",
+		word: "first release",
+		pill: "sp-pill sp-good",
+		legend: "The first release"
+	},
+	major: {
+		label: "MAJOR",
+		word: "major",
+		pill: "sp-pill sp-strong",
+		legend: "MAJOR: a change that breaks the API"
+	},
+	minor: {
+		label: "MINOR",
+		word: "minor",
+		pill: "sp-pill sp-accent",
+		legend: "MINOR: new features (before 1.0.0, also a change of the API)"
+	},
+	patch: {
+		label: "PATCH",
+		word: "patch",
+		pill: "sp-pill",
+		legend: "PATCH: fixes and small additions"
+	}
+};
+/** This function gives "Oct 18, 2026" for an ISO date. */
+function dayWithYear(date) {
+	return `${shortDate(date)}, ${new Date(date).getUTCFullYear()}`;
+}
+/**
+* This function gives the lead line of the releases page, for example "23 versions from Oct 12 to
+* Oct 18, 2026. 7 MINOR releases and 15 PATCH releases came after the first release."
+*/
+function releasesLead(releases) {
+	const summary = releaseSummary(releases);
+	if (!summary.first || !summary.last) return "The repository has no release yet.";
+	const sameYear = new Date(summary.first).getUTCFullYear() === new Date(summary.last).getUTCFullYear();
+	const from = sameYear ? shortDate(summary.first) : dayWithYear(summary.first);
+	const range = shortDate(summary.first) === shortDate(summary.last) && sameYear ? `on ${dayWithYear(summary.last)}` : `from ${from} to ${dayWithYear(summary.last)}`;
+	if (summary.versions === 1) return `1 version, the first release, ${range}.`;
+	const kinds = [
+		summary.major > 0 ? plural(summary.major, "MAJOR release") : "",
+		summary.minor > 0 ? plural(summary.minor, "MINOR release") : "",
+		summary.patch > 0 ? plural(summary.patch, "PATCH release") : ""
+	].filter(Boolean);
+	return `${plural(summary.versions, "version")} ${range}. ${listText(kinds)} came after the first release.`;
+}
+/** The shape of a mark. The first release is a diamond, a MAJOR is a large dot, a MINOR is a dot and a PATCH is a ring. */
+function markShape(kind, y) {
+	if (kind === "first") return `<rect class="sp-dot" x="-5.5" y="${y - 5.5}" width="11" height="11" transform="rotate(45 0 ${y})"/>`;
+	if (kind === "major") return `<circle class="sp-dot" cy="${y}" r="8"/>`;
+	if (kind === "minor") return `<circle class="sp-dot" cy="${y}" r="6.5"/>`;
+	return `<circle class="sp-ring" cy="${y}" r="4.5"/>`;
+}
+function legend(releases) {
+	return `<ul class="sp-legend">${[
+		"major",
+		"minor",
+		"patch",
+		"first"
+	].filter((kind) => releases.some((release) => release.kind === kind)).map((kind) => `<li><svg width="18" height="18" viewBox="-9 -9 18 18" aria-hidden="true"><g class="sp-kind-${kind}">${markShape(kind, 0)}</g></svg>${escapeHtml(KIND_INFO[kind].legend)}</li>`).join("")}</ul>`;
+}
+const fixed = (value) => value.toFixed(1).replace(/\.0$/, "");
+function timelineSvg(releases, width, selected) {
+	const layout = timelineLayout(releases, { width });
+	const { plotTop, plotBottom } = layout;
+	const parts = [];
+	for (const band of layout.bands) {
+		const middle = (band.x0 + band.x1) / 2;
+		const room = band.x1 - band.x0;
+		const count = band.empty ? "no release" : plural(band.count, "release");
+		parts.push(`<g${band.empty ? " class=\"sp-empty-band\"" : ""}>`);
+		if (band.empty) parts.push(`<rect class="sp-gap" x="${fixed(band.x0)}" y="${plotTop}" width="${fixed(room)}" height="${plotBottom - plotTop}"/>`);
+		parts.push(`<line class="sp-grid" x1="${fixed(band.x0)}" x2="${fixed(band.x0)}" y1="${plotTop}" y2="${plotBottom + 6}"/>`);
+		if (room >= band.label.length * 7 + 6) parts.push(`<text class="sp-day" x="${fixed(middle)}" y="${plotBottom + 21}" text-anchor="middle">${escapeHtml(band.label)}</text>`);
+		if (room >= count.length * 6 + 6) parts.push(`<text class="sp-day-count" x="${fixed(middle)}" y="${plotBottom + 38}" text-anchor="middle">${escapeHtml(count)}</text>`);
+		parts.push("</g>");
+	}
+	const lastBand = layout.bands[layout.bands.length - 1];
+	if (lastBand) parts.push(`<line class="sp-grid" x1="${fixed(lastBand.x1)}" x2="${fixed(lastBand.x1)}" y1="${plotTop}" y2="${plotBottom + 6}"/>`);
+	parts.push(`<line class="sp-axis" x1="${fixed(layout.bands[0]?.x0 ?? 0)}" x2="${fixed(lastBand?.x1 ?? width)}" y1="${plotBottom}" y2="${plotBottom}"/>`);
+	const axis = `<g aria-hidden="true">${parts.join("")}</g>`;
+	const marks = layout.marks.map((mark) => {
+		const { release } = mark;
+		const on = release.version === selected;
+		const label = `${release.version}, ${KIND_INFO[release.kind].word}, ${shortDate(release.date)}, ${plural(release.changes.length, "change")}`;
+		return `<g class="sp-mark sp-kind-${release.kind}${on ? " sp-selected" : ""}" data-sp-mark data-version="${escapeHtml(release.version)}" data-x="${fixed(mark.x)}" data-half="${fixed(mark.half)}" transform="translate(${fixed(mark.x)} ${fixed(laneCenter(layout, mark.lane))})" role="button" tabindex="${on ? 0 : -1}" aria-pressed="${on}" aria-label="${escapeHtml(label)}"><rect class="sp-hit" x="${fixed(-mark.half - 4)}" y="${fixed(-layout.laneHeight / 2 + 1)}" width="${fixed(mark.half * 2 + 8)}" height="${layout.laneHeight - 2}" rx="4"/><circle class="sp-halo" cy="${MARK_Y}" r="11"/>${markShape(release.kind, MARK_Y)}<text class="sp-label" y="-3" text-anchor="middle">${escapeHtml(release.version)}</text></g>`;
+	});
+	const name = `The release timeline, ${plural(layout.marks.length, "version")}. The arrow keys move between the versions.`;
+	return `<svg class="sp-timeline" width="${layout.width}" height="${layout.height}" viewBox="0 0 ${layout.width} ${layout.height}" role="group" aria-label="${escapeHtml(name)}">${axis}${marks.join("")}</svg>`;
+}
+/** The common scope of all the package names ("@procedures/"), or "" when the names have no common scope. */
+function commonScope(releases) {
+	const names = new Set(releases.flatMap((release) => release.changes.flatMap((change) => change.packages)));
+	const scopes = new Set([...names].map((name) => /^(@[^/]+\/)/.exec(name)?.[1] ?? ""));
+	const [scope] = scopes;
+	return scopes.size === 1 && scope ? scope : "";
+}
+function toggleButton(ids, more, less, hidden = "") {
+	return `<button type="button" class="sp-ghost" data-sp-js data-sp-toggle aria-controls="${ids}" aria-expanded="false" data-more="${escapeHtml(more)}" data-less="${escapeHtml(less)}"><span data-sp-label>${escapeHtml(more)}</span>${hidden}</button>`;
+}
+function chips(packages, scope, ids) {
+	if (packages.length === 0) return "";
+	const id = `k${ids.next++}`;
+	const items = packages.map((name, index) => {
+		const short = scope && name.startsWith(scope) ? name.slice(scope.length) : name;
+		const extra = index >= FIRST_CHIPS;
+		return `<span class="sp-pill${extra ? " sp-extra" : ""}" title="${escapeHtml(name)}"${extra ? " hidden" : ""}>${escapeHtml(short)}</span>`;
+	});
+	const more = packages.length - FIRST_CHIPS;
+	const button = more > 0 ? toggleButton(id, `+${more} more`, "Fewer", "<span class=\"sp-visually-hidden\"> packages</span>") : "";
+	return `<span class="sp-chips" id="${id}">${items.join("")}${button}</span>`;
+}
+function changeItem(change, index, repository, scope, ids) {
+	const extra = index >= FIRST_CHANGES;
+	const commit = change.commit ? link(`https://github.com/${repository}/commit/${change.commit}`, `<code>${escapeHtml(change.commit)}</code>`, `class="sp-commit" title="${escapeHtml(`Commit ${change.commit} on GitHub`)}"`) : "";
+	const meta = commit || change.packages.length > 0 ? `<div class="sp-change-meta">${commit}${chips(change.packages, scope, ids)}</div>` : "";
+	return `<li class="sp-change${extra ? " sp-extra" : ""}"${extra ? " hidden" : ""}><p>${inlineMarkdown(change.text)}</p>${meta}</li>`;
+}
+function details(release, index, selected, repository, scope, ids) {
+	const info = KIND_INFO[release.kind];
+	const links = release.links.map((each) => link(each.url, escapeHtml(each.label))).join("");
+	const head = `<div class="sp-release-head"><h2 id="h${index}">${escapeHtml(release.version)}</h2><span class="${info.pill}">${escapeHtml(info.label)}</span><time class="sp-small sp-muted" datetime="${escapeHtml(release.date)}">${escapeHtml(longDate(release.date))}</time>` + (links ? `<span class="sp-release-links sp-small">${links}</span>` : "") + "</div>";
+	let body;
+	if (release.changes.length === 0) body = "<p class=\"sp-small sp-muted\">The sources have no change entry for this version.</p>";
+	else {
+		const packages = new Set(release.changes.flatMap((change) => change.packages)).size;
+		const count = packages > 0 ? `${plural(release.changes.length, "change")} in ${plural(packages, "package")}. The changes with the most packages come first.` : `${plural(release.changes.length, "change")}.`;
+		const listId = `c${index}`;
+		const items = release.changes.map((change, position) => changeItem(change, position, repository, scope, ids));
+		const all = release.changes.length > FIRST_CHANGES ? toggleButton(listId, `Show all ${release.changes.length} changes`, "Show fewer changes") : "";
+		body = `<p class="sp-small sp-muted">${escapeHtml(count)}</p><ul class="sp-changes" id="${listId}">${items.join("")}</ul>${all}`;
+	}
+	return `<section class="sp-panel sp-release" id="v${escapeHtml(release.version)}" data-sp-release data-version="${escapeHtml(release.version)}" aria-labelledby="h${index}"${selected ? "" : " hidden"}>${head}${body}</section>`;
+}
+/**
+* The inline module of the releases page. It selects a version on a click, with the arrow keys,
+* Home, End, Enter and Space. It also opens the long lists and keeps the version in the URL.
+*/
+const RELEASES_SCRIPT = String.raw`
+const boxes = Array.from(document.querySelectorAll("[data-sp-timeline]"));
+const panels = new Map(Array.from(document.querySelectorAll("[data-sp-release]"), (panel) => [panel.dataset.version, panel]));
+const reduced = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+let selected = (document.querySelector("[data-sp-release]:not([hidden])") || {}).dataset?.version;
+const markIn = (box, version) => Array.from(box.querySelectorAll("[data-sp-mark]")).find((mark) => mark.dataset.version === version);
+function reveal(box, version, smooth) {
+  const mark = markIn(box, version);
+  if (!mark || box.scrollWidth <= box.clientWidth) return;
+  const x = Number(mark.dataset.x);
+  const margin = Number(mark.dataset.half) + 16;
+  if (x - margin >= box.scrollLeft && x + margin <= box.scrollLeft + box.clientWidth) return;
+  box.scrollTo({ left: x - box.clientWidth / 2, behavior: smooth && !reduced ? "smooth" : "auto" });
+}
+function select(version, box) {
+  const panel = panels.get(version);
+  if (!panel) return;
+  selected = version;
+  for (const each of boxes) {
+    for (const mark of each.querySelectorAll("[data-sp-mark]")) {
+      const on = mark.dataset.version === version;
+      mark.classList.toggle("sp-selected", on);
+      mark.setAttribute("aria-pressed", String(on));
+      mark.setAttribute("tabindex", on ? "0" : "-1");
+    }
+  }
+  for (const [key, each] of panels) each.hidden = key !== version;
+  if (box) {
+    const mark = markIn(box, version);
+    if (mark) mark.focus({ preventScroll: true });
+    reveal(box, version, true);
+  }
+  try {
+    history.replaceState(null, "", "#" + encodeURIComponent(panel.id));
+  } catch {}
+}
+for (const box of boxes) {
+  box.addEventListener("click", (event) => {
+    const mark = event.target.closest("[data-sp-mark]");
+    if (mark) select(mark.dataset.version, box);
+  });
+  box.addEventListener("keydown", (event) => {
+    const mark = event.target.closest("[data-sp-mark]");
+    if (!mark || event.altKey || event.ctrlKey || event.metaKey) return;
+    const marks = Array.from(box.querySelectorAll("[data-sp-mark]"));
+    const position = marks.indexOf(mark);
+    const targets = { ArrowLeft: position - 1, ArrowRight: position + 1, Home: 0, End: marks.length - 1, Enter: position, " ": position };
+    if (!(event.key in targets)) return;
+    event.preventDefault();
+    const next = marks[Math.max(0, Math.min(marks.length - 1, targets[event.key]))];
+    if (next) select(next.dataset.version, box);
+  });
+}
+document.addEventListener("click", (event) => {
+  const button = event.target.closest("[data-sp-toggle]");
+  const list = button && document.getElementById(button.getAttribute("aria-controls"));
+  if (!list) return;
+  const open = button.getAttribute("aria-expanded") !== "true";
+  for (const extra of list.querySelectorAll(":scope > .sp-extra")) extra.hidden = !open;
+  button.setAttribute("aria-expanded", String(open));
+  const label = button.querySelector("[data-sp-label]");
+  if (label) label.textContent = open ? button.dataset.less : button.dataset.more;
+});
+const hashed = decodeURIComponent(location.hash.slice(1));
+for (const [version, panel] of panels) if (panel.id === hashed) select(version, null);
+const revealAll = () => { for (const box of boxes) reveal(box, selected, false); };
+revealAll();
+window.addEventListener("resize", revealAll);
+`;
+/** This function renders the complete releases page from the data of `releases.json`. */
+function renderReleasesPage(releases, options) {
+	const newest = releases[0];
+	const ordered = oldestFirst(releases);
+	const scope = commonScope(releases);
+	const ids = { next: 0 };
+	const lead = `<p class="sp-lead">${escapeHtml(releasesLead(releases))}</p>`;
+	let content = "";
+	if (newest) content = `<div class="sp-panel"><p class="sp-small sp-muted">Each mark is one version, on a time axis in UTC. Select a mark to show its changes.</p>` + legend(releases) + `<div class="sp-timeline-box sp-timeline-narrow" data-sp-timeline>${timelineSvg(ordered, NARROW_WIDTH, newest.version)}</div><div class="sp-timeline-box sp-timeline-wide" data-sp-timeline>${timelineSvg(ordered, WIDE_WIDTH, newest.version)}</div></div>` + releases.map((release, index) => details(release, index, index === 0, options.repository, scope, ids)).join("");
+	return pageShell({
+		title: "Releases",
+		description: releasesLead(releases),
+		current: "releases",
+		main: `<h1>Releases</h1>${lead}${content}<p class="sp-small sp-muted">Source: the <code>CHANGELOG.md</code> files, the git tags, the GitHub releases and npm, read when the site was built.</p>`,
+		script: RELEASES_SCRIPT
+	}, options);
+}
+//#endregion
+//#region src/render/status.ts
+/**
+* The standalone status page: the open work of the roadmap file, the open pull requests and the
+* open issues. The build renders the HTML, and one small inline module adds the filters.
+*/
+/** The label, the icon and the meaning of each class. The page always shows a color with an icon and a label. */
+const CLASS_INFO = {
+	waiting: {
+		label: "Waiting",
+		icon: "◷",
+		meaning: "It waits for a person or a decision"
+	},
+	blocked: {
+		label: "Blocked",
+		icon: "⊘",
+		meaning: "Other work must finish first"
+	},
+	progress: {
+		label: "In progress",
+		icon: "◐",
+		meaning: "Work started"
+	},
+	open: {
+		label: "Open",
+		icon: "○",
+		meaning: "Nobody started it"
+	},
+	later: {
+		label: "Later",
+		icon: "◌",
+		meaning: "It is for later"
+	},
+	done: {
+		label: "Done",
+		icon: "✓",
+		meaning: "It is finished"
+	}
+};
+const CHECK_LABEL = {
+	success: "Checks pass",
+	failure: "Checks fail",
+	pending: "Checks run",
+	none: "No checks"
+};
+/**
+* This function gives the lead line of the status page, for example "12 open roadmap items, 9 open
+* pull requests and 0 open issues, read at Oct 19, 2026, 14:05 UTC from abc1234."
+*/
+function statusLead(data) {
+	const parts = [];
+	if (data.source.roadmap) parts.push(plural(data.items.filter((item) => item.statusClass !== "done").length, "open roadmap item"));
+	if (data.github.available) {
+		parts.push(plural(data.github.totals?.pullRequests ?? data.pullRequests.length, "open pull request"));
+		parts.push(plural(data.github.totals?.issues ?? data.issues.length, "open issue"));
+	}
+	const commit = data.commit ? data.commit.slice(0, 7) : null;
+	const read = `read at ${longDate(data.generatedAt)}${commit ? ` from ${commit}` : ""}`;
+	const line = parts.length > 0 ? `${listText(parts)}, ${read}.` : `Read at ${read.slice(8)}.`;
+	return data.github.available ? line : `${line} The build could not read GitHub.`;
+}
+/** This function gives the part of a URL for a text: "The server stack (R37)" gives "the-server-stack-r37". */
+function slugOf(text) {
+	return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "other";
+}
+/** This function gives the sections of the items, in the sequence of the file. */
+function sectionsOf(items) {
+	const sections = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const slug = slugOf(item.section);
+		const section = sections.get(slug) ?? {
+			slug,
+			label: item.section || "Other",
+			open: 0,
+			done: 0
+		};
+		if (item.statusClass === "done") section.done++;
+		else section.open++;
+		sections.set(slug, section);
+	}
+	return [...sections.values()];
+}
+/** This function gives the groups of the open items in the sequence of `OPEN_CLASSES`, without the empty groups. */
+function openGroups(items) {
+	return OPEN_CLASSES.map((statusClass) => ({
+		statusClass,
+		items: items.filter((item) => item.statusClass === statusClass)
+	})).filter((group) => group.items.length > 0);
+}
+/** This function counts the items of each class. */
+function classCounts(items) {
+	const counts = {
+		waiting: 0,
+		blocked: 0,
+		progress: 0,
+		open: 0,
+		later: 0,
+		done: 0
+	};
+	for (const item of items) counts[item.statusClass]++;
+	return counts;
+}
+function roadmapUrl(data) {
+	return `https://github.com/${data.source.github}/blob/${data.commit ?? "HEAD"}/${data.source.roadmap ?? ""}`;
+}
+function meter(items) {
+	const counts = classCounts(items);
+	const present = ["done", ...OPEN_CLASSES].filter((value) => counts[value] > 0);
+	const total = Math.max(1, items.length);
+	const summary = present.map((value) => `${counts[value]} ${CLASS_INFO[value].label.toLowerCase()}`).join(", ");
+	const parts = present.map((value) => `<span class="sp-c-${value}" style="flex-grow:${(counts[value] / total).toFixed(4)}"></span>`);
+	const legend = present.map((value) => `<li class="sp-c-${value}"><span class="sp-swatch"></span>${CLASS_INFO[value].label} <strong>${counts[value]}</strong></li>`);
+	return `<div class="sp-meter" role="img" aria-label="${escapeHtml(`${plural(items.length, "item")} of the roadmap: ${summary}`)}">${parts.join("")}</div><ul class="sp-meter-legend" aria-hidden="true">${legend.join("")}</ul>`;
+}
+function itemTable(items, data, columns) {
+	const fileUrl = roadmapUrl(data);
+	const none = "<span class=\"sp-muted\">—</span>";
+	const rows = items.map((item) => {
+		const meta = [
+			escapeHtml(item.section),
+			item.area ? inlineMarkdown(item.area) : "",
+			item.needs ? `needs ${inlineMarkdown(item.needs)}` : ""
+		].filter(Boolean).join(" · ");
+		const links = item.links.length > 0 ? `<span class="sp-links">${item.links.map((each) => link(each.url, escapeHtml(each.label))).join("")}</span>` : none;
+		return `<tr class="sp-c-${item.statusClass}" data-section="${escapeHtml(slugOf(item.section))}"><th scope="row">${link(`${fileUrl}?plain=1#L${item.line}`, escapeHtml(item.id), `title="${escapeHtml(`The row of ${item.id} in the roadmap file`)}"`)}</th><td data-label="Item" class="sp-item"><span>${item.title ? inlineMarkdown(item.title) : "<span class=\"sp-muted\">No title</span>"}</span><span class="sp-item-meta sp-small sp-muted">${meta}</span></td>` + (columns.owner ? `<td data-label="Owner">${item.owner ? `<span>${inlineMarkdown(item.owner)}</span>` : none}</td>` : "") + `<td data-label="Status"><span class="sp-status"><span aria-hidden="true">${CLASS_INFO[item.statusClass].icon}</span> ${inlineMarkdown(item.status || CLASS_INFO[item.statusClass].label)}</span></td>` + (columns.links ? `<td data-label="Links">${links}</td>` : "") + "</tr>";
+	});
+	return `<div class="sp-table-box"><table class="sp-table">${"<thead><tr><th scope=\"col\">ID</th><th scope=\"col\">Item</th>" + (columns.owner ? "<th scope=\"col\">Owner</th>" : "") + "<th scope=\"col\">Status</th>" + (columns.links ? "<th scope=\"col\">Links</th>" : "") + "</tr></thead>"}<tbody>${rows.join("")}</tbody></table></div>`;
+}
+function openWork(data) {
+	const items = data.items;
+	const open = items.filter((item) => item.statusClass !== "done");
+	const done = items.filter((item) => item.statusClass === "done");
+	const counts = classCounts(items);
+	const columns = {
+		owner: items.some((item) => item.owner),
+		links: items.some((item) => item.links.length > 0)
+	};
+	const file = (data.source.roadmap ?? "").split("/").pop() ?? "";
+	const classChips = OPEN_CLASSES.map((value) => `<button type="button" class="sp-chip sp-c-${value}" data-sp-class="${value}" aria-pressed="false" title="${escapeHtml(CLASS_INFO[value].meaning)}"><span aria-hidden="true">${CLASS_INFO[value].icon}</span> ${CLASS_INFO[value].label} <span class="sp-count">${counts[value]}</span></button>`);
+	const sectionChips = sectionsOf(items).filter((section) => section.open > 0).map((section) => `<button type="button" class="sp-chip" data-sp-section="${escapeHtml(section.slug)}" aria-pressed="false">${escapeHtml(section.label)} <span class="sp-count">${section.open}</span></button>`);
+	const filters = `<div class="sp-filters" role="group" aria-label="Filters of the open work" data-sp-js><span role="group" aria-label="Status of the items">${classChips.join("")}</span>` + (sectionChips.length > 1 ? `<span role="group" aria-label="Section of the roadmap">${sectionChips.join("")}</span>` : "") + `<button type="button" class="sp-ghost" data-sp-clear hidden>Clear the filters</button></div>`;
+	const label = plural(open.length, "open item");
+	const groups = openGroups(items).map((group) => `<section class="sp-group sp-c-${group.statusClass}" data-sp-group data-class="${group.statusClass}" aria-labelledby="group-${group.statusClass}"><h3 id="group-${group.statusClass}"><span aria-hidden="true">${CLASS_INFO[group.statusClass].icon}</span> ${CLASS_INFO[group.statusClass].label} <span class="sp-group-count" data-sp-group-count>${group.items.length}</span></h3>${itemTable(group.items, data, columns)}</section>`);
+	const list = open.length === 0 ? "<p class=\"sp-callout\">The roadmap has no open item.</p>" : `<p class="sp-small sp-muted" aria-live="polite" data-sp-shown data-label="${escapeHtml(label)}">${open.length} of ${escapeHtml(label)}</p>` + groups.join("") + "<p class=\"sp-callout\" data-sp-empty hidden>No open item matches the filters.</p>";
+	const doneText = done.length === 1 ? "1 item is done." : `${done.length} items are done.`;
+	const doneList = done.length === 0 ? `<p class="sp-done sp-small"><span aria-hidden="true">✓</span> No item is done.</p>` : `<details class="sp-done sp-c-done" data-sp-done><summary><span aria-hidden="true">✓</span> ${doneText} <span data-sp-done-label>Show the done items</span></summary><section class="sp-group sp-c-done" data-sp-group data-class="done" aria-label="The done items">${itemTable(done, data, columns)}<p class="sp-callout" data-sp-done-empty hidden>No done item matches the filters.</p></section></details>`;
+	return `<section class="sp-section" aria-labelledby="open-work" data-sp-board><h2 id="open-work">Open work</h2><p class="sp-small sp-muted">Each row of a table of ${link(roadmapUrl(data), `<code>${escapeHtml(file)}</code>`)} with an ID and a status that is not done. The build reads the file, so this list follows each commit.</p>` + meter(items) + (open.length > 0 ? filters : "") + list + doneList + "</section>";
+}
+function when(date) {
+	const text = escapeHtml(longDate(date));
+	return `<time datetime="${escapeHtml(date)}" title="${text}" data-sp-rel>${text}</time>`;
+}
+function labels(names) {
+	return names.length === 0 ? "" : `<span class="sp-labels">${names.map((name) => `<span class="sp-pill">${escapeHtml(name)}</span>`).join("")}</span>`;
+}
+function githubMissing(data) {
+	return `<p class="sp-callout">The build could not read GitHub${data.github.reason ? ` (${escapeHtml(data.github.reason)})` : ""}. Refer to ${link(`https://github.com/${data.source.github}`, escapeHtml(data.source.github))} on GitHub.</p>`;
+}
+function pullRequests(data) {
+	const total = data.github.totals?.pullRequests ?? data.pullRequests.length;
+	let body;
+	if (!data.github.available) body = githubMissing(data);
+	else if (data.pullRequests.length === 0) body = `<p class="sp-callout">No pull request is open. Refer to ${link(`https://github.com/${data.source.github}/pulls?q=is%3Apr`, "all the pull requests")}.</p>`;
+	else {
+		const count = total > data.pullRequests.length ? `The ${data.pullRequests.length} most recently updated of ${plural(total, "open pull request")}.` : `${plural(total, "open pull request")}, the most recently updated first.`;
+		const cards = data.pullRequests.map((pull) => `<li class="sp-card">${link(pull.url, `<span class="sp-number">#${pull.number}</span> ${escapeHtml(pull.title)}`, "class=\"sp-card-title\"")}<span class="sp-card-meta"><span class="sp-pill${pull.draft ? "" : " sp-accent"}">${pull.draft ? "Draft" : "Ready"}</span><span class="sp-check sp-check-${pull.checks}"><span class="sp-dot-state" aria-hidden="true"></span>${CHECK_LABEL[pull.checks]}</span><span>by ${escapeHtml(pull.author)}</span><code class="sp-branch">${escapeHtml(pull.branch)}</code><span class="sp-muted">updated ${when(pull.updatedAt)}</span>${labels(pull.labels)}</span></li>`);
+		body = `<p class="sp-small sp-muted">${escapeHtml(count)}</p><ul class="sp-cards">${cards.join("")}</ul>`;
+	}
+	return `<section class="sp-section" aria-labelledby="pull-requests"><h2 id="pull-requests">Pull requests</h2>${body}</section>`;
+}
+function issues(data) {
+	const total = data.github.totals?.issues ?? data.issues.length;
+	let body;
+	if (!data.github.available) body = githubMissing(data);
+	else if (data.issues.length === 0) body = `<p class="sp-callout">No issue is open. To report a problem, ${link(`https://github.com/${data.source.github}/issues/new`, "open an issue")}.</p>`;
+	else {
+		const count = total > data.issues.length ? `The ${data.issues.length} most recently updated of ${plural(total, "open issue")}.` : `${plural(total, "open issue")}, the most recently updated first.`;
+		const cards = data.issues.map((issue) => `<li class="sp-card">${link(issue.url, `<span class="sp-number">#${issue.number}</span> ${escapeHtml(issue.title)}`, "class=\"sp-card-title\"")}<span class="sp-card-meta"><span>by ${escapeHtml(issue.author)}</span><span class="sp-muted">updated ${when(issue.updatedAt)}</span>${labels(issue.labels)}</span></li>`);
+		body = `<p class="sp-small sp-muted">${escapeHtml(count)}</p><ul class="sp-cards">${cards.join("")}</ul>`;
+	}
+	return `<section class="sp-section" aria-labelledby="issues"><h2 id="issues">Issues</h2>${body}</section>`;
+}
+/**
+* The inline module of the status page. It filters the open work by class and by section, keeps the
+* filters in the URL, and shows the age of each GitHub time.
+*/
+const STATUS_SCRIPT = String.raw`
+function relativeTime(then, now) {
+  const seconds = Math.round((now - then) / 1000);
+  if (!Number.isFinite(seconds)) return "at an unknown time";
+  if (seconds < 60) return "just now";
+  const steps = [[60, "minute"], [3600, "hour"], [86400, "day"], [2592000, "month"], [31536000, "year"]];
+  let unit = steps[0];
+  for (const step of steps) if (seconds >= step[0]) unit = step;
+  const count = Math.floor(seconds / unit[0]);
+  return count + " " + unit[1] + (count === 1 ? "" : "s") + " ago";
+}
+function listOf(text) {
+  return (text || "").split(",").filter((part) => part !== "");
+}
+` + String.raw`
+const now = Date.now();
+for (const time of document.querySelectorAll("time[data-sp-rel]")) {
+  time.textContent = relativeTime(Date.parse(time.dateTime), now) + " (" + time.title + ")";
+}
+const board = document.querySelector("[data-sp-board]");
+if (board) {
+  const classChips = Array.from(board.querySelectorAll("[data-sp-class]"));
+  const sectionChips = Array.from(board.querySelectorAll("[data-sp-section]"));
+  const groups = Array.from(board.querySelectorAll("[data-sp-group]"));
+  const shown = board.querySelector("[data-sp-shown]");
+  const empty = board.querySelector("[data-sp-empty]");
+  const clear = board.querySelector("[data-sp-clear]");
+  const done = board.querySelector("[data-sp-done]");
+  const query = new URLSearchParams(location.search);
+  const state = {
+    classes: listOf(query.get("status")).filter((value) => classChips.some((chip) => chip.dataset.spClass === value)),
+    sections: listOf(query.get("section")),
+  };
+  if (done && query.get("done") === "1") done.open = true;
+  const apply = (write) => {
+    for (const chip of classChips) chip.setAttribute("aria-pressed", String(state.classes.includes(chip.dataset.spClass)));
+    for (const chip of sectionChips) chip.setAttribute("aria-pressed", String(state.sections.includes(chip.dataset.spSection)));
+    let count = 0;
+    for (const group of groups) {
+      const isDone = group.dataset.class === "done";
+      const classOn = isDone || state.classes.length === 0 || state.classes.includes(group.dataset.class);
+      let visible = 0;
+      for (const row of group.querySelectorAll("tr[data-section]")) {
+        const on = classOn && (state.sections.length === 0 || state.sections.includes(row.dataset.section));
+        row.hidden = !on;
+        if (on) visible++;
+      }
+      if (isDone) {
+        const none = group.querySelector("[data-sp-done-empty]");
+        if (none) none.hidden = visible > 0;
+      } else {
+        group.hidden = visible === 0;
+        const badge = group.querySelector("[data-sp-group-count]");
+        if (badge) badge.textContent = String(visible);
+        count += visible;
+      }
+    }
+    if (shown) shown.textContent = count + " of " + shown.dataset.label;
+    if (empty) empty.hidden = count > 0;
+    if (clear) clear.hidden = state.classes.length === 0 && state.sections.length === 0;
+    if (done) {
+      const label = done.querySelector("[data-sp-done-label]");
+      if (label) label.textContent = done.open ? "Hide the done items" : "Show the done items";
+    }
+    if (!write) return;
+    const next = new URLSearchParams(location.search);
+    const put = (key, value) => (value ? next.set(key, value) : next.delete(key));
+    put("status", state.classes.join(","));
+    put("section", state.sections.join(","));
+    put("done", done && done.open ? "1" : "");
+    const search = next.toString();
+    try {
+      history.replaceState(null, "", location.pathname + (search ? "?" + search : "") + location.hash);
+    } catch {}
+  };
+  const toggle = (list, value) => (list.includes(value) ? list.filter((each) => each !== value) : list.concat(value));
+  board.addEventListener("click", (event) => {
+    const chip = event.target.closest("button");
+    if (!chip) return;
+    if (chip.dataset.spClass) state.classes = toggle(state.classes, chip.dataset.spClass);
+    else if (chip.dataset.spSection) state.sections = toggle(state.sections, chip.dataset.spSection);
+    else if (chip.hasAttribute("data-sp-clear")) {
+      state.classes = [];
+      state.sections = [];
+    } else return;
+    apply(true);
+  });
+  if (done) done.addEventListener("toggle", () => apply(true));
+  apply(false);
+}
+`;
+/** This function renders the complete status page from the data of `status.json`. */
+function renderStatusPage(data, options) {
+	const lead = statusLead(data);
+	return pageShell({
+		title: "Status",
+		description: lead,
+		current: "status",
+		main: `<h1>Status</h1><p class="sp-lead">${escapeHtml(lead)}</p><p class="sp-small sp-muted">The build reads the roadmap file and GitHub again after each commit and on a schedule.</p>` + (data.source.roadmap ? openWork(data) : "") + pullRequests(data) + issues(data),
+		script: STATUS_SCRIPT
+	}, options);
+}
+//#endregion
+//#region src/build.ts
+/**
+* The `site-pages build` command. It reads the sources. Then it writes the JSON data and the two
+* standalone pages into the built output folder of a site.
+*/
+/** An error in the command line. The CLI shows the help and exits with code 2. */
+var UsageError = class extends Error {};
+function write(file, content, files) {
+	mkdirSync(dirname(file), { recursive: true });
+	writeFileSync(file, content);
+	files.push(file);
+}
+/**
+* This function reads the sources and writes `data/releases.json`, `data/status.json`,
+* `releases/index.html` and `status/index.html` into the output folder.
+*
+* @throws ReleaseDataError or RoadmapParseError when a source on disk is not correct
+*/
+async function build(options) {
+	const { repoDir, repository, warn = () => {} } = options;
+	const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
+	const commit = options.commit === void 0 ? headCommit(repoDir) : options.commit;
+	const [owner = "", repo = ""] = repository.split("/");
+	const out = isAbsolute(options.out) ? options.out : resolve(repoDir, options.out);
+	const fetcher = options.fetch ? { fetch: options.fetch } : {};
+	const releases = await readReleases({
+		repoDir,
+		repository,
+		token: options.token,
+		changesets: options.changesets,
+		packages: options.packages,
+		group: options.group,
+		ref: commit ?? void 0,
+		now,
+		warn,
+		...fetcher
+	});
+	const status = await readStatusBoard({
+		repoDir,
+		roadmap: options.roadmap ?? null,
+		owner,
+		repo,
+		token: options.token,
+		commit,
+		generatedAt: now,
+		...fetcher
+	});
+	if (!status.github.available) warn(`the status page has no GitHub data: ${status.github.reason ?? "no reason"}.`);
+	const files = [];
+	write(join(out, "data", "releases.json"), `${JSON.stringify(releases, null, 2)}\n`, files);
+	write(join(out, "data", "status.json"), `${JSON.stringify(status, null, 2)}\n`, files);
+	if (!options.dataOnly) {
+		const page = {
+			repository,
+			base: options.base,
+			siteName: options.siteName,
+			extraCss: options.css ? readFileSync(isAbsolute(options.css) ? options.css : resolve(repoDir, options.css), "utf8") : void 0,
+			generatedAt: now,
+			commit
+		};
+		write(join(out, "releases", "index.html"), renderReleasesPage(releases, page), files);
+		write(join(out, "status", "index.html"), renderStatusPage(status, page), files);
+	}
+	return {
+		files,
+		releases,
+		status
+	};
+}
+/** The help of the CLI. */
+const HELP = `Usage: site-pages build --out <dir> [options]
+
+Writes <out>/data/releases.json, <out>/data/status.json, <out>/releases/index.html
+and <out>/status/index.html. Start it in the repository, after the build of the site.
+
+Options:
+  --out <dir>           The built output folder of the site (necessary)
+  --repo <owner/name>   The GitHub repository (default: $GITHUB_REPOSITORY, else the remote "origin")
+  --base </name/>       The path of the site home (default: "/<name>/", or "/" for <owner>.github.io)
+  --roadmap <file>      The roadmap file (default: none, the status page has only the GitHub part)
+  --packages <names>    npm names or a @scope, separated by commas, for the npm dates
+  --changesets <glob>   The changelog files (default: packages/*/CHANGELOG.md, else CHANGELOG.md)
+  --group <name>        The npm name of the package whose changelog gives the versions
+  --token <token>       A GitHub token with read access (default: $GITHUB_TOKEN)
+  --css <file>          A CSS file for the pages, after the default CSS
+  --site-name <name>    The name of the site in the header (default: the repository name)
+  --data-only           Write only the JSON data, not the pages
+  -h, --help            Show this help
+`;
+/**
+* This function reads the command line into the options of `build`.
+*
+* @throws UsageError when the command line is not correct
+*/
+function parseBuildArgs(argv, io) {
+	let parsed;
+	try {
+		parsed = parseCommandLine(argv);
+	} catch (error) {
+		throw new UsageError(error instanceof Error ? error.message : String(error));
+	}
+	const { values, positionals } = parsed;
+	if (values.help) return "help";
+	if (positionals[0] !== "build" || positionals.length > 1) throw new UsageError(positionals.length === 0 ? "no command was given" : `unknown command: ${positionals.join(" ")}`);
+	if (!values.out) throw new UsageError("--out is necessary");
+	const repository = values.repo || io.env["GITHUB_REPOSITORY"] || originRepository(io.cwd) || "";
+	if (!/^[\w.-]+\/[\w.-]+$/.test(repository)) throw new UsageError(repository ? `--repo must be "owner/name", not "${repository}"` : "give --repo <owner/name> or set GITHUB_REPOSITORY");
+	const name = repository.split("/")[1] ?? "";
+	let base = values.base ?? (/\.github\.io$/i.test(name) ? "/" : `/${name}/`);
+	if (!base.startsWith("/")) base = `/${base}`;
+	if (!base.endsWith("/")) base = `${base}/`;
+	const packages = (values.packages ?? []).flatMap((entry) => entry.split(",")).map((entry) => entry.trim()).filter(Boolean);
+	const changesets = values.changesets;
+	return {
+		repoDir: io.cwd,
+		repository,
+		out: values.out,
+		base,
+		roadmap: values.roadmap,
+		packages,
+		changesets,
+		group: values.group,
+		token: values.token || io.env["GITHUB_TOKEN"] || void 0,
+		css: values.css,
+		siteName: values["site-name"],
+		dataOnly: values["data-only"] === true
+	};
+}
+function parseCommandLine(argv) {
+	return parseArgs({
+		args: [...argv],
+		allowPositionals: true,
+		strict: true,
+		options: {
+			out: { type: "string" },
+			repo: { type: "string" },
+			base: { type: "string" },
+			roadmap: { type: "string" },
+			packages: {
+				type: "string",
+				multiple: true
+			},
+			changesets: { type: "string" },
+			group: { type: "string" },
+			token: { type: "string" },
+			css: { type: "string" },
+			"site-name": { type: "string" },
+			"data-only": { type: "boolean" },
+			help: {
+				type: "boolean",
+				short: "h"
+			}
+		}
+	});
+}
+/**
+* This function starts the CLI and gives the exit code. The code is 0 after a build, 1 when a
+* source is not correct, and 2 for an incorrect command line.
+*/
+async function runCli(argv, io) {
+	let options;
+	try {
+		options = parseBuildArgs(argv, io);
+	} catch (error) {
+		if (!(error instanceof UsageError)) throw error;
+		io.stderr(`site-pages: ${error.message}\n\n${HELP}`);
+		return 2;
+	}
+	if (options === "help") {
+		io.stdout(HELP);
+		return 0;
+	}
+	try {
+		const result = await build({
+			...options,
+			warn: (message) => io.stderr(`site-pages: ${message}\n`),
+			...io.fetch ? { fetch: io.fetch } : {},
+			...io.now ? { now: io.now } : {}
+		});
+		const open = result.status.items.filter((item) => item.statusClass !== "done").length;
+		const github = result.status.github.available ? `${plural(result.status.pullRequests.length, "open pull request")} and ${plural(result.status.issues.length, "open issue")}` : "no GitHub data";
+		io.stdout(`site-pages: ${plural(result.releases.length, "release")}, ${plural(result.status.items.length, "roadmap item")} (${open} open), ${github}.\n` + result.files.map((file) => `  ${file}\n`).join(""));
+		return 0;
+	} catch (error) {
+		if (error instanceof ReleaseDataError || error instanceof RoadmapParseError || error?.code === "ENOENT") {
+			io.stderr(`site-pages: ${error.message}\n`);
+			return 1;
+		}
+		throw error;
+	}
+}
+//#endregion
+export { GITHUB_API as $, RoadmapParseError as A, DEFAULT_CHANGELOGS as B, longDate as C, inlineMarkdown as D, escapeHtml as E, plainText as F, globFiles as G, mergeReleases as H, readStatusBoard as I, headingDate as J, gitTagDates as K, roadmapItems as L, buildStatusBoard as M, linksOf as N, safeUrl as O, markdownTables as P, npmPublishTimes as Q, splitRow as R, dayRange as S, utcDay as T, readChangelogs as U, ReleaseDataError as V, readReleases as W, originRepository as X, isShallow as Y, NPM_REGISTRY as Z, oldestFirst as _, runCli as a, headingAnchor as at, BASE_CSS as b, openGroups as c, compareVersions as ct, slugOf as d, versionOfTag as dt, GITHUB_GRAPHQL as et, statusLead as f, laneCenter as g, renderReleasesPage as h, parseBuildArgs as i, firstSentence as it, STATUS_CLASSES as j, OPEN_CLASSES as k, renderStatusPage as l, kindOf as lt, releasesLead as m, UsageError as n, githubOpenWork as nt, STATUS_SCRIPT as o, parseChangelog as ot, RELEASES_SCRIPT as p, headCommit as q, build as r, githubReleases as rt, classCounts as s, releaseBodyEntries as st, HELP as t, checkStateOf as tt, sectionsOf as u, parseVersion as ut, releaseSummary as v, shortDate as w, pageShell as x, timelineLayout as y, statusClassOf as z };
+
+//# sourceMappingURL=build-vAps0mRE.js.map