@magland/mochi 0.3.1

package/dist/releases.js

@@ -0,0 +1,435 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releasesDir = releasesDir;
+exports.readRelease = readRelease;
+exports.listReleases = listReleases;
+exports.releaseTags = releaseTags;
+exports.saveRelease = saveRelease;
+exports.deleteRelease = deleteRelease;
+exports.hasReleases = hasReleases;
+exports.registerReleases = registerReleases;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const YAML = __importStar(require("yaml"));
+const atom_1 = require("./atom");
+const atomic_1 = require("./atomic");
+const git_1 = require("./git");
+const html_1 = require("./html");
+const icons_1 = require("./icons");
+const markdown_1 = require("./markdown");
+const render_1 = require("./render");
+const session_1 = require("./session");
+const layout_1 = require("./layout");
+const scan_1 = require("./scan");
+const views_1 = require("./views");
+const web_1 = require("./web");
+const MAX_NAME = 200;
+const MAX_NOTES = 64 * 1024;
+function releasesDir(root, collection, repo) {
+    return (0, layout_1.repoPath)(root, collection, `${repo}.releases`);
+}
+function fileFor(dir, tag) {
+    // encodeURIComponent leaves no slash and no dot-dot, so the name cannot
+    // climb out of the directory however the tag was written.
+    return path.join(dir, `${encodeURIComponent(tag)}.md`);
+}
+function parseRelease(text, tag) {
+    const m = text.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    let head = {};
+    let body = text;
+    if (m) {
+        try {
+            head = (YAML.parse(m[1]) ?? {});
+        }
+        catch {
+            head = {};
+        }
+        body = m[2];
+    }
+    const str = (v) => (typeof v === 'string' ? v : '');
+    return {
+        tag: str(head.tag) || tag,
+        name: str(head.name),
+        author: str(head.author),
+        created: str(head.created),
+        prerelease: head.prerelease === true,
+        body,
+    };
+}
+function readRelease(root, collection, repo, tag) {
+    if (!(0, scan_1.isValidName)(collection) || !(0, scan_1.isValidName)(repo) || !(0, git_1.isValidRefName)(tag))
+        return null;
+    try {
+        const text = fs.readFileSync(fileFor(releasesDir(root, collection, repo), tag), 'utf8');
+        return parseRelease(text, tag);
+    }
+    catch {
+        return null;
+    }
+}
+/** Every release in the vault for this repository, newest first by tag date. */
+function listReleases(root, collection, repo) {
+    const dir = releasesDir(root, collection, repo);
+    let names;
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of names) {
+        if (!name.endsWith('.md'))
+            continue;
+        let tag;
+        try {
+            tag = decodeURIComponent(name.slice(0, -3));
+        }
+        catch {
+            continue;
+        }
+        const release = readRelease(root, collection, repo, tag);
+        if (release)
+            out.push(release);
+    }
+    return out;
+}
+/**
+ * The tag of every release, from the directory alone.
+ *
+ * A release's file is named for its tag, so counting releases and asking
+ * whether a tag has one needs no file opened and no front matter parsed --
+ * which is all that a repository page wants, and it wants it on every page.
+ * listReleases reads and YAML-parses every release to answer the same two
+ * questions, which at a hundred releases is 19ms and a hundred opens spent on
+ * bodies nobody looks at.
+ */
+function releaseTags(root, collection, repo) {
+    let names;
+    try {
+        names = fs.readdirSync(releasesDir(root, collection, repo));
+    }
+    catch {
+        return [];
+    }
+    const tags = [];
+    for (const name of names) {
+        if (!name.endsWith('.md'))
+            continue;
+        try {
+            tags.push(decodeURIComponent(name.slice(0, -3)));
+        }
+        catch {
+            // A name that is not a tag this forge wrote; listReleases skips it too.
+        }
+    }
+    return tags;
+}
+function saveRelease(root, collection, repo, release) {
+    const dir = releasesDir(root, collection, repo);
+    fs.mkdirSync(dir, { recursive: true });
+    const head = YAML.stringify({
+        tag: release.tag,
+        name: release.name,
+        author: release.author,
+        created: release.created,
+        prerelease: release.prerelease,
+    }).trimEnd();
+    (0, atomic_1.writeFileAtomic)(fileFor(dir, release.tag), `---\n${head}\n---\n${release.body}\n`);
+}
+function deleteRelease(root, collection, repo, tag) {
+    if (!(0, git_1.isValidRefName)(tag))
+        return false;
+    try {
+        fs.unlinkSync(fileFor(releasesDir(root, collection, repo), tag));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function hasReleases(root, collection, repo) {
+    try {
+        return fs.readdirSync(releasesDir(root, collection, repo)).some((n) => n.endsWith('.md'));
+    }
+    catch {
+        return false;
+    }
+}
+// ---- pages ----
+function releaseTitle(release) {
+    return release.name || release.tag;
+}
+/** The download links: the source at that tag, from the archive routes. */
+function downloads(ctx, tag) {
+    const base = `${(0, views_1.repoUrl)(ctx)}/archive/${(0, views_1.encPath)(tag)}`;
+    const one = (ext, label) => (0, html_1.html) `<a class="release-download" href="${base}.${ext}">${(0, icons_1.icon)('file-zip')}<span>${label}</span></a>`;
+    return (0, html_1.html) `<div class="release-downloads">${one('zip', 'Source code (zip)')}${one('tar.gz', 'Source code (tar.gz)')}</div>`;
+}
+function releaseCard(ctx, release, ref, latest, notes) {
+    const base = (0, views_1.repoUrl)(ctx);
+    const chips = [
+        latest ? (0, html_1.raw)('<span class="chip chip-latest">Latest</span>') : '',
+        release.prerelease ? (0, html_1.raw)('<span class="chip chip-pre">Pre-release</span>') : '',
+    ];
+    const edit = ctx.canPush
+        ? (0, html_1.html) `<a class="btn" href="${base}/releases/new?tag=${encodeURIComponent(release.tag)}">${(0, icons_1.icon)('pencil')}<span>Edit</span></a>`
+        : '';
+    return (0, html_1.html) `<div class="release">
+  <div class="release-side">
+    <a class="release-tag" href="${base}/tree/${(0, views_1.encPath)(release.tag)}">${(0, icons_1.icon)('tag')}<b>${release.tag}</b></a>
+    ${ref ? (0, html_1.html) `<div class="small muted">${(0, render_1.timeTag)(ref.date)}</div>` : ''}
+    ${ref ? (0, html_1.html) `<a class="sha" href="${base}/commit/${ref.sha}">${ref.sha.slice(0, 7)}</a>` : ''}
+  </div>
+  <div class="release-main">
+    <div class="release-head"><h2><a href="${base}/releases/tag/${(0, views_1.encPath)(release.tag)}">${releaseTitle(release)}</a></h2>${chips}<span class="release-actions">${edit}</span></div>
+    <div class="muted small">${release.author ? (0, html_1.html) `${release.author} released this` : 'Released'} ${release.created ? (0, render_1.timeTag)(release.created) : ''}</div>
+    ${notes ? (0, html_1.html) `<div class="markdown-body release-notes">${(0, html_1.raw)(notes)}</div>` : (0, html_1.raw)('<p class="muted">No notes.</p>')}
+    ${downloads(ctx, release.tag)}
+  </div>
+</div>`;
+}
+function releasesPage(ctx, cards, count) {
+    const base = (0, views_1.repoUrl)(ctx);
+    const newBtn = ctx.canPush
+        ? (0, html_1.html) `<a class="btn btn-primary" href="${base}/releases/new">${(0, icons_1.icon)('plus')}<span>Draft a release</span></a>`
+        : '';
+    const feed = (0, html_1.html) `<a class="btn" href="${base}/releases.atom" title="Atom feed of releases">${(0, icons_1.icon)('rss')}<span>Feed</span></a>`;
+    const body = count === 0
+        ? (0, html_1.html) `<div class="empty-state"><p>No releases yet.</p><p class="small">A release is notes attached to a tag. ${ctx.canPush ? 'Draft one above,' : 'Someone with push access can draft one,'} or browse the <a href="${base}/tags">tags</a>.</p></div>`
+        : cards;
+    const content = (0, html_1.html) `${(0, views_1.repoHeader)(ctx, 'releases')}
+<div class="page-head"><h1>Releases</h1><span class="right-group">${feed}${newBtn}</span></div>
+${body}`;
+    return (0, views_1.layout)(`Releases - ${ctx.collection}/${ctx.repo}`, content, (0, views_1.repoOpts)(ctx, `${base}/releases`));
+}
+function releaseFormPage(ctx, viewer, tags, editing, error) {
+    const base = (0, views_1.repoUrl)(ctx);
+    const options = tags.map((t) => (0, html_1.html) `<option value="${t.name}"${editing && t.name === editing.tag ? (0, html_1.raw)(' selected') : ''}>${t.name}</option>`);
+    const del = editing && ctx.canPush
+        ? (0, html_1.html) `<form method="post" action="${base}/releases/delete" data-confirm="Delete the notes for ${editing.tag}? The tag itself is not touched.">${(0, views_1.csrfField)(viewer)}<input type="hidden" name="tag" value="${editing.tag}"><button type="submit" class="btn btn-danger-outline">${(0, icons_1.icon)('trash')}<span>Delete release</span></button></form>`
+        : '';
+    const content = (0, html_1.html) `${(0, views_1.repoHeader)(ctx, 'releases')}
+<div class="form-box wide">
+<h1>${editing ? 'Edit release' : 'Draft a release'}</h1>
+${error ? (0, html_1.html) `<div class="form-error">${error}</div>` : ''}
+<form method="post" action="${base}/releases/new">
+${(0, views_1.csrfField)(viewer)}
+<div class="field"><label for="tag">Tag</label>
+${editing
+        ? (0, html_1.html) `<input type="hidden" name="tag" value="${editing.tag}"><p class="mono">${editing.tag}</p>`
+        : (0, html_1.html) `<select id="tag" name="tag" required>${options}</select>
+<p class="muted small">Releases attach to a tag that already exists. Create one on the <a href="${base}/tags">tags page</a> first.</p>`}
+</div>
+<div class="field"><label for="name">Title</label>
+<input type="text" id="name" name="name" maxlength="${MAX_NAME}" value="${editing?.name ?? ''}" placeholder="Leave empty to use the tag name"></div>
+<div class="field"><label for="body">Notes</label>
+<textarea class="code-editor" id="body" name="body" rows="16" placeholder="What changed, and what it means for anyone upgrading. Markdown.">${editing?.body ?? ''}</textarea></div>
+<div class="field"><label class="checkbox"><input type="checkbox" name="prerelease" value="1"${editing?.prerelease ? (0, html_1.raw)(' checked') : ''}> This is a pre-release</label></div>
+<div class="actions"><button type="submit" class="btn btn-primary">${editing ? 'Save release' : 'Publish release'}</button><a class="btn" href="${base}/releases">Cancel</a>${del}</div>
+</form>
+</div>`;
+    return (0, views_1.layout)(`${editing ? 'Edit' : 'Draft'} release - ${ctx.collection}/${ctx.repo}`, content, (0, views_1.repoOpts)(ctx, `${base}/releases/new`));
+}
+// ---- routes ----
+function registerReleases(app, root) {
+    // Release notes are prose about a version, not a place to paste an artifact,
+    // so this form is held to a much smaller body than the file editor's.
+    const form = (0, web_1.urlencodedForm)('256kb');
+    // Writing a release is a write to the vault, so it needs the same session,
+    // CSRF check, and the write role on the repository that editing a file does.
+    function requirePusher(req, res, ctx, viewer) {
+        if (!viewer) {
+            (0, web_1.fail)(res, 403, 'You must be signed in to do that.', null, '/login');
+            return false;
+        }
+        if (!(0, session_1.checkCsrf)(req, viewer)) {
+            (0, web_1.fail)(res, 403, 'The form has expired; go back, reload the page, and try again.', viewer);
+            return false;
+        }
+        if (!ctx.canPush) {
+            (0, web_1.fail)(res, 403, `You do not have push access to ${ctx.collection}/${ctx.repo}.`, viewer, (0, views_1.repoUrl)(ctx));
+            return false;
+        }
+        return true;
+    }
+    /** Releases with the tag each one points at, newest tag first. */
+    function ordered(root, ctx) {
+        const byName = new Map(ctx.tags.map((t) => [t.name, t]));
+        return listReleases(root, ctx.collection, ctx.repo)
+            .map((release) => ({ release, ref: byName.get(release.tag) }))
+            .sort((a, b) => {
+            const at = a.ref?.date ?? a.release.created;
+            const bt = b.ref?.date ?? b.release.created;
+            return bt.localeCompare(at);
+        });
+    }
+    app.get('/:collection/:repo/releases', (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, session_1.getViewer)(req, root);
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return;
+        const ctx = await (0, web_1.makeCtx)(root, req, loaded, loaded.defaultBranch ?? '', viewer);
+        const rows = ordered(root, ctx);
+        const cards = (0, html_1.joinHtml)(rows.map(({ release, ref }, i) => releaseCard(ctx, release, ref, i === 0 && !release.prerelease, notesHtml(ctx, release))));
+        res.type('html').send(releasesPage(ctx, cards, rows.length));
+    }));
+    app.get('/:collection/:repo/releases.atom', (0, web_1.ah)(async (req, res) => {
+        // The viewer is resolved so a signed-in browser can read a private
+        // repository's feed; an anonymous feed reader of one gets the 404
+        // loadRepo answers.
+        const loaded = await (0, web_1.loadRepo)(root, req, res, (0, session_1.getViewer)(req, root));
+        if (!loaded)
+            return;
+        const ctx = await (0, web_1.makeCtx)(root, req, loaded, loaded.defaultBranch ?? '', null);
+        const base = `${(0, web_1.baseUrlOf)(req)}${(0, views_1.repoUrl)(ctx)}`;
+        const rows = ordered(root, ctx);
+        res
+            .type('application/atom+xml; charset=utf-8')
+            .send((0, atom_1.atomFeed)({
+            id: `${base}/releases`,
+            title: `${ctx.collection}/${ctx.repo} releases`,
+            selfLink: `${base}/releases.atom`,
+            htmlLink: `${base}/releases`,
+            entries: rows.map(({ release, ref }) => ({
+                id: `${base}/releases/tag/${(0, views_1.encPath)(release.tag)}`,
+                title: releaseTitle(release),
+                updated: ref?.date || release.created,
+                link: `${base}/releases/tag/${(0, views_1.encPath)(release.tag)}`,
+                author: release.author || ctx.collection,
+                summary: release.body,
+            })),
+        }));
+    }));
+    app.get('/:collection/:repo/releases/new', (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, session_1.getViewer)(req, root);
+        if (!viewer) {
+            res.redirect(`/login?next=${encodeURIComponent(req.originalUrl)}`);
+            return;
+        }
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return;
+        const ctx = await (0, web_1.makeCtx)(root, req, loaded, loaded.defaultBranch ?? '', viewer);
+        if (!ctx.canPush) {
+            (0, web_1.fail)(res, 403, `You do not have push access to ${ctx.collection}/${ctx.repo}.`, viewer, (0, views_1.repoUrl)(ctx));
+            return;
+        }
+        const asked = String(req.query.tag ?? '');
+        const editing = asked ? readRelease(root, ctx.collection, ctx.repo, asked) : null;
+        if (asked && !editing && !ctx.tags.some((t) => t.name === asked)) {
+            (0, web_1.send404)(res, `Tag ${asked} not found`, viewer);
+            return;
+        }
+        // A tag that already has notes is edited rather than drafted twice.
+        const draft = editing ??
+            (asked
+                ? { tag: asked, name: '', author: viewer.auth.username, created: '', prerelease: false, body: '' }
+                : null);
+        res.type('html').send(releaseFormPage(ctx, viewer, ctx.tags, draft));
+    }));
+    app.post('/:collection/:repo/releases/new', form, (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, session_1.getViewer)(req, root);
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return;
+        const ctx = await (0, web_1.makeCtx)(root, req, loaded, loaded.defaultBranch ?? '', viewer);
+        if (!requirePusher(req, res, ctx, viewer))
+            return;
+        const tag = (0, web_1.field)(req, 'tag');
+        if (!(0, git_1.isValidRefName)(tag) || !ctx.tags.some((t) => t.name === tag)) {
+            (0, web_1.fail)(res, 400, `There is no tag named ${tag} in this repository.`, viewer, `${(0, views_1.repoUrl)(ctx)}/releases`);
+            return;
+        }
+        const existing = readRelease(root, ctx.collection, ctx.repo, tag);
+        const body = (0, web_1.field)(req, 'body').replace(/\r\n/g, '\n').slice(0, MAX_NOTES);
+        saveRelease(root, ctx.collection, ctx.repo, {
+            tag,
+            name: (0, web_1.field)(req, 'name').slice(0, MAX_NAME).trim(),
+            // The first publisher keeps the byline; an edit does not steal it.
+            author: existing?.author || viewer.auth.username,
+            created: existing?.created || new Date().toISOString(),
+            prerelease: (0, web_1.field)(req, 'prerelease') === '1',
+            body,
+        });
+        res.redirect(`${(0, views_1.repoUrl)(ctx)}/releases/tag/${(0, views_1.encPath)(tag)}`);
+    }));
+    app.post('/:collection/:repo/releases/delete', form, (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, session_1.getViewer)(req, root);
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return;
+        const ctx = await (0, web_1.makeCtx)(root, req, loaded, loaded.defaultBranch ?? '', viewer);
+        if (!requirePusher(req, res, ctx, viewer))
+            return;
+        deleteRelease(root, ctx.collection, ctx.repo, (0, web_1.field)(req, 'tag'));
+        res.redirect(`${(0, views_1.repoUrl)(ctx)}/releases`);
+    }));
+    app.get('/:collection/:repo/releases/tag/*', (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, session_1.getViewer)(req, root);
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return;
+        const tag = (0, web_1.wildcard)(req);
+        const ctx = await (0, web_1.makeCtx)(root, req, loaded, tag, viewer);
+        const release = readRelease(root, ctx.collection, ctx.repo, tag);
+        if (!release) {
+            (0, web_1.send404)(res, `No release for ${tag}`, viewer);
+            return;
+        }
+        const ref = ctx.tags.find((t) => t.name === tag);
+        const rows = ordered(root, ctx);
+        const latest = rows.length > 0 && rows[0].release.tag === tag && !release.prerelease;
+        const content = (0, html_1.html) `${(0, views_1.repoHeader)(ctx, 'releases')}
+<div class="page-head"><h1><a href="${(0, views_1.repoUrl)(ctx)}/releases">Releases</a></h1></div>
+${releaseCard(ctx, release, ref, latest, notesHtml(ctx, release))}`;
+        res
+            .type('html')
+            .send((0, views_1.layout)(`${releaseTitle(release)} - ${ctx.collection}/${ctx.repo}`, content, (0, views_1.repoOpts)(ctx, `${(0, views_1.repoUrl)(ctx)}/releases/tag/${(0, views_1.encPath)(tag)}`)));
+    }));
+    /** Notes are markdown from a repository writer, rendered by the same sanitizing path as a README. */
+    function notesHtml(ctx, release) {
+        if (release.body.trim() === '')
+            return '';
+        const base = (0, views_1.repoUrl)(ctx);
+        return (0, markdown_1.renderMarkdown)(release.body, {
+            rawBase: `${base}/raw/${(0, views_1.encPath)(release.tag)}`,
+            blobBase: `${base}/blob/${(0, views_1.encPath)(release.tag)}`,
+            issueBase: `${base}/issues`,
+            commitBase: `${base}/commit`,
+        });
+    }
+}

package/dist/render.js

@@ -0,0 +1,233 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.esc = void 0;
+exports.languageFor = languageFor;
+exports.highlightCode = highlightCode;
+exports.highlightedLines = highlightedLines;
+exports.isBinary = isBinary;
+exports.formatSize = formatSize;
+exports.formatDate = formatDate;
+exports.formatDateFull = formatDateFull;
+exports.formatDay = formatDay;
+exports.timeAgo = timeAgo;
+exports.timeTag = timeTag;
+const highlight_js_1 = __importDefault(require("highlight.js"));
+const html_1 = require("./html");
+// esc lives in html.ts now, beside the template tag that made it the
+// exception rather than the rule; re-exported here so the files that still
+// escape by hand keep their import until they are converted.
+var html_2 = require("./html");
+Object.defineProperty(exports, "esc", { enumerable: true, get: function () { return html_2.esc; } });
+const EXT_LANG = {
+    js: 'javascript',
+    mjs: 'javascript',
+    cjs: 'javascript',
+    jsx: 'javascript',
+    ts: 'typescript',
+    tsx: 'typescript',
+    py: 'python',
+    rb: 'ruby',
+    go: 'go',
+    rs: 'rust',
+    c: 'c',
+    h: 'c',
+    cpp: 'cpp',
+    cc: 'cpp',
+    cxx: 'cpp',
+    hpp: 'cpp',
+    java: 'java',
+    json: 'json',
+    yml: 'yaml',
+    yaml: 'yaml',
+    sh: 'bash',
+    bash: 'bash',
+    zsh: 'bash',
+    html: 'xml',
+    htm: 'xml',
+    xml: 'xml',
+    css: 'css',
+    scss: 'scss',
+    less: 'less',
+    md: 'markdown',
+    markdown: 'markdown',
+    toml: 'ini',
+    ini: 'ini',
+    cfg: 'ini',
+    sql: 'sql',
+    php: 'php',
+    swift: 'swift',
+    kt: 'kotlin',
+    m: 'objectivec',
+    r: 'r',
+    jl: 'julia',
+    pl: 'perl',
+    lua: 'lua',
+    diff: 'diff',
+    patch: 'diff',
+    txt: 'plaintext',
+};
+const NAME_LANG = {
+    dockerfile: 'dockerfile',
+    makefile: 'makefile',
+    cmakelists_txt: 'cmake',
+};
+function languageFor(filename) {
+    const base = filename.split('/').pop() ?? filename;
+    const byName = NAME_LANG[base.toLowerCase().replace(/\./g, '_')];
+    if (byName)
+        return byName;
+    const dot = base.lastIndexOf('.');
+    if (dot === -1)
+        return null;
+    return EXT_LANG[base.slice(dot + 1).toLowerCase()] ?? null;
+}
+function highlightCode(text, filename) {
+    const lang = languageFor(filename);
+    if (lang && highlight_js_1.default.getLanguage(lang)) {
+        try {
+            return highlight_js_1.default.highlight(text, { language: lang, ignoreIllegals: true }).value;
+        }
+        catch {
+            // fall through to plain
+        }
+    }
+    return (0, html_1.esc)(text);
+}
+/**
+ * Highlighted code split into one HTML string per line, so each line can be
+ * its own element and so carry an anchor. highlight.js emits spans that cross
+ * line boundaries (a block comment, a multi-line string), which is why this
+ * cannot be a split on newline: open spans are closed at the end of a line and
+ * reopened at the start of the next. The input is highlight.js output, whose
+ * only tags are <span class="..."> and </span> and whose text is escaped, so
+ * tokenizing on angle brackets is sound here and nowhere else.
+ */
+function highlightedLines(html) {
+    const lines = [];
+    const open = [];
+    let current = '';
+    for (const token of html.match(/<[^>]*>|[^<]+/g) ?? []) {
+        if (token.startsWith('</')) {
+            open.pop();
+            current += token;
+        }
+        else if (token.startsWith('<')) {
+            open.push(token);
+            current += token;
+        }
+        else {
+            const parts = token.split('\n');
+            parts.forEach((part, i) => {
+                if (i > 0) {
+                    current += '</span>'.repeat(open.length);
+                    lines.push(current);
+                    current = open.join('');
+                }
+                current += part;
+            });
+        }
+    }
+    lines.push(current);
+    // A file that ends in a newline has no line after it, matching how the line
+    // count is taken elsewhere.
+    if (lines.length > 1 && lines[lines.length - 1] === '')
+        lines.pop();
+    return lines;
+}
+function isBinary(buf) {
+    const n = Math.min(buf.length, 8192);
+    for (let i = 0; i < n; i++) {
+        if (buf[i] === 0)
+            return true;
+    }
+    return false;
+}
+// Past a gigabyte the unit keeps going: a release asset or a day's outgoing
+// traffic is routinely larger than that, and "20480.0 MB" is a number a reader
+// has to divide before it means anything.
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    if (bytes < 1024 * 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+    return `${(bytes / (1024 * 1024 * 1024 * 1024)).toFixed(2)} TB`;
+}
+function formatDate(iso) {
+    if (!iso)
+        return '';
+    const d = new Date(iso);
+    if (isNaN(d.getTime()))
+        return iso;
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+/** "19 Aug 2026, 01:04" - the exact time, shown as the tooltip on a relative one. */
+function formatDateFull(iso) {
+    const d = new Date(iso);
+    if (!iso || isNaN(d.getTime()))
+        return iso;
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${d.getDate()} ${MONTHS[d.getMonth()]} ${d.getFullYear()}, ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+// Thresholds for timeAgo, coarsest last: below `limit` seconds, divide by
+// `secs` (rounding down, so an age never reads older than it is) and name the
+// unit. A dedicated "yesterday" sits between hours and days because that is
+// what the reader would say.
+const AGO_UNITS = [
+    { limit: 3600, secs: 60, unit: 'minute' },
+    { limit: 24 * 3600, secs: 3600, unit: 'hour' },
+    { limit: 30 * 86400, secs: 86400, unit: 'day' },
+    { limit: 365 * 86400, secs: 30 * 86400, unit: 'month' },
+    { limit: Infinity, secs: 365 * 86400, unit: 'year' },
+];
+/** "19 Aug 2026" - the day alone, for grouping a list by date. */
+function formatDay(iso) {
+    const d = new Date(iso);
+    if (!iso || isNaN(d.getTime()))
+        return iso;
+    return `${d.getDate()} ${MONTHS[d.getMonth()]} ${d.getFullYear()}`;
+}
+/**
+ * A relative time in words: "now", "3 minutes ago", "yesterday", "2 years
+ * ago". Dates the clock puts in the future (skew, or a rewritten commit) read
+ * as "in 3 minutes" rather than as an absurd age. The exact time is never
+ * lost: timeTag() keeps it in the tooltip and in the datetime attribute.
+ */
+function timeAgo(iso, now = new Date()) {
+    const d = new Date(iso);
+    if (!iso || isNaN(d.getTime()))
+        return iso;
+    const delta = (now.getTime() - d.getTime()) / 1000;
+    const secs = Math.abs(delta);
+    const future = delta < 0;
+    if (secs < 60)
+        return 'now';
+    if (!future && secs >= 24 * 3600 && secs < 48 * 3600)
+        return 'yesterday';
+    const step = AGO_UNITS.find((u) => secs < u.limit);
+    const n = Math.floor(secs / step.secs);
+    const phrase = `${n} ${step.unit}${n === 1 ? '' : 's'}`;
+    return future ? `in ${phrase}` : `${phrase} ago`;
+}
+/**
+ * A relative time as a <time> element, with the exact time in its tooltip.
+ * Rendering is server-side and so is the "now" it counts from, which is why
+ * the datetime attribute carries the original timestamp: a reader who wants
+ * precision hovers, and a machine reading the page gets ISO 8601.
+ */
+function timeTag(iso, cls = 'muted') {
+    if (!iso)
+        return (0, html_1.raw)('');
+    const d = new Date(iso);
+    if (isNaN(d.getTime()))
+        return (0, html_1.raw)((0, html_1.esc)(iso));
+    return (0, html_1.raw)(`<time class="${cls}" datetime="${(0, html_1.esc)(d.toISOString())}" title="${(0, html_1.esc)(formatDateFull(iso))}">${(0, html_1.esc)(timeAgo(iso))}</time>`);
+}