« get me outta code hell

hsmusic-wiki - HSMusic - static wiki software cataloguing collaborative creation
about summary refs log tree commit diff
path: root/upd8.js
diff options
context:
space:
mode:
Diffstat (limited to 'upd8.js')
-rwxr-xr-xupd8.js6597
1 files changed, 0 insertions, 6597 deletions
diff --git a/upd8.js b/upd8.js
deleted file mode 100755
index e17005dd..00000000
--- a/upd8.js
+++ /dev/null
@@ -1,6597 +0,0 @@
-#!/usr/bin/env node
-
-// HEY N8RDS!
-//
-// This is one of the 8ACKEND FILES. It's not used anywhere on the actual site
-// you are pro8a8ly using right now.
-//
-// Specifically, this one does all the actual work of the music wiki. The
-// process looks something like this:
-//
-//   1. Crawl the music directories. Well, not so much "crawl" as "look inside
-//      the folders for each al8um, and read the metadata file descri8ing that
-//      al8um and the tracks within."
-//
-//   2. Read that metadata. I'm writing this 8efore actually doing any of the
-//      code, and I've gotta admit I have no idea what file format they're
-//      going to 8e in. May8e JSON, 8ut more likely some weird custom format
-//      which will 8e a lot easier to edit.
-//
-//   3. Generate the page files! They're just static index.html files, and are
-//      what gh-pages (or wherever this is hosted) will show to clients.
-//      Hopefully pretty minimalistic HTML, 8ut like, shrug. They'll reference
-//      CSS (and maaaaaaaay8e JS) files, hard-coded somewhere near the root.
-//
-//   4. Print an awesome message which says the process is done. This is the
-//      most important step.
-//
-// Oh yeah, like. Just run this through some relatively recent version of
-// node.js and you'll 8e fine. ...Within the project root. O8viously.
-
-// HEY FUTURE ME!!!!!!!! Don't forget to implement artist pages! Those are,
-// like, the coolest idea you've had yet, so DO NOT FORGET. (Remem8er, link
-// from track listings, etc!) --- Thanks, past me. To futurerer me: an al8um
-// listing page (a list of all the al8ums)! Make sure to sort these 8y date -
-// we'll need a new field for al8ums.
-
-// ^^^^^^^^ DID THAT! 8ut also, artist images. Pro8a8ly stolen from the fandom
-// wiki (I found half those images anywayz).
-
-// TRACK ART CREDITS. This is a must.
-
-// 2020-08-23
-// ATTENTION ALL 8*TCHES AND OTHER GENDER TRUCKERS: AS IT TURNS OUT, THIS CODE
-// ****SUCKS****. I DON'T THINK ANYTHING WILL EVER REDEEM IT, 8UT THAT DOESN'T
-// MEAN WE CAN'T TAKE SOME ACTION TO MAKE WRITING IT A LITTLE LESS TERRI8LE.
-// We're gonna start defining STRUCTURES to make things suck less!!!!!!!!
-// No classes 8ecause those are a huge pain and like, pro8a8ly 8ad performance
-// or whatever -- just some standard structures that should 8e followed
-// wherever reasona8le. Only one I need today is the contri8 one 8ut let's put
-// any new general-purpose structures here too, ok?
-//
-// Contri8ution: {who, what, date, thing}. D8 and thing are the new fields.
-//
-// Use these wisely, which is to say all the time and instead of whatever
-// terri8le new pseudo structure you're trying to invent!!!!!!!!
-//
-// Upd8 2021-01-03: Soooooooo we didn't actually really end up using these,
-// lol? Well there's still only one anyway. Kinda ended up doing a 8ig refactor
-// of all the o8ject structures today. It's not *especially* relevant 8ut feels
-// worth mentioning? I'd get rid of this comment 8lock 8ut I like it too much!
-// Even though I haven't actually reread it, lol. 8ut yeah, hopefully in the
-// spirit of this "make things more consistent" attitude I 8rought up 8ack in
-// August, stuff's lookin' 8etter than ever now. W00t!
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const util = require('util');
-
-// I made this dependency myself! A long, long time ago. It is pro8a8ly my
-// most useful li8rary ever. I'm not sure 8esides me actually uses it, though.
-const fixWS = require('fix-whitespace');
-// Wait nevermind, I forgot a8out why-do-kids-love-the-taste-of-cinnamon-toast-
-// crunch. THAT is my 8est li8rary.
-
-// The require function just returns whatever the module exports, so there's
-// no reason you can't wrap it in some decorator right out of the 8ox. Which is
-// exactly what we do here.
-const mkdirp = util.promisify(require('mkdirp'));
-
-// It stands for "HTML Entities", apparently. Cursed.
-const he = require('he');
-
-// This is the dum8est name for a function possi8le. Like, SURE, fine, may8e
-// the UNIX people had some valid reason to go with the weird truncated
-// lowercased convention they did. 8ut Node didn't have to ALSO use that
-// convention! Would it have 8een so hard to just name the function something
-// like fs.readDirectory???????? No, it wouldn't have 8een.
-const readdir = util.promisify(fs.readdir);
-// 8ut okay, like, look at me. DOING THE SAME THING. See, *I* could have named
-// my promisified function differently, and yet I did not. I literally cannot
-// explain why. We are all used to following in the 8ad decisions of our
-// ancestors, and never never never never never never never consider that hey,
-// may8e we don't need to make the exact same decisions they did. Even when
-// we're perfectly aware th8t's exactly what we're doing! Programmers,
-// including me, are all pretty stupid.
-
-// 8ut I mean, come on. Look. Node decided to use readFile, instead of like,
-// what, cat? Why couldn't they rename readdir too???????? As Johannes Kepler
-// once so elegantly put it: "Shrug."
-const readFile = util.promisify(fs.readFile);
-const writeFile = util.promisify(fs.writeFile);
-const access = util.promisify(fs.access);
-const symlink = util.promisify(fs.symlink);
-const unlink = util.promisify(fs.unlink);
-
-const {
-    cacheOneArg,
-    call,
-    chunkByConditions,
-    chunkByProperties,
-    curry,
-    decorateTime,
-    filterEmptyLines,
-    joinNoOxford,
-    mapInPlace,
-    logWarn,
-    logInfo,
-    logError,
-    parseOptions,
-    progressPromiseAll,
-    queue,
-    s,
-    sortByName,
-    splitArray,
-    th,
-    unique,
-    withEntries
-} = require('./upd8-util');
-
-const genThumbs = require('./gen-thumbs');
-
-const C = require('./common/common');
-
-const CACHEBUST = 5;
-
-const WIKI_INFO_FILE = 'wiki-info.txt';
-const HOMEPAGE_INFO_FILE = 'homepage.txt';
-const ARTIST_DATA_FILE = 'artists.txt';
-const FLASH_DATA_FILE = 'flashes.txt';
-const NEWS_DATA_FILE = 'news.txt';
-const TAG_DATA_FILE = 'tags.txt';
-const GROUP_DATA_FILE = 'groups.txt';
-const STATIC_PAGE_DATA_FILE = 'static-pages.txt';
-const DEFAULT_STRINGS_FILE = 'strings-default.json';
-
-const CSS_FILE = 'site.css';
-
-// Shared varia8les! These are more efficient to access than a shared varia8le
-// (or at least I h8pe so), and are easier to pass across functions than a
-// 8unch of specific arguments.
-//
-// Upd8: Okay yeah these aren't actually any different. Still cleaner than
-// passing around a data object containing all this, though.
-let dataPath;
-let mediaPath;
-let langPath;
-let outputPath;
-
-let wikiInfo;
-let homepageInfo;
-let albumData;
-let trackData;
-let flashData;
-let flashActData;
-let newsData;
-let tagData;
-let groupData;
-let groupCategoryData;
-let staticPageData;
-
-let artistNames;
-let artistData;
-let artistAliasData;
-
-let officialAlbumData;
-let fandomAlbumData;
-let justEverythingMan; // tracks, albums, flashes -- don't forget to upd8 toAnythingMan!
-let justEverythingSortedByArtDateMan;
-let contributionData;
-
-let queueSize;
-
-let languages;
-
-const html = {
-    // Non-comprehensive. ::::P
-    selfClosingTags: ['br', 'img'],
-
-    // Pass to tag() as an attri8utes key to make tag() return a 8lank string
-    // if the provided content is empty. Useful for when you'll only 8e showing
-    // an element according to the presence of content that would 8elong there.
-    onlyIfContent: Symbol(),
-
-    tag(tagName, ...args) {
-        const selfClosing = html.selfClosingTags.includes(tagName);
-
-        let openTag;
-        let content;
-        let attrs;
-
-        if (typeof args[0] === 'object' && !Array.isArray(args[0])) {
-            attrs = args[0];
-            content = args[1];
-        } else {
-            content = args[0];
-        }
-
-        if (selfClosing && content) {
-            throw new Error(`Tag <${tagName}> is self-closing but got content!`);
-        }
-
-        if (attrs?.[html.onlyIfContent] && !content) {
-            return '';
-        }
-
-        if (attrs) {
-            const attrString = html.attributes(args[0]);
-            if (attrString) {
-                openTag = `${tagName} ${attrString}`;
-            }
-        }
-
-        if (!openTag) {
-            openTag = tagName;
-        }
-
-        if (Array.isArray(content)) {
-            content = content.filter(Boolean).join('\n');
-        }
-
-        if (content) {
-            if (content.includes('\n')) {
-                return fixWS`
-                    <${openTag}>
-                        ${content}
-                    </${tagName}>
-                `;
-            } else {
-                return `<${openTag}>${content}</${tagName}>`;
-            }
-        } else {
-            if (selfClosing) {
-                return `<${openTag}>`;
-            } else {
-                return `<${openTag}></${tagName}>`;
-            }
-        }
-    },
-
-    escapeAttributeValue(value) {
-        return value
-            .replaceAll('"', '&quot;')
-            .replaceAll("'", '&apos;');
-    },
-
-    attributes(attribs) {
-        return Object.entries(attribs)
-            .map(([ key, val ]) => {
-                if (!val)
-                    return [key, val];
-                else if (typeof val === 'string' || typeof val === 'boolean')
-                    return [key, val];
-                else if (typeof val === 'number')
-                    return [key, val.toString()];
-                else if (Array.isArray(val))
-                    return [key, val.join(' ')];
-                else
-                    throw new Error(`Attribute value for ${key} should be primitive or array, got ${typeof val}`);
-            })
-            .filter(([ key, val ]) => val)
-            .map(([ key, val ]) => (typeof val === 'boolean'
-                ? `${key}`
-                : `${key}="${html.escapeAttributeValue(val)}"`))
-            .join(' ');
-    }
-};
-
-const urlSpec = {
-    data: {
-        prefix: 'data/',
-
-        paths: {
-            root: '',
-            path: '<>',
-
-            album: 'album/<>',
-            artist: 'artist/<>',
-            track: 'track/<>'
-        }
-    },
-
-    localized: {
-        // TODO: Implement this.
-        // prefix: '_languageCode',
-
-        paths: {
-            root: '',
-            path: '<>',
-
-            home: '',
-
-            album: 'album/<>/',
-            albumCommentary: 'commentary/album/<>/',
-
-            artist: 'artist/<>/',
-            artistGallery: 'artist/<>/gallery/',
-
-            commentaryIndex: 'commentary/',
-
-            flashIndex: 'flash/',
-            flash: 'flash/<>/',
-
-            groupInfo: 'group/<>/',
-            groupGallery: 'group/<>/gallery/',
-
-            listingIndex: 'list/',
-            listing: 'list/<>/',
-
-            newsIndex: 'news/',
-            newsEntry: 'news/<>/',
-
-            staticPage: '<>/',
-            tag: 'tag/<>/',
-            track: 'track/<>/'
-        }
-    },
-
-    shared: {
-        paths: {
-            root: '',
-            path: '<>',
-
-            commonFile: 'common/<>',
-            staticFile: 'static/<>'
-        }
-    },
-
-    media: {
-        prefix: 'media/',
-
-        paths: {
-            root: '',
-            path: '<>',
-
-            albumCover: 'album-art/<>/cover.jpg',
-            albumWallpaper: 'album-art/<>/bg.jpg',
-            albumBanner: 'album-art/<>/banner.jpg',
-            trackCover: 'album-art/<>/<>.jpg',
-            artistAvatar: 'artist-avatar/<>.jpg',
-            flashArt: 'flash-art/<>.jpg'
-        }
-    }
-};
-
-// This gets automatically switched in place when working from a baseDirectory,
-// so it should never be referenced manually.
-urlSpec.localizedWithBaseDirectory = {
-    paths: withEntries(
-        urlSpec.localized.paths,
-        entries => entries.map(([key, path]) => [key, '<>/' + path])
-    )
-};
-
-const linkHelper = (hrefFn, {color = true, attr = null} = {}) =>
-    (thing, {
-        strings, to,
-        text = '',
-        class: className = '',
-        hash = ''
-    }) => (
-        html.tag('a', {
-            ...attr ? attr(thing) : {},
-            href: hrefFn(thing, {to}) + (hash ? (hash.startsWith('#') ? '' : '#') + hash : ''),
-            style: color ? getLinkThemeString(thing) : '',
-            class: className
-        }, text || thing.name)
-    );
-
-const linkDirectory = (key, {expose = null, attr = null, ...conf} = {}) =>
-    linkHelper((thing, {to}) => to('localized.' + key, thing.directory), {
-        attr: thing => ({
-            ...attr ? attr(thing) : {},
-            ...expose ? {[expose]: thing.directory} : {}
-        }),
-        ...conf
-    });
-
-const linkPathname = (key, conf) => linkHelper(({directory: pathname}, {to}) => to(key, pathname), conf);
-const linkIndex = (key, conf) => linkHelper((_, {to}) => to('localized.' + key), conf);
-
-const link = {
-    album: linkDirectory('album'),
-    albumCommentary: linkDirectory('albumCommentary'),
-    artist: linkDirectory('artist', {color: false}),
-    artistGallery: linkDirectory('artistGallery', {color: false}),
-    commentaryIndex: linkIndex('commentaryIndex', {color: false}),
-    flashIndex: linkIndex('flashIndex', {color: false}),
-    flash: linkDirectory('flash'),
-    groupInfo: linkDirectory('groupInfo'),
-    groupGallery: linkDirectory('groupGallery'),
-    home: linkIndex('home', {color: false}),
-    listingIndex: linkIndex('listingIndex'),
-    listing: linkDirectory('listing'),
-    newsIndex: linkIndex('newsIndex', {color: false}),
-    newsEntry: linkDirectory('newsEntry', {color: false}),
-    staticPage: linkDirectory('staticPage', {color: false}),
-    tag: linkDirectory('tag'),
-    track: linkDirectory('track', {expose: 'data-track'}),
-
-    media: linkPathname('media.path', {color: false}),
-    root: linkPathname('shared.path', {color: false}),
-    data: linkPathname('data.path', {color: false}),
-    site: linkPathname('localized.path', {color: false})
-};
-
-const thumbnailHelper = name => file =>
-    file.replace(/\.(jpg|png)$/, name + '.jpg');
-
-const thumb = {
-    medium: thumbnailHelper('.medium'),
-    small: thumbnailHelper('.small')
-};
-
-function generateURLs(fromPath) {
-    const getValueForFullKey = (obj, fullKey, prop = null) => {
-        const [ groupKey, subKey ] = fullKey.split('.');
-        if (!groupKey || !subKey) {
-            throw new Error(`Expected group key and subkey (got ${fullKey})`);
-        }
-
-        if (!obj.hasOwnProperty(groupKey)) {
-            throw new Error(`Expected valid group key (got ${groupKey})`);
-        }
-
-        const group = obj[groupKey];
-
-        if (!group.hasOwnProperty(subKey)) {
-            throw new Error(`Expected valid subkey (got ${subKey} for group ${groupKey})`);
-        }
-
-        return {
-            value: group[subKey],
-            group
-        };
-    };
-
-    const generateTo = (fromPath, fromGroup) => {
-        const rebasePrefix = '../'.repeat((fromGroup.prefix || '').split('/').filter(Boolean).length);
-
-        const pathHelper = (toPath, toGroup) => {
-            let target = toPath;
-
-            let argIndex = 0;
-            target = target.replaceAll('<>', () => `<${argIndex++}>`);
-
-            if (toGroup.prefix !== fromGroup.prefix) {
-                // TODO: Handle differing domains in prefixes.
-                target = rebasePrefix + (toGroup.prefix || '') + target;
-            }
-
-            return (path.relative(fromPath, target)
-                + (toPath.endsWith('/') ? '/' : ''));
-        };
-
-        const groupSymbol = Symbol();
-
-        const groupHelper = urlGroup => ({
-            [groupSymbol]: urlGroup,
-            ...withEntries(urlGroup.paths, entries => entries
-                .map(([key, path]) => [key, pathHelper(path, urlGroup)]))
-        });
-
-        const relative = withEntries(urlSpec, entries => entries
-            .map(([key, urlGroup]) => [key, groupHelper(urlGroup)]));
-
-        const to = (key, ...args) => {
-            const { value: template, group: {[groupSymbol]: toGroup} } = getValueForFullKey(relative, key)
-            let result = template.replaceAll(/<([0-9]+)>/g, (match, n) => args[n]);
-
-            // Kinda hacky lol, 8ut it works.
-            const missing = result.match(/<([0-9]+)>/g);
-            if (missing) {
-                throw new Error(`Expected ${missing[missing.length - 1]} arguments, got ${args.length}`);
-            }
-
-            return result;
-        };
-
-        return {to, relative};
-    };
-
-    const generateFrom = () => {
-        const map = withEntries(urlSpec, entries => entries
-            .map(([key, group]) => [key, withEntries(group.paths, entries => entries
-                .map(([key, path]) => [key, generateTo(path, group)])
-            )]));
-
-        const from = key => getValueForFullKey(map, key).value;
-
-        return {from, map};
-    };
-
-    return generateFrom();
-}
-
-const urls = generateURLs();
-
-const searchHelper = (keys, dataFn, findFn) => ref => {
-    if (!ref) return null;
-    ref = ref.replace(new RegExp(`^(${keys.join('|')}):`), '');
-    const found = findFn(ref, dataFn());
-    if (!found) {
-        logWarn`Didn't match anything for ${ref}! (${keys.join(', ')})`;
-    }
-    return found;
-};
-
-const matchDirectory = (ref, data) => data.find(({ directory }) => directory === ref);
-
-const matchDirectoryOrName = (ref, data) => {
-    let thing;
-
-    thing = matchDirectory(ref, data);
-    if (thing) return thing;
-
-    thing = data.find(({ name }) => name === ref);
-    if (thing) return thing;
-
-    thing = data.find(({ name }) => name.toLowerCase() === ref.toLowerCase());
-    if (thing) {
-        logWarn`Bad capitalization: ${'\x1b[31m' + ref} -> ${'\x1b[32m' + thing.name}`;
-        return thing;
-    }
-
-    return null;
-};
-
-const search = {
-    album: searchHelper(['album', 'album-commentary'], () => albumData, matchDirectoryOrName),
-    artist: searchHelper(['artist', 'artist-gallery'], () => artistData, matchDirectoryOrName),
-    flash: searchHelper(['flash'], () => flashData, matchDirectory),
-    group: searchHelper(['group', 'group-gallery'], () => groupData, matchDirectoryOrName),
-    listing: searchHelper(['listing'], () => listingSpec, matchDirectory),
-    newsEntry: searchHelper(['news-entry'], () => newsData, matchDirectory),
-    staticPage: searchHelper(['static'], () => staticPageData, matchDirectory),
-    tag: searchHelper(['tag'], () => tagData, (ref, data) =>
-        matchDirectoryOrName(ref.startsWith('cw: ') ? ref.slice(4) : ref, data)),
-    track: searchHelper(['track'], () => trackData, matchDirectoryOrName)
-};
-
-// Localiz8tion time! Or l10n as the neeeeeeeerds call it. Which is a terri8le
-// name and not one I intend on using, thank you very much. (Don't even get me
-// started on """"a11y"""".)
-//
-// All the default strings are in strings-default.json, if you're curious what
-// those actually look like. Pretty much it's "I like {ANIMAL}" for example.
-// For each language, the o8ject gets turned into a single function of form
-// f(key, {args}). It searches for a key in the o8ject and uses the string it
-// finds (or the one in strings-default.json) as a templ8 evaluated with the
-// arguments passed. (This function gets treated as an o8ject too; it gets
-// the language code attached.)
-//
-// The function's also responsi8le for getting rid of dangerous characters
-// (quotes and angle tags), though only within the templ8te (not the args),
-// and it converts the keys of the arguments o8ject from camelCase to
-// CONSTANT_CASE too.
-function genStrings(stringsJSON, defaultJSON = null) {
-    // genStrings will only 8e called once for each language, and it happens
-    // right at the start of the program (or at least 8efore 8uilding pages).
-    // So, now's a good time to valid8te the strings and let any warnings be
-    // known.
-
-    // May8e contrary to the argument name, the arguments should 8e o8jects,
-    // not actual JSON-formatted strings!
-    if (typeof stringsJSON !== 'object' || stringsJSON.constructor !== Object) {
-        return {error: `Expected an object (parsed JSON) for stringsJSON.`};
-    }
-    if (typeof defaultJSON !== 'object') { // typeof null === object. I h8 JS.
-        return {error: `Expected an object (parsed JSON) or null for defaultJSON.`};
-    }
-
-    // All languages require a language code.
-    const code = stringsJSON['meta.languageCode'];
-    if (!code) {
-        return {error: `Missing language code.`};
-    }
-    if (typeof code !== 'string') {
-        return {error: `Expected language code to be a string.`};
-    }
-
-    // Every value on the provided o8ject should be a string.
-    // (This is lazy, but we only 8other checking this on stringsJSON, on the
-    // assumption that defaultJSON was passed through this function too, and so
-    // has already been valid8ted.)
-    {
-        let err = false;
-        for (const [ key, value ] of Object.entries(stringsJSON)) {
-            if (typeof value !== 'string') {
-                logError`(${code}) The value for ${key} should be a string.`;
-                err = true;
-            }
-        }
-        if (err) {
-            return {error: `Expected all values to be a string.`};
-        }
-    }
-
-    // Checking is generally done against the default JSON, so we'll skip out
-    // if that isn't provided (which should only 8e the case when it itself is
-    // 8eing processed as the first loaded language).
-    if (defaultJSON) {
-        // Warn for keys that are missing or unexpected.
-        const expectedKeys = Object.keys(defaultJSON);
-        const presentKeys = Object.keys(stringsJSON);
-        for (const key of presentKeys) {
-            if (!expectedKeys.includes(key)) {
-                logWarn`(${code}) Unexpected translation key: ${key} - this won't be used!`;
-            }
-        }
-        for (const key of expectedKeys) {
-            if (!presentKeys.includes(key)) {
-                logWarn`(${code}) Missing translation key: ${key} - this won't be localized!`;
-            }
-        }
-    }
-
-    // Valid8tion is complete, 8ut We can still do a little caching to make
-    // repeated actions faster.
-
-    // We're gonna 8e mut8ting the strings dictionary o8ject from here on out.
-    // We make a copy so we don't mess with the one which was given to us.
-    stringsJSON = Object.assign({}, stringsJSON);
-
-    // Preemptively pass everything through HTML encoding. This will prevent
-    // strings from embedding HTML tags or accidentally including characters
-    // that throw HTML parsers off.
-    for (const key of Object.keys(stringsJSON)) {
-        stringsJSON[key] = he.encode(stringsJSON[key], {useNamedReferences: true});
-    }
-
-    // It's time to cre8te the actual langauge function!
-
-    // In the function, we don't actually distinguish 8etween the primary and
-    // default (fall8ack) strings - any relevant warnings have already 8een
-    // presented a8ove, at the time the language JSON is processed. Now we'll
-    // only 8e using them for indexing strings to use as templ8tes, and we can
-    // com8ine them for that.
-    const stringIndex = Object.assign({}, defaultJSON, stringsJSON);
-
-    // We do still need the list of valid keys though. That's 8ased upon the
-    // default strings. (Or stringsJSON, 8ut only if the defaults aren't
-    // provided - which indic8tes that the single o8ject provided *is* the
-    // default.)
-    const validKeys = Object.keys(defaultJSON || stringsJSON);
-
-    const invalidKeysFound = [];
-
-    const strings = (key, args = {}) => {
-        // Ok, with the warning out of the way, it's time to get to work.
-        // First make sure we're even accessing a valid key. (If not, return
-        // an error string as su8stitute.)
-        if (!validKeys.includes(key)) {
-            // We only want to warn a8out a given key once. More than that is
-            // just redundant!
-            if (!invalidKeysFound.includes(key)) {
-                invalidKeysFound.push(key);
-                logError`(${code}) Accessing invalid key ${key}. Fix a typo or provide this in strings-default.json!`;
-            }
-            return `MISSING: ${key}`;
-        }
-
-        const template = stringIndex[key];
-
-        // Convert the keys on the args dict from camelCase to CONSTANT_CASE.
-        // (This isn't an OUTRAGEOUSLY versatile algorithm for doing that, 8ut
-        // like, who cares, dude?) Also, this is an array, 8ecause it's handy
-        // for the iterating we're a8out to do.
-        const processedArgs = Object.entries(args)
-            .map(([ k, v ]) => [k.replace(/[A-Z]/g, '_$&').toUpperCase(), v]);
-
-        // Replacement time! Woot. Reduce comes in handy here!
-        const output = processedArgs.reduce(
-            (x, [ k, v ]) => x.replaceAll(`{${k}}`, v),
-            template);
-
-        // Post-processing: if any expected arguments *weren't* replaced, that
-        // is almost definitely an error.
-        if (output.match(/\{[A-Z_]+\}/)) {
-            logError`(${code}) Args in ${key} were missing - output: ${output}`;
-        }
-
-        return output;
-    };
-
-    // And lastly, we add some utility stuff to the strings function.
-
-    // Store the language code, for convenience of access.
-    strings.code = code;
-
-    // Store the strings dictionary itself, also for convenience.
-    strings.json = stringsJSON;
-
-    // Store Intl o8jects that can 8e reused for value formatting.
-    strings.intl = {
-        date: new Intl.DateTimeFormat(code, {full: true}),
-        number: new Intl.NumberFormat(code),
-        list: {
-            conjunction: new Intl.ListFormat(code, {type: 'conjunction'}),
-            disjunction: new Intl.ListFormat(code, {type: 'disjunction'}),
-            unit: new Intl.ListFormat(code, {type: 'unit'})
-        },
-        plural: {
-            cardinal: new Intl.PluralRules(code, {type: 'cardinal'}),
-            ordinal: new Intl.PluralRules(code, {type: 'ordinal'})
-        }
-    };
-
-    const bindUtilities = (obj, bind) => Object.fromEntries(Object.entries(obj).map(
-        ([ key, fn ]) => [key, (value, opts = {}) => fn(value, {...bind, ...opts})]
-    ));
-
-    // There are a 8unch of handy count functions which expect a strings value;
-    // for a more terse syntax, we'll stick 'em on the strings function itself,
-    // with automatic 8inding for the strings argument.
-    strings.count = bindUtilities(count, {strings});
-
-    // The link functions also expect the strings o8ject(*). May as well hand
-    // 'em over here too! Keep in mind they still expect {to} though, and that
-    // isn't something we have access to from this scope (so calls such as
-    // strings.link.album(...) still need to provide it themselves).
-    //
-    // (*) At time of writing, it isn't actually used for anything, 8ut future-
-    // proofing, ok????????
-    strings.link = bindUtilities(link, {strings});
-
-    // List functions, too!
-    strings.list = bindUtilities(list, {strings});
-
-    return strings;
-};
-
-const countHelper = (stringKey, argName = stringKey) => (value, {strings, unit = false}) => strings(
-    (unit
-        ? `count.${stringKey}.withUnit.` + strings.intl.plural.cardinal.select(value)
-        : `count.${stringKey}`),
-    {[argName]: strings.intl.number.format(value)});
-
-const count = {
-    date: (date, {strings}) => {
-        return strings.intl.date.format(date);
-    },
-
-    dateRange: ([startDate, endDate], {strings}) => {
-        return strings.intl.date.formatRange(startDate, endDate);
-    },
-
-    duration: (secTotal, {strings, approximate = false, unit = false}) => {
-        if (secTotal === 0) {
-            return strings('count.duration.missing');
-        }
-
-        const hour = Math.floor(secTotal / 3600);
-        const min = Math.floor((secTotal - hour * 3600) / 60);
-        const sec = Math.floor(secTotal - hour * 3600 - min * 60);
-
-        const pad = val => val.toString().padStart(2, '0');
-
-        const stringSubkey = unit ? '.withUnit' : '';
-
-        const duration = (hour > 0
-            ? strings('count.duration.hours' + stringSubkey, {
-                hours: hour,
-                minutes: pad(min),
-                seconds: pad(sec)
-            })
-            : strings('count.duration.minutes' + stringSubkey, {
-                minutes: min,
-                seconds: pad(sec)
-            }));
-
-        return (approximate
-            ? strings('count.duration.approximate', {duration})
-            : duration);
-    },
-
-    index: (value, {strings}) => {
-        return strings('count.index.' + strings.intl.plural.ordinal.select(value), {index: value});
-    },
-
-    number: value => strings.intl.number.format(value),
-
-    words: (value, {strings, unit = false}) => {
-        const num = strings.intl.number.format(value > 1000
-            ? Math.floor(value / 100) / 10
-            : value);
-
-        const words = (value > 1000
-            ? strings('count.words.thousand', {words: num})
-            : strings('count.words', {words: num}));
-
-        return strings('count.words.withUnit.' + strings.intl.plural.cardinal.select(value), {words});
-    },
-
-    albums: countHelper('albums'),
-    commentaryEntries: countHelper('commentaryEntries', 'entries'),
-    contributions: countHelper('contributions'),
-    coverArts: countHelper('coverArts'),
-    timesReferenced: countHelper('timesReferenced'),
-    timesUsed: countHelper('timesUsed'),
-    tracks: countHelper('tracks')
-};
-
-const listHelper = type => (list, {strings}) => strings.intl.list[type].format(list);
-
-const list = {
-    unit: listHelper('unit'),
-    or: listHelper('disjunction'),
-    and: listHelper('conjunction')
-};
-
-// Note there isn't a 'find track data files' function. I plan on including the
-// data for all tracks within an al8um collected in the single metadata file
-// for that al8um. Otherwise there'll just 8e way too many files, and I'd also
-// have to worry a8out linking track files to al8um files (which would contain
-// only the track listing, not track data itself), and dealing with errors of
-// missing track files (or track files which are not linked to al8ums). All a
-// 8unch of stuff that's a pain to deal with for no apparent 8enefit.
-async function findFiles(dataPath, filter = f => true) {
-    return (await readdir(dataPath))
-        .map(file => path.join(dataPath, file))
-        .filter(file => filter(file));
-}
-
-function* getSections(lines) {
-    // ::::)
-    const isSeparatorLine = line => /^-{8,}$/.test(line);
-    yield* splitArray(lines, isSeparatorLine);
-}
-
-function getBasicField(lines, name) {
-    const line = lines.find(line => line.startsWith(name + ':'));
-    return line && line.slice(name.length + 1).trim();
-}
-
-function getBooleanField(lines, name) {
-    // The ?? oper8tor (which is just, hilariously named, lol) can 8e used to
-    // specify a default!
-    const value = getBasicField(lines, name);
-    switch (value) {
-        case 'yes':
-        case 'true':
-            return true;
-        case 'no':
-        case 'false':
-            return false;
-        default:
-            return null;
-    }
-}
-
-function getListField(lines, name) {
-    let startIndex = lines.findIndex(line => line.startsWith(name + ':'));
-    // If callers want to default to an empty array, they should stick
-    // "|| []" after the call.
-    if (startIndex === -1) {
-        return null;
-    }
-    // We increment startIndex 8ecause we don't want to include the
-    // "heading" line (e.g. "URLs:") in the actual data.
-    startIndex++;
-    let endIndex = lines.findIndex((line, index) => index >= startIndex && !line.startsWith('- '));
-    if (endIndex === -1) {
-        endIndex = lines.length;
-    }
-    if (endIndex === startIndex) {
-        // If there is no list that comes after the heading line, treat the
-        // heading line itself as the comma-separ8ted array value, using
-        // the 8asic field function to do that. (It's l8 and my 8rain is
-        // sleepy. Please excuse any unhelpful comments I may write, or may
-        // have already written, in this st8. Thanks!)
-        const value = getBasicField(lines, name);
-        return value && value.split(',').map(val => val.trim());
-    }
-    const listLines = lines.slice(startIndex, endIndex);
-    return listLines.map(line => line.slice(2));
-};
-
-function getContributionField(section, name) {
-    let contributors = getListField(section, name);
-
-    if (!contributors) {
-        return null;
-    }
-
-    if (contributors.length === 1 && contributors[0].startsWith('<i>')) {
-        const arr = [];
-        arr.textContent = contributors[0];
-        return arr;
-    }
-
-    contributors = contributors.map(contrib => {
-        // 8asically, the format is "Who (What)", or just "Who". 8e sure to
-        // keep in mind that "what" doesn't necessarily have a value!
-        const match = contrib.match(/^(.*?)( \((.*)\))?$/);
-        if (!match) {
-            return contrib;
-        }
-        const who = match[1];
-        const what = match[3] || null;
-        return {who, what};
-    });
-
-    const badContributor = contributors.find(val => typeof val === 'string');
-    if (badContributor) {
-        return {error: `An entry has an incorrectly formatted contributor, "${badContributor}".`};
-    }
-
-    if (contributors.length === 1 && contributors[0].who === 'none') {
-        return null;
-    }
-
-    return contributors;
-};
-
-function getMultilineField(lines, name) {
-    // All this code is 8asically the same as the getListText - just with a
-    // different line prefix (four spaces instead of a dash and a space).
-    let startIndex = lines.findIndex(line => line.startsWith(name + ':'));
-    if (startIndex === -1) {
-        return null;
-    }
-    startIndex++;
-    let endIndex = lines.findIndex((line, index) => index >= startIndex && line.length && !line.startsWith('    '));
-    if (endIndex === -1) {
-        endIndex = lines.length;
-    }
-    // If there aren't any content lines, don't return anything!
-    if (endIndex === startIndex) {
-        return null;
-    }
-    // We also join the lines instead of returning an array.
-    const listLines = lines.slice(startIndex, endIndex);
-    return listLines.map(line => line.slice(4)).join('\n');
-};
-
-const replacerSpec = {
-    'album': {
-        search: 'album',
-        link: 'album'
-    },
-    'album-commentary': {
-        search: 'album',
-        link: 'albumCommentary'
-    },
-    'artist': {
-        search: 'artist',
-        link: 'artist'
-    },
-    'artist-gallery': {
-        search: 'artist',
-        link: 'artistGallery'
-    },
-    'commentary-index': {
-        search: null,
-        link: 'commentaryIndex'
-    },
-    'date': {
-        search: null,
-        value: ref => new Date(ref),
-        html: (date, {strings}) => `<time datetime="${date.toString()}">${strings.count.date(date)}</time>`
-    },
-    'flash': {
-        search: 'flash',
-        link: 'flash',
-        transformName(name, search, offset, text) {
-            const nextCharacter = text[offset + search.length];
-            const lastCharacter = name[name.length - 1];
-            if (
-                ![' ', '\n', '<'].includes(nextCharacter) &&
-                lastCharacter === '.'
-            ) {
-                return name.slice(0, -1);
-            } else {
-                return name;
-            }
-        }
-    },
-    'group': {
-        search: 'group',
-        link: 'groupInfo'
-    },
-    'group-gallery': {
-        search: 'group',
-        link: 'groupGallery'
-    },
-    'listing-index': {
-        search: null,
-        link: 'listingIndex'
-    },
-    'listing': {
-        search: 'listing',
-        link: 'listing'
-    },
-    'media': {
-        search: null,
-        link: 'media'
-    },
-    'news-index': {
-        search: null,
-        link: 'newsIndex'
-    },
-    'news-entry': {
-        search: 'newsEntry',
-        link: 'newsEntry'
-    },
-    'root': {
-        search: null,
-        link: 'root'
-    },
-    'site': {
-        search: null,
-        link: 'site'
-    },
-    'static': {
-        search: 'staticPage',
-        link: 'staticPage'
-    },
-    'tag': {
-        search: 'tag',
-        link: 'tag'
-    },
-    'track': {
-        search: 'track',
-        link: 'track'
-    }
-};
-
-{
-    let error = false;
-    for (const [key, {link: linkKey, search: searchKey, value, html}] of Object.entries(replacerSpec)) {
-        if (!html && !link[linkKey]) {
-            logError`The replacer spec ${key} has invalid link key ${linkKey}! Specify it in link specs or fix typo.`;
-            error = true;
-        }
-        if (searchKey && !search[searchKey]) {
-            logError`The replacer spec ${key} has invalid search key ${searchKey}! Specify it in search specs or fix typo.`;
-            error = true;
-        }
-    }
-    if (error) process.exit();
-
-    const categoryPart = Object.keys(replacerSpec).join('|');
-    transformInline.regexp = new RegExp(String.raw`(?<!\\)\[\[((${categoryPart}):)?(.+?)((?<! )#.+?)?(\|(.+?))?\]\]`, 'g');
-}
-
-function transformInline(text, {strings, to}) {
-    return text.replace(transformInline.regexp, (match, _1, category, ref, hash, _2, enteredName, offset) => {
-        if (!category) {
-            category = 'track';
-        }
-
-        const {
-            search: searchKey,
-            link: linkKey,
-            value: valueFn,
-            html: htmlFn,
-            transformName
-        } = replacerSpec[category];
-
-        const value = (
-            valueFn ? valueFn(ref) :
-            searchKey ? search[searchKey](ref) :
-            {
-                directory: ref.replace(category + ':', ''),
-                name: null
-            });
-
-        if (!value) {
-            logWarn`The link ${match} does not match anything!`;
-            return match;
-        }
-
-        const label = (enteredName
-            || transformName && transformName(value.name, match, offset, text)
-            || value.name);
-
-        if (!valueFn && !label) {
-            logWarn`The link ${match} requires a label be entered!`;
-            return match;
-        }
-
-        const fn = (htmlFn
-            ? htmlFn
-            : strings.link[linkKey]);
-
-        try {
-            return fn(value, {text: label, hash, strings, to});
-        } catch (error) {
-            logError`The link ${match} failed to be processed: ${error}`;
-            return match;
-        }
-    }).replaceAll(String.raw`\[[`, '[[');
-}
-
-function parseAttributes(string, {to}) {
-    const attributes = Object.create(null);
-    const skipWhitespace = i => {
-        const ws = /\s/;
-        if (ws.test(string[i])) {
-            const match = string.slice(i).match(/[^\s]/);
-            if (match) {
-                return i + match.index;
-            } else {
-                return string.length;
-            }
-        } else {
-            return i;
-        }
-    };
-
-    for (let i = 0; i < string.length;) {
-        i = skipWhitespace(i);
-        const aStart = i;
-        const aEnd = i + string.slice(i).match(/[\s=]|$/).index;
-        const attribute = string.slice(aStart, aEnd);
-        i = skipWhitespace(aEnd);
-        if (string[i] === '=') {
-            i = skipWhitespace(i + 1);
-            let end, endOffset;
-            if (string[i] === '"' || string[i] === "'") {
-                end = string[i];
-                endOffset = 1;
-                i++;
-            } else {
-                end = '\\s';
-                endOffset = 0;
-            }
-            const vStart = i;
-            const vEnd = i + string.slice(i).match(new RegExp(`${end}|$`)).index;
-            const value = string.slice(vStart, vEnd);
-            i = vEnd + endOffset;
-            if (attribute === 'src' && value.startsWith('media/')) {
-                attributes[attribute] = to('media.path', value.slice('media/'.length));
-            } else {
-                attributes[attribute] = value;
-            }
-        } else {
-            attributes[attribute] = attribute;
-        }
-    }
-    return Object.fromEntries(Object.entries(attributes).map(([ key, val ]) => [
-        key,
-        val === 'true' ? true :
-        val === 'false' ? false :
-        val === key ? true :
-        val
-    ]));
-}
-
-function transformMultiline(text, {strings, to}) {
-    // Heck yes, HTML magics.
-
-    text = transformInline(text.trim(), {strings, to});
-
-    const outLines = [];
-
-    const indentString = ' '.repeat(4);
-
-    let levelIndents = [];
-    const openLevel = indent => {
-        // opening a sublist is a pain: to be semantically *and* visually
-        // correct, we have to append the <ul> at the end of the existing
-        // previous <li>
-        const previousLine = outLines[outLines.length - 1];
-        if (previousLine?.endsWith('</li>')) {
-            // we will re-close the <li> later
-            outLines[outLines.length - 1] = previousLine.slice(0, -5) + ' <ul>';
-        } else {
-            // if the previous line isn't a list item, this is the opening of
-            // the first list level, so no need for indent
-            outLines.push('<ul>');
-        }
-        levelIndents.push(indent);
-    };
-    const closeLevel = () => {
-        levelIndents.pop();
-        if (levelIndents.length) {
-            // closing a sublist, so close the list item containing it too
-            outLines.push(indentString.repeat(levelIndents.length) + '</ul></li>');
-        } else {
-            // closing the final list level! no need for indent here
-            outLines.push('</ul>');
-        }
-    };
-
-    // okay yes we should support nested formatting, more than one blockquote
-    // layer, etc, but hear me out here: making all that work would basically
-    // be the same as implementing an entire markdown converter, which im not
-    // interested in doing lol. sorry!!!
-    let inBlockquote = false;
-
-    for (let line of text.split(/\r|\n|\r\n/)) {
-        const imageLine = line.startsWith('<img');
-        line = line.replace(/<img (.*?)>/g, (match, attributes) => img({
-            lazy: true,
-            link: true,
-            thumb: 'medium',
-            ...parseAttributes(attributes, {to})
-        }));
-
-        let indentThisLine = 0;
-        let lineContent = line;
-        let lineTag = 'p';
-
-        const listMatch = line.match(/^( *)- *(.*)$/);
-        if (listMatch) {
-            // is a list item!
-            if (!levelIndents.length) {
-                // first level is always indent = 0, regardless of actual line
-                // content (this is to avoid going to a lesser indent than the
-                // initial level)
-                openLevel(0);
-            } else {
-                // find level corresponding to indent
-                const indent = listMatch[1].length;
-                let i;
-                for (i = levelIndents.length - 1; i >= 0; i--) {
-                    if (levelIndents[i] <= indent) break;
-                }
-                // note: i cannot equal -1 because the first indentation level
-                // is always 0, and the minimum indentation is also 0
-                if (levelIndents[i] === indent) {
-                    // same indent! return to that level
-                    while (levelIndents.length - 1 > i) closeLevel();
-                    // (if this is already the current level, the above loop
-                    // will do nothing)
-                } else if (levelIndents[i] < indent) {
-                    // lesser indent! branch based on index
-                    if (i === levelIndents.length - 1) {
-                        // top level is lesser: add a new level
-                        openLevel(indent);
-                    } else {
-                        // lower level is lesser: return to that level
-                        while (levelIndents.length - 1 > i) closeLevel();
-                    }
-                }
-            }
-            // finally, set variables for appending content line
-            indentThisLine = levelIndents.length;
-            lineContent = listMatch[2];
-            lineTag = 'li';
-        } else {
-            // not a list item! close any existing list levels
-            while (levelIndents.length) closeLevel();
-
-            // like i said, no nested shenanigans - quotes only appear outside
-            // of lists. sorry!
-            const quoteMatch = line.match(/^> *(.*)$/);
-            if (quoteMatch) {
-                // is a quote! open a blockquote tag if it doesnt already exist
-                if (!inBlockquote) {
-                    inBlockquote = true;
-                    outLines.push('<blockquote>');
-                }
-                indentThisLine = 1;
-                lineContent = quoteMatch[1];
-            } else if (inBlockquote) {
-                // not a quote! close a blockquote tag if it exists
-                inBlockquote = false;
-                outLines.push('</blockquote>');
-            }
-        }
-
-        if (lineTag === 'p') {
-            // certain inline element tags should still be postioned within a
-            // paragraph; other elements (e.g. headings) should be added as-is
-            const elementMatch = line.match(/^<(.*?)[ >]/);
-            if (elementMatch && !imageLine && !['a', 'abbr', 'b', 'bdo', 'br', 'cite', 'code', 'data', 'datalist', 'del', 'dfn', 'em', 'i', 'img', 'ins', 'kbd', 'mark', 'output', 'picture', 'q', 'ruby', 'samp', 'small', 'span', 'strong', 'sub', 'sup', 'svg', 'time', 'var', 'wbr'].includes(elementMatch[1])) {
-                lineTag = '';
-            }
-        }
-
-        let pushString = indentString.repeat(indentThisLine);
-        if (lineTag) {
-            pushString += `<${lineTag}>${lineContent}</${lineTag}>`;
-        } else {
-            pushString += lineContent;
-        }
-        outLines.push(pushString);
-    }
-
-    // after processing all lines...
-
-    // if still in a list, close all levels
-    while (levelIndents.length) closeLevel();
-
-    // if still in a blockquote, close its tag
-    if (inBlockquote) {
-        inBlockquote = false;
-        outLines.push('</blockquote>');
-    }
-
-    return outLines.join('\n');
-}
-
-function transformLyrics(text, {strings, to}) {
-    // Different from transformMultiline 'cuz it joins multiple lines together
-    // with line 8reaks (<br>); transformMultiline treats each line as its own
-    // complete paragraph (or list, etc).
-
-    // If it looks like old data, then like, oh god.
-    // Use the normal transformMultiline tool.
-    if (text.includes('<br')) {
-        return transformMultiline(text, {strings, to});
-    }
-
-    text = transformInline(text.trim(), {strings, to});
-
-    let buildLine = '';
-    const addLine = () => outLines.push(`<p>${buildLine}</p>`);
-    const outLines = [];
-    for (const line of text.split('\n')) {
-        if (line.length) {
-            if (buildLine.length) {
-                buildLine += '<br>';
-            }
-            buildLine += line;
-        } else if (buildLine.length) {
-            addLine();
-            buildLine = '';
-        }
-    }
-    if (buildLine.length) {
-        addLine();
-    }
-    return outLines.join('\n');
-}
-
-function getCommentaryField(lines) {
-    const text = getMultilineField(lines, 'Commentary');
-    if (text) {
-        const lines = text.split('\n');
-        if (!lines[0].replace(/<\/b>/g, '').includes(':</i>')) {
-            return {error: `An entry is missing commentary citation: "${lines[0].slice(0, 40)}..."`};
-        }
-        return text;
-    } else {
-        return null;
-    }
-};
-
-async function processAlbumDataFile(file) {
-    let contents;
-    try {
-        contents = await readFile(file, 'utf-8');
-    } catch (error) {
-        // This function can return "error o8jects," which are really just
-        // ordinary o8jects with an error message attached. I'm not 8othering
-        // with error codes here or anywhere in this function; while this would
-        // normally 8e 8ad coding practice, it doesn't really matter here,
-        // 8ecause this isn't an API getting consumed 8y other services (e.g.
-        // translaction functions). If we return an error, the caller will just
-        // print the attached message in the output summary.
-        return {error: `Could not read ${file} (${error.code}).`};
-    }
-
-    // We're pro8a8ly supposed to, like, search for a header somewhere in the
-    // al8um contents, to make sure it's trying to 8e the intended structure
-    // and is a valid utf-8 (or at least ASCII) file. 8ut like, whatever.
-    // We'll just return more specific errors if it's missing necessary data
-    // fields.
-
-    const contentLines = contents.split('\n');
-
-    // In this line of code I defeat the purpose of using a generator in the
-    // first place. Sorry!!!!!!!!
-    const sections = Array.from(getSections(contentLines));
-
-    const albumSection = sections[0];
-    const album = {};
-
-    album.name = getBasicField(albumSection, 'Album');
-    album.artists = getContributionField(albumSection, 'Artists') || getContributionField(albumSection, 'Artist');
-    album.wallpaperArtists = getContributionField(albumSection, 'Wallpaper Art');
-    album.wallpaperStyle = getMultilineField(albumSection, 'Wallpaper Style');
-    album.bannerArtists = getContributionField(albumSection, 'Banner Art');
-    album.bannerStyle = getMultilineField(albumSection, 'Banner Style');
-    album.date = getBasicField(albumSection, 'Date');
-    album.trackArtDate = getBasicField(albumSection, 'Track Art Date') || album.date;
-    album.coverArtDate = getBasicField(albumSection, 'Cover Art Date') || album.date;
-    album.dateAdded = getBasicField(albumSection, 'Date Added');
-    album.coverArtists = getContributionField(albumSection, 'Cover Art');
-    album.hasTrackArt = getBooleanField(albumSection, 'Has Track Art') ?? true;
-    album.trackCoverArtists = getContributionField(albumSection, 'Track Art');
-    album.artTags = getListField(albumSection, 'Art Tags') || [];
-    album.commentary = getCommentaryField(albumSection);
-    album.urls = getListField(albumSection, 'URLs') || [];
-    album.groups = getListField(albumSection, 'Groups') || [];
-    album.directory = getBasicField(albumSection, 'Directory');
-    album.isMajorRelease = getBooleanField(albumSection, 'Major Release') ?? false;
-
-    if (album.artists && album.artists.error) {
-        return {error: `${album.artists.error} (in ${album.name})`};
-    }
-
-    if (album.coverArtists && album.coverArtists.error) {
-        return {error: `${album.coverArtists.error} (in ${album.name})`};
-    }
-
-    if (album.commentary && album.commentary.error) {
-        return {error: `${album.commentary.error} (in ${album.name})`};
-    }
-
-    if (album.trackCoverArtists && album.trackCoverArtists.error) {
-        return {error: `${album.trackCoverArtists.error} (in ${album.name})`};
-    }
-
-    if (!album.coverArtists) {
-        return {error: `The album "${album.name}" is missing the "Cover Art" field.`};
-    }
-
-    album.color = (
-        getBasicField(albumSection, 'Color') ||
-        getBasicField(albumSection, 'FG')
-    );
-
-    if (!album.name) {
-        return {error: `Expected "Album" (name) field!`};
-    }
-
-    if (!album.date) {
-        return {error: `Expected "Date" field! (in ${album.name})`};
-    }
-
-    if (!album.dateAdded) {
-        return {error: `Expected "Date Added" field! (in ${album.name})`};
-    }
-
-    if (isNaN(Date.parse(album.date))) {
-        return {error: `Invalid Date field: "${album.date}" (in ${album.name})`};
-    }
-
-    if (isNaN(Date.parse(album.trackArtDate))) {
-        return {error: `Invalid Track Art Date field: "${album.trackArtDate}" (in ${album.name})`};
-    }
-
-    if (isNaN(Date.parse(album.coverArtDate))) {
-        return {error: `Invalid Cover Art Date field: "${album.coverArtDate}" (in ${album.name})`};
-    }
-
-    if (isNaN(Date.parse(album.dateAdded))) {
-        return {error: `Invalid Date Added field: "${album.dateAdded}" (in ${album.name})`};
-    }
-
-    album.date = new Date(album.date);
-    album.trackArtDate = new Date(album.trackArtDate);
-    album.coverArtDate = new Date(album.coverArtDate);
-    album.dateAdded = new Date(album.dateAdded);
-
-    if (!album.directory) {
-        album.directory = C.getKebabCase(album.name);
-    }
-
-    album.tracks = [];
-
-    // will be overwritten if a group section is found!
-    album.trackGroups = null;
-
-    let group = null;
-    let trackIndex = 0;
-
-    for (const section of sections.slice(1)) {
-        // Just skip empty sections. Sometimes I paste a 8unch of dividers,
-        // and this lets the empty sections doing that creates (temporarily)
-        // exist without raising an error.
-        if (!section.filter(Boolean).length) {
-            continue;
-        }
-
-        const groupName = getBasicField(section, 'Group');
-        if (groupName) {
-            group = {
-                name: groupName,
-                color: (
-                    getBasicField(section, 'Color') ||
-                    getBasicField(section, 'FG') ||
-                    album.color
-                ),
-                startIndex: trackIndex,
-                tracks: []
-            };
-            if (album.trackGroups) {
-                album.trackGroups.push(group);
-            } else {
-                album.trackGroups = [group];
-            }
-            continue;
-        }
-
-        trackIndex++;
-
-        const track = {};
-
-        track.name = getBasicField(section, 'Track');
-        track.commentary = getCommentaryField(section);
-        track.lyrics = getMultilineField(section, 'Lyrics');
-        track.originalDate = getBasicField(section, 'Original Date');
-        track.coverArtDate = getBasicField(section, 'Cover Art Date') || track.originalDate || album.trackArtDate;
-        track.references = getListField(section, 'References') || [];
-        track.artists = getContributionField(section, 'Artists') || getContributionField(section, 'Artist');
-        track.coverArtists = getContributionField(section, 'Track Art');
-        track.artTags = getListField(section, 'Art Tags') || [];
-        track.contributors = getContributionField(section, 'Contributors') || [];
-        track.directory = getBasicField(section, 'Directory');
-        track.aka = getBasicField(section, 'AKA');
-
-        if (!track.name) {
-            return {error: `A track section is missing the "Track" (name) field (in ${album.name}, previous: ${album.tracks[album.tracks.length - 1]?.name}).`};
-        }
-
-        let durationString = getBasicField(section, 'Duration') || '0:00';
-        track.duration = getDurationInSeconds(durationString);
-
-        if (track.contributors.error) {
-            return {error: `${track.contributors.error} (in ${track.name}, ${album.name})`};
-        }
-
-        if (track.commentary && track.commentary.error) {
-            return {error: `${track.commentary.error} (in ${track.name}, ${album.name})`};
-        }
-
-        if (!track.artists) {
-            // If an al8um has an artist specified (usually 8ecause it's a solo
-            // al8um), let tracks inherit that artist. We won't display the
-            // "8y <artist>" string on the al8um listing.
-            if (album.artists) {
-                track.artists = album.artists;
-            } else {
-                return {error: `The track "${track.name}" is missing the "Artist" field (in ${album.name}).`};
-            }
-        }
-
-        if (!track.coverArtists) {
-            if (getBasicField(section, 'Track Art') !== 'none' && album.hasTrackArt) {
-                if (album.trackCoverArtists) {
-                    track.coverArtists = album.trackCoverArtists;
-                } else {
-                    return {error: `The track "${track.name}" is missing the "Track Art" field (in ${album.name}).`};
-                }
-            }
-        }
-
-        if (track.coverArtists && track.coverArtists.length && track.coverArtists[0] === 'none') {
-            track.coverArtists = null;
-        }
-
-        if (!track.directory) {
-            track.directory = C.getKebabCase(track.name);
-        }
-
-        if (track.originalDate) {
-            if (isNaN(Date.parse(track.originalDate))) {
-                return {error: `The track "${track.name}"'s has an invalid "Original Date" field: "${track.originalDate}"`};
-            }
-            track.date = new Date(track.originalDate);
-        } else {
-            track.date = album.date;
-        }
-
-        track.coverArtDate = new Date(track.coverArtDate);
-
-        const hasURLs = getBooleanField(section, 'Has URLs') ?? true;
-
-        track.urls = hasURLs && (getListField(section, 'URLs') || []).filter(Boolean);
-
-        if (hasURLs && !track.urls.length) {
-            return {error: `The track "${track.name}" should have at least one URL specified.`};
-        }
-
-        // 8ack-reference the al8um o8ject! This is very useful for when
-        // we're outputting the track pages.
-        track.album = album;
-
-        if (group) {
-            track.color = group.color;
-            group.tracks.push(track);
-        } else {
-            track.color = album.color;
-        }
-
-        album.tracks.push(track);
-    }
-
-    return album;
-}
-
-async function processArtistDataFile(file) {
-    let contents;
-    try {
-        contents = await readFile(file, 'utf-8');
-    } catch (error) {
-        return {error: `Could not read ${file} (${error.code}).`};
-    }
-
-    const contentLines = contents.split('\n');
-    const sections = Array.from(getSections(contentLines));
-
-    return sections.filter(s => s.filter(Boolean).length).map(section => {
-        const name = getBasicField(section, 'Artist');
-        const urls = (getListField(section, 'URLs') || []).filter(Boolean);
-        const alias = getBasicField(section, 'Alias');
-        const hasAvatar = getBooleanField(section, 'Has Avatar') ?? false;
-        const note = getMultilineField(section, 'Note');
-        let directory = getBasicField(section, 'Directory');
-
-        if (!name) {
-            return {error: 'Expected "Artist" (name) field!'};
-        }
-
-        if (!directory) {
-            directory = C.getArtistDirectory(name);
-        }
-
-        if (alias) {
-            return {name, directory, alias};
-        } else {
-            return {name, directory, urls, note, hasAvatar};
-        }
-    });
-}
-
-async function processFlashDataFile(file) {
-    let contents;
-    try {
-        contents = await readFile(file, 'utf-8');
-    } catch (error) {
-        return {error: `Could not read ${file} (${error.code}).`};
-    }
-
-    const contentLines = contents.split('\n');
-    const sections = Array.from(getSections(contentLines));
-
-    let act, color;
-    return sections.map(section => {
-        if (getBasicField(section, 'ACT')) {
-            act = getBasicField(section, 'ACT');
-            color = (
-                getBasicField(section, 'Color') ||
-                getBasicField(section, 'FG')
-            );
-            const anchor = getBasicField(section, 'Anchor');
-            const jump = getBasicField(section, 'Jump');
-            const jumpColor = getBasicField(section, 'Jump Color') || color;
-            return {act8r8k: true, name: act, color, anchor, jump, jumpColor};
-        }
-
-        const name = getBasicField(section, 'Flash');
-        let page = getBasicField(section, 'Page');
-        let directory = getBasicField(section, 'Directory');
-        let date = getBasicField(section, 'Date');
-        const jiff = getBasicField(section, 'Jiff');
-        const tracks = getListField(section, 'Tracks') || [];
-        const contributors = getContributionField(section, 'Contributors') || [];
-        const urls = (getListField(section, 'URLs') || []).filter(Boolean);
-
-        if (!name) {
-            return {error: 'Expected "Flash" (name) field!'};
-        }
-
-        if (!page && !directory) {
-            return {error: 'Expected "Page" or "Directory" field!'};
-        }
-
-        if (!directory) {
-            directory = page;
-        }
-
-        if (!date) {
-            return {error: 'Expected "Date" field!'};
-        }
-
-        if (isNaN(Date.parse(date))) {
-            return {error: `Invalid Date field: "${date}"`};
-        }
-
-        date = new Date(date);
-
-        return {name, page, directory, date, contributors, tracks, urls, act, color, jiff};
-    });
-}
-
-async function processNewsDataFile(file) {
-    let contents;
-    try {
-        contents = await readFile(file, 'utf-8');
-    } catch (error) {
-        return {error: `Could not read ${file} (${error.code}).`};
-    }
-
-    const contentLines = contents.split('\n');
-    const sections = Array.from(getSections(contentLines));
-
-    return sections.map(section => {
-        const name = getBasicField(section, 'Name');
-        if (!name) {
-            return {error: 'Expected "Name" field!'};
-        }
-
-        const directory = getBasicField(section, 'Directory') || getBasicField(section, 'ID');
-        if (!directory) {
-            return {error: 'Expected "Directory" field!'};
-        }
-
-        let body = getMultilineField(section, 'Body');
-        if (!body) {
-            return {error: 'Expected "Body" field!'};
-        }
-
-        let date = getBasicField(section, 'Date');
-        if (!date) {
-            return {error: 'Expected "Date" field!'};
-        }
-
-        if (isNaN(Date.parse(date))) {
-            return {error: `Invalid date field: "${date}"`};
-        }
-
-        date = new Date(date);
-
-        let bodyShort = body.split('<hr class="split">')[0];
-
-        return {
-            name,
-            directory,
-            body,
-            bodyShort,
-            date
-        };
-    });
-}
-
-async function processTagDataFile(file) {
-    let contents;
-    try {
-        contents = await readFile(file, 'utf-8');
-    } catch (error) {
-        if (error.code === 'ENOENT') {
-            return [];
-        } else {
-            return {error: `Could not read ${file} (${error.code}).`};
-        }
-    }
-
-    const contentLines = contents.split('\n');
-    const sections = Array.from(getSections(contentLines));
-
-    return sections.map(section => {
-        let isCW = false;
-
-        let name = getBasicField(section, 'Tag');
-        if (!name) {
-            name = getBasicField(section, 'CW');
-            isCW = true;
-            if (!name) {
-                return {error: 'Expected "Tag" or "CW" field!'};
-            }
-        }
-
-        let color;
-        if (!isCW) {
-            color = getBasicField(section, 'Color');
-            if (!color) {
-                return {error: 'Expected "Color" field!'};
-            }
-        }
-
-        const directory = C.getKebabCase(name);
-
-        return {
-            name,
-            directory,
-            isCW,
-            color
-        };
-    });
-}
-
-async function processGroupDataFile(file) {
-    let contents;
-    try {
-        contents = await readFile(file, 'utf-8');
-    } catch (error) {
-        if (error.code === 'ENOENT') {
-            return [];
-        } else {
-            return {error: `Could not read ${file} (${error.code}).`};
-        }
-    }
-
-    const contentLines = contents.split('\n');
-    const sections = Array.from(getSections(contentLines));
-
-    let category, color;
-    return sections.map(section => {
-        if (getBasicField(section, 'Category')) {
-            category = getBasicField(section, 'Category');
-            color = getBasicField(section, 'Color');
-            return {isCategory: true, name: category, color};
-        }
-
-        const name = getBasicField(section, 'Group');
-        if (!name) {
-            return {error: 'Expected "Group" field!'};
-        }
-
-        let directory = getBasicField(section, 'Directory');
-        if (!directory) {
-            directory = C.getKebabCase(name);
-        }
-
-        let description = getMultilineField(section, 'Description');
-        if (!description) {
-            return {error: 'Expected "Description" field!'};
-        }
-
-        let descriptionShort = description.split('<hr class="split">')[0];
-
-        const urls = (getListField(section, 'URLs') || []).filter(Boolean);
-
-        return {
-            isGroup: true,
-            name,
-            directory,
-            description,
-            descriptionShort,
-            urls,
-            category,
-            color
-        };
-    });
-}
-
-async function processStaticPageDataFile(file) {
-    let contents;
-    try {
-        contents = await readFile(file, 'utf-8');
-    } catch (error) {
-        if (error.code === 'ENOENT') {
-            return [];
-        } else {
-            return {error: `Could not read ${file} (${error.code}).`};
-        }
-    }
-
-    const contentLines = contents.split('\n');
-    const sections = Array.from(getSections(contentLines));
-
-    return sections.map(section => {
-        const name = getBasicField(section, 'Name');
-        if (!name) {
-            return {error: 'Expected "Name" field!'};
-        }
-
-        const shortName = getBasicField(section, 'Short Name') || name;
-
-        let directory = getBasicField(section, 'Directory');
-        if (!directory) {
-            return {error: 'Expected "Directory" field!'};
-        }
-
-        let content = getMultilineField(section, 'Content');
-        if (!content) {
-            return {error: 'Expected "Content" field!'};
-        }
-
-        let stylesheet = getMultilineField(section, 'Style') || '';
-
-        let listed = getBooleanField(section, 'Listed') ?? true;
-
-        return {
-            name,
-            shortName,
-            directory,
-            content,
-            stylesheet,
-            listed
-        };
-    });
-}
-
-async function processWikiInfoFile(file) {
-    let contents;
-    try {
-        contents = await readFile(file, 'utf-8');
-    } catch (error) {
-        return {error: `Could not read ${file} (${error.code}).`};
-    }
-
-    // Unlike other data files, the site info data file isn't 8roken up into
-    // more than one entry. So we operate on the plain old contentLines array,
-    // rather than dividing into sections like we usually do!
-    const contentLines = contents.split('\n');
-
-    const name = getBasicField(contentLines, 'Name');
-    if (!name) {
-        return {error: 'Expected "Name" field!'};
-    }
-
-    const shortName = getBasicField(contentLines, 'Short Name') || name;
-
-    const color = getBasicField(contentLines, 'Color') || '#0088ff';
-
-    // This is optional! Without it, <meta rel="canonical"> tags won't 8e
-    // gener8ted.
-    const canonicalBase = getBasicField(contentLines, 'Canonical Base');
-
-    // This is optional! Without it, the site will default to 8uilding in
-    // English. (This is only really relevant if you've provided string files
-    // for non-English languages.)
-    const defaultLanguage = getBasicField(contentLines, 'Default Language');
-
-    // Also optional! In charge of <meta rel="description">.
-    const description = getBasicField(contentLines, 'Description');
-
-    const footer = getMultilineField(contentLines, 'Footer') || '';
-
-    // We've had a comment lying around for ages, just reading:
-    // "Might ena8le this later... we'll see! Eventually. May8e."
-    // We still haven't! 8ut hey, the option's here.
-    const enableArtistAvatars = getBooleanField(contentLines, 'Enable Artist Avatars') ?? false;
-
-    const enableFlashesAndGames = getBooleanField(contentLines, 'Enable Flashes & Games') ?? false;
-    const enableListings = getBooleanField(contentLines, 'Enable Listings') ?? false;
-    const enableNews = getBooleanField(contentLines, 'Enable News') ?? false;
-    const enableArtTagUI = getBooleanField(contentLines, 'Enable Art Tag UI') ?? false;
-    const enableGroupUI = getBooleanField(contentLines, 'Enable Group UI') ?? false;
-
-    return {
-        name,
-        shortName,
-        color,
-        canonicalBase,
-        defaultLanguage,
-        description,
-        footer,
-        features: {
-            artistAvatars: enableArtistAvatars,
-            flashesAndGames: enableFlashesAndGames,
-            listings: enableListings,
-            news: enableNews,
-            artTagUI: enableArtTagUI,
-            groupUI: enableGroupUI
-        }
-    };
-}
-
-async function processHomepageInfoFile(file) {
-    let contents;
-    try {
-        contents = await readFile(file, 'utf-8');
-    } catch (error) {
-        return {error: `Could not read ${file} (${error.code}).`};
-    }
-
-    const contentLines = contents.split('\n');
-    const sections = Array.from(getSections(contentLines));
-
-    const [ firstSection, ...rowSections ] = sections;
-
-    const sidebar = getMultilineField(firstSection, 'Sidebar');
-
-    const validRowTypes = ['albums'];
-
-    const rows = rowSections.map(section => {
-        const name = getBasicField(section, 'Row');
-        if (!name) {
-            return {error: 'Expected "Row" (name) field!'};
-        }
-
-        const color = getBasicField(section, 'Color');
-
-        const type = getBasicField(section, 'Type');
-        if (!type) {
-            return {error: 'Expected "Type" field!'};
-        }
-
-        if (!validRowTypes.includes(type)) {
-            return {error: `Expected "Type" field to be one of: ${validRowTypes.join(', ')}`};
-        }
-
-        const row = {name, color, type};
-
-        switch (type) {
-            case 'albums': {
-                const group = getBasicField(section, 'Group') || null;
-                const albums = getListField(section, 'Albums') || [];
-
-                if (!group && !albums) {
-                    return {error: 'Expected "Group" and/or "Albums" field!'};
-                }
-
-                let groupCount = getBasicField(section, 'Count');
-                if (group && !groupCount) {
-                    return {error: 'Expected "Count" field!'};
-                }
-
-                if (groupCount) {
-                    if (isNaN(parseInt(groupCount))) {
-                        return {error: `Invalid Count field: "${groupCount}"`};
-                    }
-
-                    groupCount = parseInt(groupCount);
-                }
-
-                const actions = getListField(section, 'Actions') || [];
-
-                return {...row, group, groupCount, albums, actions};
-            }
-        }
-    });
-
-    return {sidebar, rows};
-}
-
-function getDurationInSeconds(string) {
-    const parts = string.split(':').map(n => parseInt(n))
-    if (parts.length === 3) {
-        return parts[0] * 3600 + parts[1] * 60 + parts[2]
-    } else if (parts.length === 2) {
-        return parts[0] * 60 + parts[1]
-    } else {
-        return 0
-    }
-}
-
-function getTotalDuration(tracks) {
-    return tracks.reduce((duration, track) => duration + track.duration, 0);
-}
-
-const stringifyIndent = 0;
-
-const toRefs = (label, objectOrArray) => {
-    if (Array.isArray(objectOrArray)) {
-        return objectOrArray.filter(Boolean).map(x => `${label}:${x.directory}`);
-    } else if (objectOrArray.directory) {
-        throw new Error('toRefs should not be passed a single object with directory');
-    } else if (typeof objectOrArray === 'object') {
-        return Object.fromEntries(Object.entries(objectOrArray)
-            .map(([ key, value ]) => [key, toRefs(key, value)]));
-    } else {
-        throw new Error('toRefs should be passed an array or object of arrays');
-    }
-};
-
-function stringifyRefs(key, value) {
-    switch (key) {
-        case 'tracks':
-        case 'references':
-        case 'referencedBy':
-            return toRefs('track', value);
-        case 'artists':
-        case 'contributors':
-        case 'coverArtists':
-        case 'trackCoverArtists':
-            return value && value.map(({ who, what }) => ({who: `artist:${who.directory}`, what}));
-        case 'albums': return toRefs('album', value);
-        case 'flashes': return toRefs('flash', value);
-        case 'groups': return toRefs('group', value);
-        case 'artTags': return toRefs('tag', value);
-        case 'aka': return value && `track:${value.directory}`;
-        default:
-            return value;
-    }
-}
-
-function stringifyAlbumData() {
-    return JSON.stringify(albumData, (key, value) => {
-        switch (key) {
-            case 'commentary':
-                return '';
-            default:
-                return stringifyRefs(key, value);
-        }
-    }, stringifyIndent);
-}
-
-function stringifyTrackData() {
-    return JSON.stringify(trackData, (key, value) => {
-        switch (key) {
-            case 'album':
-            case 'commentary':
-            case 'otherReleases':
-                return undefined;
-            default:
-                return stringifyRefs(key, value);
-        }
-    }, stringifyIndent);
-}
-
-function stringifyFlashData() {
-    return JSON.stringify(flashData, (key, value) => {
-        switch (key) {
-            case 'act':
-            case 'commentary':
-                return undefined;
-            default:
-                return stringifyRefs(key, value);
-        }
-    }, stringifyIndent);
-}
-
-function stringifyArtistData() {
-    return JSON.stringify(artistData, (key, value) => {
-        switch (key) {
-            case 'asAny':
-                return;
-            case 'asArtist':
-            case 'asContributor':
-            case 'asCoverArtist':
-                return toRefs('track', value);
-            default:
-                return stringifyRefs(key, value);
-        }
-    }, stringifyIndent);
-}
-
-function img({
-    src = '',
-    alt = '',
-    thumb: thumbKey = '',
-    reveal = '',
-    id = '',
-    class: className = '',
-    width = '',
-    height = '',
-    link = false,
-    lazy = false,
-    square = false
-}) {
-    const willSquare = square;
-    const willLink = typeof link === 'string' || link;
-
-    const originalSrc = src;
-    const thumbSrc = thumbKey ? thumb[thumbKey](src) : src;
-
-    const imgAttributes = html.attributes({
-        id: link ? '' : id,
-        class: className,
-        alt,
-        width,
-        height
-    });
-
-    const nonlazyHTML = wrap(`<img src="${thumbSrc}" ${imgAttributes}>`);
-    const lazyHTML = lazy && wrap(`<img class="lazy" data-original="${thumbSrc}" ${imgAttributes}>`, true);
-
-    if (lazy) {
-        return fixWS`
-            <noscript>${nonlazyHTML}</noscript>
-            ${lazyHTML}
-        `;
-    } else {
-        return nonlazyHTML;
-    }
-
-    function wrap(input, hide = false) {
-        let wrapped = input;
-
-        wrapped = `<div class="image-inner-area">${wrapped}</div>`;
-        wrapped = `<div class="image-container">${wrapped}</div>`;
-
-        if (reveal) {
-            wrapped = fixWS`
-                <div class="reveal">
-                    ${wrapped}
-                    <span class="reveal-text">${reveal}</span>
-                </div>
-            `;
-        }
-
-        if (willSquare) {
-            wrapped = html.tag('div', {class: 'square-content'}, wrapped);
-            wrapped = html.tag('div', {class: ['square', hide && !willLink && 'js-hide']}, wrapped);
-        }
-
-        if (willLink) {
-            wrapped = html.tag('a', {
-                id,
-                class: ['box', hide && 'js-hide'],
-                href: typeof link === 'string' ? link : originalSrc
-            }, wrapped);
-        }
-
-        return wrapped;
-    }
-}
-
-function serializeImagePaths(original) {
-    return {
-        original,
-        medium: thumb.medium(original),
-        small: thumb.small(original)
-    };
-}
-
-function serializeLink(thing) {
-    const ret = {};
-    ret.name = thing.name;
-    ret.directory = thing.directory;
-    if (thing.color) ret.color = thing.color;
-    return ret;
-}
-
-function serializeContribs(contribs) {
-    return contribs.map(({ who, what }) => {
-        const ret = {};
-        ret.artist = serializeLink(who);
-        if (what) ret.contribution = what;
-        return ret;
-    });
-}
-
-function serializeCover(thing, pathFunction) {
-    const coverPath = pathFunction(thing, {
-        to: urls.from('media.root').to
-    });
-
-    const { artTags } = thing;
-
-    const cwTags = artTags.filter(tag => tag.isCW);
-    const linkTags = artTags.filter(tag => !tag.isCW);
-
-    return {
-        paths: serializeImagePaths(coverPath),
-        tags: linkTags.map(serializeLink),
-        warnings: cwTags.map(tag => tag.name)
-    };
-}
-
-function serializeGroupsForAlbum(album) {
-    return album.groups.map(group => {
-        const index = group.albums.indexOf(album);
-        const next = group.albums[index + 1] || null;
-        const previous = group.albums[index - 1] || null;
-        return {group, index, next, previous};
-    }).map(({group, index, next, previous}) => ({
-        link: serializeLink(group),
-        descriptionShort: group.descriptionShort,
-        albumIndex: index,
-        nextAlbum: next && serializeLink(next),
-        previousAlbum: previous && serializeLink(previous),
-        urls: group.urls
-    }));
-}
-
-function serializeGroupsForTrack(track) {
-    return track.album.groups.map(group => ({
-        link: serializeLink(group),
-        urls: group.urls,
-    }));
-}
-
-function validateWritePath(path, urlGroup) {
-    if (!Array.isArray(path)) {
-        return {error: `Expected array, got ${path}`};
-    }
-
-    const { paths } = urlGroup;
-
-    const definedKeys = Object.keys(paths);
-    const specifiedKey = path[0];
-
-    if (!definedKeys.includes(specifiedKey)) {
-        return {error: `Specified key ${specifiedKey} isn't defined`};
-    }
-
-    const expectedArgs = paths[specifiedKey].match(/<>/g).length;
-    const specifiedArgs = path.length - 1;
-
-    if (specifiedArgs !== expectedArgs) {
-        return {error: `Expected ${expectedArgs} arguments, got ${specifiedArgs}`};
-    }
-
-    return {success: true};
-}
-
-function validateWriteObject(obj) {
-    if (typeof obj !== 'object') {
-        return {error: `Expected object, got ${typeof obj}`};
-    }
-
-    if (typeof obj.type !== 'string') {
-        return {error: `Expected type to be string, got ${obj.type}`};
-    }
-
-    switch (obj.type) {
-        case 'legacy': {
-            if (typeof obj.write !== 'function') {
-                return {error: `Expected write to be string, got ${obj.write}`};
-            }
-
-            break;
-        }
-
-        case 'page': {
-            const path = validateWritePath(obj.path, urlSpec.localized);
-            if (path.error) {
-                return {error: `Path validation failed: ${path.error}`};
-            }
-
-            if (typeof obj.page !== 'function') {
-                return {error: `Expected page to be function, got ${obj.content}`};
-            }
-
-            break;
-        }
-
-        case 'data': {
-            const path = validateWritePath(obj.path, urlSpec.data);
-            if (path.error) {
-                return {error: `Path validation failed: ${path.error}`};
-            }
-
-            if (typeof obj.data !== 'function') {
-                return {error: `Expected data to be function, got ${obj.data}`};
-            }
-
-            break;
-        }
-
-        default: {
-            return {error: `Unknown type: ${obj.type}`};
-        }
-    }
-
-    return {success: true};
-}
-
-async function writeData(subKey, directory, data) {
-    const paths = writePage.paths('', 'data.' + subKey, directory, {file: 'data.json'});
-    await writePage.write(JSON.stringify(data), {paths});
-}
-
-async function writePage(strings, baseDirectory, pageSubKey, directory, pageFn) {
-    // Generally this function shouldn't 8e called directly - instead use the
-    // shadowed version provided 8y wrapLanguages, which automatically provides
-    // the appropriate baseDirectory and strings arguments. (The utility
-    // functions attached to this function are generally useful, though!)
-
-    const paths = writePage.paths(baseDirectory, 'localized.' + pageSubKey, directory);
-
-    const to = (targetFullKey, ...args) => {
-        const [ groupKey, subKey ] = targetFullKey.split('.')[0];
-        let path = paths.subdirectoryPrefix
-        // When linking to *outside* the localized area of the site, we need to
-        // make sure the result is correctly relative to the 8ase directory.
-        if (groupKey !== 'localized' && baseDirectory) {
-            path += urls.from('localizedWithBaseDirectory.' + pageSubKey).to(targetFullKey, ...args);
-        } else {
-            // If we're linking inside the localized area (or there just is no
-            // 8ase directory), the 8ase directory doesn't matter.
-            path += urls.from('localized.' + pageSubKey).to(targetFullKey, ...args);
-        }
-        // console.log(pageSubKey, '->', targetFullKey, '=', path);
-        return path;
-    };
-
-    const content = writePage.html(pageFn, {paths, strings, to});
-    await writePage.write(content, {paths});
-}
-
-writePage.html = (pageFn, {paths, strings, to}) => {
-    let {
-        title = '',
-        meta = {},
-        theme = '',
-        stylesheet = '',
-
-        // missing properties are auto-filled, see below!
-        body = {},
-        banner = {},
-        main = {},
-        sidebarLeft = {},
-        sidebarRight = {},
-        nav = {},
-        footer = {}
-    } = pageFn({to});
-
-    body.style ??= '';
-
-    theme = theme || getThemeString(wikiInfo);
-
-    banner ||= {};
-    banner.classes ??= [];
-    banner.src ??= '';
-    banner.position ??= '';
-
-    main.classes ??= [];
-    main.content ??= '';
-
-    sidebarLeft ??= {};
-    sidebarRight ??= {};
-
-    for (const sidebar of [sidebarLeft, sidebarRight]) {
-        sidebar.classes ??= [];
-        sidebar.content ??= '';
-        sidebar.collapse ??= true;
-    }
-
-    nav.classes ??= [];
-    nav.content ??= '';
-    nav.links ??= [];
-
-    footer.classes ??= [];
-    footer.content ??= (wikiInfo.footer ? transformMultiline(wikiInfo.footer, {strings, to}) : '');
-
-    const canonical = (wikiInfo.canonicalBase
-        ? wikiInfo.canonicalBase + paths.pathname
-        : '');
-
-    const collapseSidebars = (sidebarLeft.collapse !== false) && (sidebarRight.collapse !== false);
-
-    const mainHTML = main.content && fixWS`
-        <main id="content" ${classes(...main.classes || [])}>
-            ${main.content}
-        </main>
-    `;
-
-    const footerHTML = footer.content && fixWS`
-        <footer id="footer" ${classes(...footer.classes || [])}>
-            ${footer.content}
-        </footer>
-    `;
-
-    const generateSidebarHTML = (id, {
-        content,
-        multiple,
-        classes: sidebarClasses = [],
-        collapse = true,
-        wide = false
-    }) => (content ? fixWS`
-        <div id="${id}" ${classes(
-            'sidebar-column',
-            'sidebar',
-            wide && 'wide',
-            !collapse && 'no-hide',
-            ...sidebarClasses
-        )}>
-            ${content}
-        </div>
-    ` : multiple ? fixWS`
-        <div id="${id}" ${classes(
-            'sidebar-column',
-            'sidebar-multiple',
-            wide && 'wide',
-            !collapse && 'no-hide'
-        )}>
-            ${multiple.map(content => fixWS`
-                <div ${classes(
-                    'sidebar',
-                    ...sidebarClasses
-                )}>
-                    ${content}
-                </div>
-            `).join('\n')}
-        </div>
-    ` : '');
-
-    const sidebarLeftHTML = generateSidebarHTML('sidebar-left', sidebarLeft);
-    const sidebarRightHTML = generateSidebarHTML('sidebar-right', sidebarRight);
-
-    if (nav.simple) {
-        nav.links = [
-            {
-                href: to('localized.home'),
-                title: wikiInfo.shortName
-            },
-            {
-                href: '',
-                title
-            }
-        ];
-    }
-
-    const links = (nav.links || []).filter(Boolean);
-
-    const navLinkParts = [];
-    for (let i = 0; i < links.length; i++) {
-        const link = links[i];
-        const prev = links[i - 1];
-        const next = links[i + 1];
-        const { html, href, title, divider = true } = link;
-        let part = prev && divider ? '/ ' : '';
-        if (typeof href === 'string') {
-            part += `<a href="${href}" ${classes(i === links.length - 1 && 'current')}>${title}</a>`;
-        } else if (html) {
-            part += `<span>${html}</span>`;
-        }
-        navLinkParts.push(part);
-    }
-
-    const navHTML = html.tag('nav', {
-        [html.onlyIfContent]: true,
-        id: 'header',
-        class: nav.classes
-    }, [
-        links.length && html.tag('h2', {class: 'highlight-last-link'}, navLinkParts),
-        nav.content
-    ]);
-
-    const bannerHTML = banner.position && banner.src && html.tag('div',
-        {
-            id: 'banner',
-            class: banner.classes
-        },
-        html.tag('img', {
-            src: banner.src,
-            alt: banner.alt,
-            width: 1100,
-            height: 200
-        })
-    );
-
-    const layoutHTML = [
-        navHTML,
-        banner.position === 'top' && bannerHTML,
-        (sidebarLeftHTML || sidebarRightHTML) ? fixWS`
-            <div ${classes('layout-columns', !collapseSidebars && 'vertical-when-thin')}>
-                ${sidebarLeftHTML}
-                ${mainHTML}
-                ${sidebarRightHTML}
-            </div>
-        ` : mainHTML,
-        banner.position === 'bottom' && bannerHTML,
-        footerHTML
-    ].filter(Boolean).join('\n');
-
-    const infoCardHTML = fixWS`
-        <div id="info-card-container">
-            <div class="info-card-decor">
-                <div class="info-card">
-                    <div class="info-card-art-container no-reveal">
-                        ${img({
-                            class: 'info-card-art',
-                            src: '',
-                            link: true,
-                            square: true
-                        })}
-                    </div>
-                    <div class="info-card-art-container reveal">
-                        ${img({
-                            class: 'info-card-art',
-                            src: '',
-                            link: true,
-                            square: true,
-                            reveal: getRevealStringFromWarnings('<span class="info-card-art-warnings"></span>', {strings})
-                        })}
-                    </div>
-                    <h1 class="info-card-name"><a></a></h1>
-                    <p class="info-card-album">${strings('releaseInfo.from', {album: '<a></a>'})}</p>
-                    <p class="info-card-artists">${strings('releaseInfo.by', {artists: '<span></span>'})}</p>
-                    <p class="info-card-cover-artists">${strings('releaseInfo.coverArtBy', {artists: '<span></span>'})}</p>
-                </div>
-            </div>
-        </div>
-    `;
-
-    return filterEmptyLines(fixWS`
-        <!DOCTYPE html>
-        <html ${html.attributes({
-            lang: strings.code,
-            'data-rebase-localized': to('localized.root'),
-            'data-rebase-shared': to('shared.root'),
-            'data-rebase-media': to('media.root'),
-            'data-rebase-data': to('data.root')
-        })}>
-            <head>
-                <title>${title}</title>
-                <meta charset="utf-8">
-                <meta name="viewport" content="width=device-width, initial-scale=1">
-                ${Object.entries(meta).filter(([ key, value ]) => value).map(([ key, value ]) => `<meta ${key}="${html.escapeAttributeValue(value)}">`).join('\n')}
-                ${canonical && `<link rel="canonical" href="${canonical}">`}
-                <link rel="stylesheet" href="${to('shared.staticFile', `site.css?${CACHEBUST}`)}">
-                ${(theme || stylesheet) && fixWS`
-                    <style>
-                        ${theme}
-                        ${stylesheet}
-                    </style>
-                `}
-                <script src="${to('shared.staticFile', `lazy-loading.js?${CACHEBUST}`)}"></script>
-            </head>
-            <body ${html.attributes({style: body.style || ''})}>
-                <div id="page-container">
-                    ${mainHTML && fixWS`
-                        <div id="skippers">
-                            ${[
-                                ['#content', strings('misc.skippers.skipToContent')],
-                                sidebarLeftHTML && ['#sidebar-left', (sidebarRightHTML
-                                    ? strings('misc.skippers.skipToSidebar.left')
-                                    : strings('misc.skippers.skipToSidebar'))],
-                                sidebarRightHTML && ['#sidebar-right', (sidebarLeftHTML
-                                    ? strings('misc.skippers.skipToSidebar.right')
-                                    : strings('misc.skippers.skipToSidebar'))],
-                                footerHTML && ['#footer', strings('misc.skippers.skipToFooter')]
-                            ].filter(Boolean).map(([ href, title ]) => fixWS`
-                                <span class="skipper"><a href="${href}">${title}</a></span>
-                            `).join('\n')}
-                        </div>
-                    `}
-                    ${layoutHTML}
-                </div>
-                ${infoCardHTML}
-                <script src="${to('shared.commonFile', `common.js?${CACHEBUST}`)}"></script>
-                <script src="${to('shared.staticFile', `client.js?${CACHEBUST}`)}"></script>
-            </body>
-        </html>
-    `);
-};
-
-writePage.write = async (content, {paths}) => {
-    await mkdirp(paths.outputDirectory);
-    await writeFile(paths.outputFile, content);
-};
-
-// TODO: This only supports one <>-style argument.
-writePage.paths = (baseDirectory, fullKey, directory, {
-    file = 'index.html'
-} = {}) => {
-    const [ groupKey, subKey ] = fullKey.split('.');
-
-    const pathname = (groupKey === 'localized' && baseDirectory
-        ? urls.from('shared.root').to('localizedWithBaseDirectory.' + subKey, baseDirectory, directory)
-        : urls.from('shared.root').to(fullKey, directory));
-
-    // Needed for the rare directory which itself contains a slash, e.g. for
-    // listings, with directories like 'albums/by-name'.
-    const subdirectoryPrefix = '../'.repeat(directory.split('/').length - 1);
-
-    const outputDirectory = path.join(outputPath, pathname);
-    const outputFile = path.join(outputDirectory, file);
-
-    return {
-        pathname,
-        subdirectoryPrefix,
-        outputDirectory, outputFile
-    };
-};
-
-function getGridHTML({
-    strings,
-    entries,
-    srcFn,
-    hrefFn,
-    altFn = () => '',
-    detailsFn = null,
-    lazy = true
-}) {
-    return entries.map(({ large, item }, i) => fixWS`
-        <a ${classes('grid-item', 'box', large && 'large-grid-item')} href="${hrefFn(item)}" style="${getLinkThemeString(item)}">
-            ${img({
-                src: srcFn(item),
-                alt: altFn(item),
-                thumb: 'small',
-                lazy: (typeof lazy === 'number' ? i >= lazy : lazy),
-                square: true,
-                reveal: getRevealStringFromTags(item.artTags, {strings})
-            })}
-            <span>${item.name}</span>
-            ${detailsFn && `<span>${detailsFn(item)}</span>`}
-        </a>
-    `).join('\n');
-}
-
-function getAlbumGridHTML({strings, to, details = false, ...props}) {
-    return getGridHTML({
-        strings,
-        srcFn: album => getAlbumCover(album, {to}),
-        hrefFn: album => to('localized.album', album.directory),
-        detailsFn: details && (album => strings('misc.albumGridDetails', {
-            tracks: strings.count.tracks(album.tracks.length, {unit: true}),
-            time: strings.count.duration(getTotalDuration(album.tracks))
-        })),
-        ...props
-    });
-}
-
-function getFlashGridHTML({strings, to, ...props}) {
-    return getGridHTML({
-        strings,
-        srcFn: flash => to('media.flashArt', flash.directory),
-        hrefFn: flash => to('localized.flash', flash.directory),
-        ...props
-    });
-}
-
-function getNewReleases(numReleases) {
-    const latestFirst = albumData.slice().reverse();
-    const majorReleases = latestFirst.filter(album => album.isMajorRelease);
-    majorReleases.splice(1);
-
-    const otherReleases = latestFirst
-        .filter(album => !majorReleases.includes(album))
-        .slice(0, numReleases - majorReleases.length);
-
-    return [
-        ...majorReleases.map(album => ({large: true, item: album})),
-        ...otherReleases.map(album => ({large: false, item: album}))
-    ];
-}
-
-function getNewAdditions(numAlbums) {
-    // Sort al8ums, in descending order of priority, 8y...
-    //
-    // * D8te of addition to the wiki (descending).
-    // * Major releases first.
-    // * D8te of release (descending).
-    //
-    // Major releases go first to 8etter ensure they show up in the list (and
-    // are usually at the start of the final output for a given d8 of release
-    // too).
-    const sortedAlbums = albumData.slice().sort((a, b) => {
-        if (a.dateAdded > b.dateAdded) return -1;
-        if (a.dateAdded < b.dateAdded) return 1;
-        if (a.isMajorRelease && !b.isMajorRelease) return -1;
-        if (!a.isMajorRelease && b.isMajorRelease) return 1;
-        if (a.date > b.date) return -1;
-        if (a.date < b.date) return 1;
-    });
-
-    // When multiple al8ums are added to the wiki at a time, we want to show
-    // all of them 8efore pulling al8ums from the next (earlier) date. We also
-    // want to show a diverse selection of al8ums - with limited space, we'd
-    // rather not show only the latest al8ums, if those happen to all 8e
-    // closely rel8ted!
-    //
-    // Specifically, we're concerned with avoiding too much overlap amongst
-    // the primary (first/top-most) group. We do this 8y collecting every
-    // primary group present amongst the al8ums for a given d8 into one
-    // (ordered) array, initially sorted (inherently) 8y latest al8um from
-    // the group. Then we cycle over the array, adding one al8um from each
-    // group until all the al8ums from that release d8 have 8een added (or
-    // we've met the total target num8er of al8ums). Once we've added all the
-    // al8ums for a given group, it's struck from the array (so the groups
-    // with the most additions on one d8 will have their oldest releases
-    // collected more towards the end of the list).
-
-    const albums = [];
-
-    let i = 0;
-    outerLoop: while (i < sortedAlbums.length) {
-        // 8uild up a list of groups and their al8ums 8y order of decending
-        // release, iter8ting until we're on a different d8. (We use a map for
-        // indexing so we don't have to iter8te through the entire array each
-        // time we access one of its entries. This is 8asically unnecessary
-        // since this will never 8e an expensive enough task for that to
-        // matter.... 8ut it's nicer code. BBBB) )
-        const currentDate = sortedAlbums[i].dateAdded;
-        const groupMap = new Map();
-        const groupArray = [];
-        for (let album; (album = sortedAlbums[i]) && +album.dateAdded === +currentDate; i++) {
-            const primaryGroup = album.groups[0];
-            if (groupMap.has(primaryGroup)) {
-                groupMap.get(primaryGroup).push(album);
-            } else {
-                const entry = [album]
-                groupMap.set(primaryGroup, entry);
-                groupArray.push(entry);
-            }
-        }
-
-        // Then cycle over that sorted array, adding one al8um from each to
-        // the main array until we've run out or have met the target num8er
-        // of al8ums.
-        while (groupArray.length) {
-            let j = 0;
-            while (j < groupArray.length) {
-                const entry = groupArray[j];
-                const album = entry.shift();
-                albums.push(album);
-
-
-                // This is the only time we ever add anything to the main al8um
-                // list, so it's also the only place we need to check if we've
-                // met the target length.
-                if (albums.length === numAlbums) {
-                    // If we've met it, 8r8k out of the outer loop - we're done
-                    // here!
-                    break outerLoop;
-                }
-
-                if (entry.length) {
-                    j++;
-                } else {
-                    groupArray.splice(j, 1);
-                }
-            }
-        }
-    }
-
-    // Finally, do some quick mapping shenanigans to 8etter display the result
-    // in a grid. (This should pro8a8ly 8e a separ8te, shared function, 8ut
-    // whatevs.)
-    return albums.map(album => ({large: album.isMajorRelease, item: album}));
-}
-
-function writeSymlinks() {
-    return progressPromiseAll('Writing site symlinks.', [
-        link(path.join(__dirname, C.COMMON_DIRECTORY), C.COMMON_DIRECTORY),
-        link(path.join(__dirname, C.STATIC_DIRECTORY), C.STATIC_DIRECTORY),
-        link(mediaPath, C.MEDIA_DIRECTORY)
-    ]);
-
-    async function link(directory, target) {
-        const file = path.join(outputPath, target);
-        try {
-            await unlink(file);
-        } catch (error) {
-            if (error.code !== 'ENOENT') {
-                throw error;
-            }
-        }
-        await symlink(path.resolve(directory), file);
-    }
-}
-
-function writeSharedFilesAndPages({strings}) {
-    const redirect = async (title, from, urlKey, directory) => {
-        const target = path.relative(from, urls.from('shared.root').to(urlKey, directory));
-        const content = generateRedirectPage(title, target, {strings});
-        await mkdirp(path.join(outputPath, from));
-        await writeFile(path.join(outputPath, from, 'index.html'), content);
-    };
-
-    return progressPromiseAll(`Writing files & pages shared across languages.`, [
-        groupData?.some(group => group.directory === 'fandom') &&
-        redirect('Fandom - Gallery', 'albums/fandom', 'localized.groupGallery', 'fandom'),
-
-        groupData?.some(group => group.directory === 'official') &&
-        redirect('Official - Gallery', 'albums/official', 'localized.groupGallery', 'official'),
-
-        wikiInfo.features.listings &&
-        redirect('Album Commentary', 'list/all-commentary', 'localized.commentaryIndex', ''),
-
-        writeFile(path.join(outputPath, 'data.json'), fixWS`
-            {
-                "albumData": ${stringifyAlbumData()},
-                ${wikiInfo.features.flashesAndGames && `"flashData": ${stringifyFlashData()},`}
-                "artistData": ${stringifyArtistData()}
-            }
-        `)
-    ].filter(Boolean));
-}
-
-function writeHomepage() {
-    return ({strings, writePage}) => writePage('home', '', ({to}) => ({
-        title: wikiInfo.name,
-
-        meta: {
-            description: wikiInfo.description
-        },
-
-        main: {
-            classes: ['top-index'],
-            content: fixWS`
-                <h1>${wikiInfo.name}</h1>
-                ${homepageInfo.rows.map((row, i) => fixWS`
-                    <section class="row" style="${getLinkThemeString(row)}">
-                        <h2>${row.name}</h2>
-                        ${row.type === 'albums' && fixWS`
-                            <div class="grid-listing">
-                                ${getAlbumGridHTML({
-                                    strings, to,
-                                    entries: (
-                                        row.group === 'new-releases' ? getNewReleases(row.groupCount) :
-                                        row.group === 'new-additions' ? getNewAdditions(row.groupCount) :
-                                        ((search.group(row.group)?.albums || [])
-                                            .slice()
-                                            .reverse()
-                                            .slice(0, row.groupCount)
-                                            .map(album => ({item: album})))
-                                    ).concat(row.albums
-                                        .map(search.album)
-                                        .map(album => ({item: album}))
-                                    ),
-                                    lazy: i > 0
-                                })}
-                                ${row.actions.length && fixWS`
-                                    <div class="grid-actions">
-                                        ${row.actions.map(action => transformInline(action, {strings, to})
-                                            .replace('<a', '<a class="box grid-item"')).join('\n')}
-                                    </div>
-                                `}
-                            </div>
-                        `}
-                    </section>
-                `).join('\n')}
-            `
-        },
-
-        sidebarLeft: homepageInfo.sidebar && {
-            wide: true,
-            collapse: false,
-            // This is a pretty filthy hack! 8ut otherwise, the [[news]] part
-            // gets treated like it's a reference to the track named "news",
-            // which o8viously isn't what we're going for. Gotta catch that
-            // 8efore we pass it to transformMultiline, 'cuz otherwise it'll
-            // get repl8ced with just the word "news" (or anything else that
-            // transformMultiline does with references it can't match) -- and
-            // we can't match that for replacing it with the news column!
-            //
-            // And no, I will not make [[news]] into part of transformMultiline
-            // (even though that would 8e hilarious).
-            content: transformMultiline(homepageInfo.sidebar.replace('[[news]]', '__GENERATE_NEWS__'), {strings, to}).replace('<p>__GENERATE_NEWS__</p>', wikiInfo.features.news ? fixWS`
-                <h1>${strings('homepage.news.title')}</h1>
-                ${newsData.slice(0, 3).map((entry, i) => fixWS`
-                    <article ${classes('news-entry', i === 0 && 'first-news-entry')}>
-                        <h2><time>${strings.count.date(entry.date)}</time> ${strings.link.newsEntry(entry, {to})}</h2>
-                        ${transformMultiline(entry.bodyShort, {strings, to})}
-                        ${entry.bodyShort !== entry.body && strings.link.newsEntry(entry, {
-                            to,
-                            text: strings('homepage.news.entry.viewRest')
-                        })}
-                    </article>
-                `).join('\n')}
-            ` : `<p><i>News requested in content description but this feature isn't enabled</i></p>`)
-        },
-
-        nav: {
-            content: fixWS`
-                <h2 class="dot-between-spans">
-                    ${[
-                        strings.link.home('', {text: wikiInfo.shortName, class: 'current', to}),
-                        wikiInfo.features.listings &&
-                        strings.link.listingIndex('', {text: strings('listingIndex.title'), to}),
-                        wikiInfo.features.news &&
-                        strings.link.newsIndex('', {text: strings('newsIndex.title'), to}),
-                        wikiInfo.features.flashesAndGames &&
-                        strings.link.flashIndex('', {text: strings('flashIndex.title'), to}),
-                        ...staticPageData.filter(page => page.listed).map(page => strings.link.staticPage(page, {to}))
-                    ].filter(Boolean).map(link => `<span>${link}</span>`).join('\n')}
-                </h2>
-            `
-        }
-    }));
-}
-
-function writeMiscellaneousPages() {
-    return [
-        writeHomepage()
-    ];
-}
-
-function writeNewsPages() {
-    if (!wikiInfo.features.news) {
-        return;
-    }
-
-    return [
-        writeNewsIndex(),
-        ...newsData.map(writeNewsEntryPage)
-    ];
-}
-
-function writeNewsIndex() {
-    return ({strings, writePage}) => writePage('newsIndex', '', ({to}) => ({
-        title: strings('newsIndex.title'),
-
-        main: {
-            content: fixWS`
-                <div class="long-content news-index">
-                    <h1>${strings('newsIndex.title')}</h1>
-                    ${newsData.map(entry => fixWS`
-                        <article id="${entry.directory}">
-                            <h2><time>${strings.count.date(entry.date)}</time> ${strings.link.newsEntry(entry, {to})}</h2>
-                            ${transformMultiline(entry.bodyShort, {strings, to})}
-                            ${entry.bodyShort !== entry.body && `<p>${strings.link.newsEntry(entry, {
-                                to,
-                                text: strings('newsIndex.entry.viewRest')
-                            })}</p>`}
-                        </article>
-                    `).join('\n')}
-                </div>
-            `
-        },
-
-        nav: {simple: true}
-    }));
-}
-
-function writeNewsEntryPage(entry) {
-    return ({strings, writePage}) => writePage('newsEntry', entry.directory, ({to}) => ({
-        title: strings('newsEntryPage.title', {entry: entry.name}),
-
-        main: {
-            content: fixWS`
-                <div class="long-content">
-                    <h1>${strings('newsEntryPage.title', {entry: entry.name})}</h1>
-                    <p>${strings('newsEntryPage.published', {date: strings.count.date(entry.date)})}</p>
-                    ${transformMultiline(entry.body, {strings, to})}
-                </div>
-            `
-        },
-
-        nav: generateNewsEntryNav(entry, {strings, to})
-    }));
-}
-
-function generateNewsEntryNav(entry, {strings, to}) {
-    // The newsData list is sorted reverse chronologically (newest ones first),
-    // so the way we find next/previous entries is flipped from normal.
-    const previousNextLinks = generatePreviousNextLinks('localized.newsEntry', entry, newsData.slice().reverse(), {strings, to});
-
-    return {
-        links: [
-            {
-                href: to('localized.home'),
-                title: wikiInfo.shortName
-            },
-            {
-                href: to('localized.newsIndex'),
-                title: strings('newsEntryPage.nav.news')
-            },
-            {
-                html: strings('newsEntryPage.nav.entry', {
-                    date: strings.count.date(entry.date),
-                    entry: strings.link.newsEntry(entry, {class: 'current', to})
-                })
-            },
-            previousNextLinks &&
-            {
-                divider: false,
-                html: `(${previousNextLinks})`
-            }
-        ]
-    };
-}
-
-function writeStaticPages() {
-    return staticPageData.map(writeStaticPage);
-}
-
-function writeStaticPage(staticPage) {
-    return ({strings, writePage}) => writePage('staticPage', staticPage.directory, ({to}) => ({
-        title: staticPage.name,
-        stylesheet: staticPage.stylesheet,
-
-        main: {
-            content: fixWS`
-                <div class="long-content">
-                    <h1>${staticPage.name}</h1>
-                    ${transformMultiline(staticPage.content, {strings, to})}
-                </div>
-            `
-        },
-
-        nav: {simple: true}
-    }));
-}
-
-
-function getRevealStringFromWarnings(warnings, {strings}) {
-    return strings('misc.contentWarnings', {warnings}) + `<br><span class="reveal-interaction">${strings('misc.contentWarnings.reveal')}</span>`
-}
-
-function getRevealStringFromTags(tags, {strings}) {
-    return tags && tags.some(tag => tag.isCW) && (
-        getRevealStringFromWarnings(strings.list.unit(tags.filter(tag => tag.isCW).map(tag => tag.name)), {strings}));
-}
-
-function generateCoverLink({
-    strings, to,
-    src,
-    alt,
-    tags = []
-}) {
-    return fixWS`
-        <div id="cover-art-container">
-            ${img({
-                src,
-                alt,
-                thumb: 'medium',
-                id: 'cover-art',
-                link: true,
-                square: true,
-                reveal: getRevealStringFromTags(tags, {strings})
-            })}
-            ${wikiInfo.features.artTagUI && tags.filter(tag => !tag.isCW).length && fixWS`
-                <p class="tags">
-                    ${strings('releaseInfo.artTags')}
-                    ${(tags
-                        .filter(tag => !tag.isCW)
-                        .map(tag => strings.link.tag(tag, {to}))
-                        .join(',\n'))}
-                </p>
-            `}
-        </div>
-    `;
-}
-
-// This function title is my gr8test work of art.
-// (The 8ehavior... well, um. Don't tell anyone, 8ut it's even 8etter.)
-/* // RIP, 2k20-2k20.
-function writeIndexAndTrackPagesForAlbum(album) {
-    return [
-        () => writeAlbumPage(album),
-        ...album.tracks.map(track => () => writeTrackPage(track))
-    ];
-}
-*/
-
-function writeAlbumPages() {
-    return albumData.map(writeAlbumPage);
-}
-
-function writeAlbumPage(album) {
-    const trackToListItem = (track, {strings, to}) => {
-        const itemOpts = {
-            duration: strings.count.duration(track.duration),
-            track: strings.link.track(track, {to})
-        };
-        return `<li style="${getLinkThemeString(track)}">${
-            (track.artists === album.artists
-                ? strings('trackList.item.withDuration', itemOpts)
-                : strings('trackList.item.withDuration.withArtists', {
-                    ...itemOpts,
-                    by: `<span class="by">${
-                        strings('trackList.item.withArtists.by', {
-                            artists: getArtistString(track.artists, {strings, to})
-                        })
-                    }</span>`
-                }))
-        }</li>`;
-    };
-
-    const commentaryEntries = [album, ...album.tracks].filter(x => x.commentary).length;
-    const albumDuration = getTotalDuration(album.tracks);
-
-    const listTag = getAlbumListTag(album);
-
-    const data = {
-        type: 'data',
-        path: ['album', album.directory],
-        data: () => ({
-            name: album.name,
-            directory: album.directory,
-            dates: {
-                released: album.date,
-                trackArtAdded: album.trackArtDate,
-                coverArtAdded: album.coverArtDate,
-                addedToWiki: album.dateAdded
-            },
-            duration: albumDuration,
-            color: album.color,
-            cover: serializeCover(album, getAlbumCover),
-            artists: serializeContribs(album.artists || []),
-            coverArtists: serializeContribs(album.coverArtists || []),
-            wallpaperArtists: serializeContribs(album.wallpaperArtists || []),
-            bannerArtists: serializeContribs(album.bannerArtists || []),
-            groups: serializeGroupsForAlbum(album),
-            trackGroups: album.trackGroups?.map(trackGroup => ({
-                name: trackGroup.name,
-                color: trackGroup.color,
-                tracks: trackGroup.tracks.map(track => track.directory)
-            })),
-            tracks: album.tracks.map(track => ({
-                link: serializeLink(track),
-                duration: track.duration
-            }))
-        })
-    };
-
-    const page = {type: 'page', path: ['album', album.directory], page: ({strings, to}) => ({
-        title: strings('albumPage.title', {album: album.name}),
-        stylesheet: getAlbumStylesheet(album, {to}),
-        theme: getThemeString(album, [
-            `--album-directory: ${album.directory}`
-        ]),
-
-        banner: album.bannerArtists && {
-            src: to('media.albumBanner', album.directory),
-            alt: strings('misc.alt.albumBanner'),
-            position: 'top'
-        },
-
-        main: {
-            content: fixWS`
-                ${generateCoverLink({
-                    strings, to,
-                    src: to('media.albumCover', album.directory),
-                    alt: strings('misc.alt.albumCover'),
-                    tags: album.artTags
-                })}
-                <h1>${strings('albumPage.title', {album: album.name})}</h1>
-                <p>
-                    ${[
-                        album.artists && strings('releaseInfo.by', {
-                            artists: getArtistString(album.artists, {
-                                strings, to,
-                                showContrib: true,
-                                showIcons: true
-                            })
-                        }),
-                        album.coverArtists && strings('releaseInfo.coverArtBy', {
-                            artists: getArtistString(album.coverArtists, {
-                                strings, to,
-                                showContrib: true,
-                                showIcons: true
-                            })
-                        }),
-                        album.wallpaperArtists && strings('releaseInfo.wallpaperArtBy', {
-                            artists: getArtistString(album.wallpaperArtists, {
-                                strings, to,
-                                showContrib: true,
-                                showIcons: true
-                            })
-                        }),
-                        album.bannerArtists && strings('releaseInfo.bannerArtBy', {
-                            artists: getArtistString(album.bannerArtists, {
-                                strings, to,
-                                showContrib: true,
-                                showIcons: true
-                            })
-                        }),
-                        strings('releaseInfo.released', {
-                            date: strings.count.date(album.date)
-                        }),
-                        +album.coverArtDate !== +album.date && strings('releaseInfo.artReleased', {
-                            date: strings.count.date(album.coverArtDate)
-                        }),
-                        strings('releaseInfo.duration', {
-                            duration: strings.count.duration(albumDuration, {approximate: album.tracks.length > 1})
-                        })
-                    ].filter(Boolean).join('<br>\n')}
-                </p>
-                ${commentaryEntries && `<p>${
-                    strings('releaseInfo.viewCommentary', {
-                        link: `<a href="${to('localized.albumCommentary', album.directory)}">${
-                            strings('releaseInfo.viewCommentary.link')
-                        }</a>`
-                    })
-                }</p>`}
-                ${album.urls.length && `<p>${
-                    strings('releaseInfo.listenOn', {
-                        links: strings.list.or(album.urls.map(url => fancifyURL(url, {album: true, strings})))
-                    })
-                }</p>`}
-                ${album.trackGroups ? fixWS`
-                    <dl class="album-group-list">
-                        ${album.trackGroups.map(({ name, color, startIndex, tracks }) => fixWS`
-                            <dt>${
-                                strings('trackList.group', {
-                                    duration: strings.count.duration(getTotalDuration(tracks), {approximate: tracks.length > 1}),
-                                    group: name
-                                })
-                            }</dt>
-                            <dd><${listTag === 'ol' ? `ol start="${startIndex + 1}"` : listTag}>
-                                ${tracks.map(t => trackToListItem(t, {strings, to})).join('\n')}
-                            </${listTag}></dd>
-                        `).join('\n')}
-                    </dl>
-                ` : fixWS`
-                    <${listTag}>
-                        ${album.tracks.map(t => trackToListItem(t, {strings, to})).join('\n')}
-                    </${listTag}>
-                `}
-                <p>
-                    ${[
-                        strings('releaseInfo.addedToWiki', {
-                            date: strings.count.date(album.dateAdded)
-                        })
-                    ].filter(Boolean).join('<br>\n')}
-                </p>
-                ${album.commentary && fixWS`
-                    <p>${strings('releaseInfo.artistCommentary')}</p>
-                    <blockquote>
-                        ${transformMultiline(album.commentary, {strings, to})}
-                    </blockquote>
-                `}
-            `
-        },
-
-        sidebarLeft: generateSidebarForAlbum(album, null, {strings, to}),
-
-        nav: {
-            links: [
-                {
-                    href: to('localized.home'),
-                    title: wikiInfo.shortName
-                },
-                {
-                    html: strings('albumPage.nav.album', {
-                        album: strings.link.album(album, {class: 'current', to})
-                    })
-                },
-                {
-                    divider: false,
-                    html: generateAlbumNavLinks(album, null, {strings, to})
-                }
-            ],
-            content: fixWS`
-                <div>
-                    ${generateAlbumChronologyLinks(album, null, {strings, to})}
-                </div>
-            `
-        }
-    })};
-
-    return [page, data];
-}
-
-function getAlbumStylesheet(album, {to}) {
-    return [
-        album.wallpaperArtists && fixWS`
-            body::before {
-                background-image: url("${to('media.albumWallpaper', album.directory)}");
-                ${album.wallpaperStyle}
-            }
-        `,
-        album.bannerStyle && fixWS`
-            #banner img {
-                ${album.bannerStyle}
-            }
-        `
-    ].filter(Boolean).join('\n');
-}
-
-function writeTrackPages() {
-    return trackData.map(writeTrackPage);
-}
-
-function writeTrackPage(track) {
-    const { album } = track;
-
-    const tracksThatReference = track.referencedBy;
-    const useDividedReferences = groupData.some(group => group.directory === C.OFFICIAL_GROUP_DIRECTORY);
-    const ttrFanon = (useDividedReferences &&
-        tracksThatReference.filter(t => t.album.groups.every(group => group.directory !== C.OFFICIAL_GROUP_DIRECTORY)));
-    const ttrOfficial = (useDividedReferences &&
-        tracksThatReference.filter(t => t.album.groups.some(group => group.directory === C.OFFICIAL_GROUP_DIRECTORY)));
-
-    const tracksReferenced = track.references;
-    const otherReleases = track.otherReleases;
-    const listTag = getAlbumListTag(album);
-
-    let flashesThatFeature;
-    if (wikiInfo.features.flashesAndGames) {
-        flashesThatFeature = C.sortByDate([track, ...otherReleases]
-            .flatMap(track => track.flashes.map(flash => ({flash, as: track}))));
-    }
-
-    const generateTrackList = (tracks, {strings, to}) => html.tag('ul',
-        tracks.map(track => {
-            const line = strings('trackList.item.withArtists', {
-                track: strings.link.track(track, {to}),
-                by: `<span class="by">${strings('trackList.item.withArtists.by', {
-                    artists: getArtistString(track.artists, {strings, to})
-                })}</span>`
-            });
-            return (track.aka
-                ? `<li class="rerelease">${strings('trackList.item.rerelease', {track: line})}</li>`
-                : `<li>${line}</li>`);
-        })
-    );
-
-    const hasCommentary = track.commentary || otherReleases.some(t => t.commentary);
-    const generateCommentary = ({strings, to}) => transformMultiline(
-        [
-            track.commentary,
-            ...otherReleases.map(track =>
-                (track.commentary?.split('\n')
-                    .filter(line => line.replace(/<\/b>/g, '').includes(':</i>'))
-                    .map(line => fixWS`
-                        ${line}
-                        ${strings('releaseInfo.artistCommentary.seeOriginalRelease', {
-                            original: strings.link.track(track, {to})
-                        })}
-                    `)
-                    .join('\n')))
-        ].filter(Boolean).join('\n'),
-        {strings, to});
-
-    const data = {
-        type: 'data',
-        path: ['track', track.directory],
-        data: () => ({
-            name: track.name,
-            directory: track.directory,
-            dates: {
-                released: track.date,
-                originallyReleased: track.originalDate,
-                coverArtAdded: track.coverArtDate
-            },
-            duration: track.duration,
-            color: track.color,
-            cover: serializeCover(track, getTrackCover),
-            artists: serializeContribs(track.artists),
-            contributors: serializeContribs(track.contributors),
-            coverArtists: serializeContribs(track.coverArtists || []),
-            album: serializeLink(track.album),
-            groups: serializeGroupsForTrack(track),
-            references: track.references.map(serializeLink),
-            referencedBy: track.referencedBy.map(serializeLink),
-            alsoReleasedAs: otherReleases.map(track => ({
-                track: serializeLink(track),
-                album: serializeLink(track.album)
-            }))
-        })
-    };
-
-    const page = {type: 'page', path: ['track', track.directory], page: ({strings, to}) => ({
-        title: strings('trackPage.title', {track: track.name}),
-        stylesheet: getAlbumStylesheet(album, {to}),
-        theme: getThemeString(track, [
-            `--album-directory: ${album.directory}`,
-            `--track-directory: ${track.directory}`
-        ]),
-
-        // disabled for now! shifting banner position per height of page is disorienting
-        /*
-        banner: album.bannerArtists && {
-            classes: ['dim'],
-            src: to('media.albumBanner', album.directory),
-            alt: strings('misc.alt.albumBanner'),
-            position: 'bottom'
-        },
-        */
-
-        main: {
-            content: fixWS`
-                ${generateCoverLink({
-                    strings, to,
-                    src: getTrackCover(track, {to}),
-                    alt: strings('misc.alt.trackCover'),
-                    tags: track.artTags
-                })}
-                <h1>${strings('trackPage.title', {track: track.name})}</h1>
-                <p>
-                    ${[
-                        strings('releaseInfo.by', {
-                            artists: getArtistString(track.artists, {
-                                strings, to,
-                                showContrib: true,
-                                showIcons: true
-                            })
-                        }),
-                        track.coverArtists && strings('releaseInfo.coverArtBy', {
-                            artists: getArtistString(track.coverArtists, {
-                                strings, to,
-                                showContrib: true,
-                                showIcons: true
-                            })
-                        }),
-                        album.directory !== C.UNRELEASED_TRACKS_DIRECTORY && strings('releaseInfo.released', {
-                            date: strings.count.date(track.date)
-                        }),
-                        +track.coverArtDate !== +track.date && strings('releaseInfo.artReleased', {
-                            date: strings.count.date(track.coverArtDate)
-                        }),
-                        track.duration && strings('releaseInfo.duration', {
-                            duration: strings.count.duration(track.duration)
-                        })
-                    ].filter(Boolean).join('<br>\n')}
-                </p>
-                <p>${
-                    (track.urls.length
-                        ? strings('releaseInfo.listenOn', {
-                            links: strings.list.or(track.urls.map(url => fancifyURL(url, {strings})))
-                        })
-                        : strings('releaseInfo.listenOn.noLinks'))
-                }</p>
-                ${otherReleases.length && fixWS`
-                    <p>${strings('releaseInfo.alsoReleasedAs')}</p>
-                    <ul>
-                        ${otherReleases.map(track => fixWS`
-                            <li>${strings('releaseInfo.alsoReleasedAs.item', {
-                                track: strings.link.track(track, {to}),
-                                album: strings.link.album(track.album, {to})
-                            })}</li>
-                        `).join('\n')}
-                    </ul>
-                `}
-                ${track.contributors.textContent && fixWS`
-                    <p>
-                        ${strings('releaseInfo.contributors')}
-                        <br>
-                        ${transformInline(track.contributors.textContent, {strings, to})}
-                    </p>
-                `}
-                ${track.contributors.length && fixWS`
-                    <p>${strings('releaseInfo.contributors')}</p>
-                    <ul>
-                        ${(track.contributors
-                            .map(contrib => `<li>${getArtistString([contrib], {
-                                strings, to,
-                                showContrib: true,
-                                showIcons: true
-                            })}</li>`)
-                            .join('\n'))}
-                    </ul>
-                `}
-                ${tracksReferenced.length && fixWS`
-                    <p>${strings('releaseInfo.tracksReferenced', {track: `<i>${track.name}</i>`})}</p>
-                    ${generateTrackList(tracksReferenced, {strings, to})}
-                `}
-                ${tracksThatReference.length && fixWS`
-                    <p>${strings('releaseInfo.tracksThatReference', {track: `<i>${track.name}</i>`})}</p>
-                    ${useDividedReferences && fixWS`
-                        <dl>
-                            ${ttrOfficial.length && fixWS`
-                                <dt>${strings('trackPage.referenceList.official')}</dt>
-                                <dd>${generateTrackList(ttrOfficial, {strings, to})}</dd>
-                            `}
-                            ${ttrFanon.length && fixWS`
-                                <dt>${strings('trackPage.referenceList.fandom')}</dt>
-                                <dd>${generateTrackList(ttrFanon, {strings, to})}</dd>
-                            `}
-                        </dl>
-                    `}
-                    ${!useDividedReferences && generateTrackList(tracksThatReference, {strings, to})}
-                `}
-                ${wikiInfo.features.flashesAndGames && flashesThatFeature.length && fixWS`
-                    <p>${strings('releaseInfo.flashesThatFeature', {track: `<i>${track.name}</i>`})}</p>
-                    <ul>
-                        ${flashesThatFeature.map(({ flash, as }) => fixWS`
-                            <li ${classes(as !== track && 'rerelease')}>${
-                                (as === track
-                                    ? strings('releaseInfo.flashesThatFeature.item', {
-                                        flash: strings.link.flash(flash, {to})
-                                    })
-                                    : strings('releaseInfo.flashesThatFeature.item.asDifferentRelease', {
-                                        flash: strings.link.flash(flash, {to}),
-                                        track: strings.link.track(as, {to})
-                                    }))
-                            }</li>
-                        `).join('\n')}
-                    </ul>
-                `}
-                ${track.lyrics && fixWS`
-                    <p>${strings('releaseInfo.lyrics')}</p>
-                    <blockquote>
-                        ${transformLyrics(track.lyrics, {strings, to})}
-                    </blockquote>
-                `}
-                ${hasCommentary && fixWS`
-                    <p>${strings('releaseInfo.artistCommentary')}</p>
-                    <blockquote>
-                        ${generateCommentary({strings, to})}
-                    </blockquote>
-                `}
-            `
-        },
-
-        sidebarLeft: generateSidebarForAlbum(album, track, {strings, to}),
-
-        nav: {
-            links: [
-                {
-                    href: to('localized.home'),
-                    title: wikiInfo.shortName
-                },
-                {
-                    href: to('localized.album', album.directory),
-                    title: album.name
-                },
-                listTag === 'ol' ? {
-                    html: strings('trackPage.nav.track.withNumber', {
-                        number: album.tracks.indexOf(track) + 1,
-                        track: strings.link.track(track, {class: 'current', to})
-                    })
-                } : {
-                    html: strings('trackPage.nav.track', {
-                        track: strings.link.track(track, {class: 'current', to})
-                    })
-                },
-                {
-                    divider: false,
-                    html: generateAlbumNavLinks(album, track, {strings, to})
-                }
-            ].filter(Boolean),
-            content: fixWS`
-                <div>
-                    ${generateAlbumChronologyLinks(album, track, {strings, to})}
-                </div>
-            `
-        }
-    })};
-
-    return [data, page];
-}
-
-function writeArtistPages() {
-    return [
-        ...artistData.map(writeArtistPage),
-        ...artistAliasData.map(writeArtistAliasPage)
-    ];
-}
-
-function writeArtistPage(artist) {
-    const {
-        name,
-        urls = [],
-        note = ''
-    } = artist;
-
-    const artThingsAll = C.sortByDate(unique([...artist.albums.asCoverArtist, ...artist.albums.asWallpaperArtist, ...artist.albums.asBannerArtist, ...artist.tracks.asCoverArtist]));
-    const artThingsGallery = C.sortByDate([...artist.albums.asCoverArtist, ...artist.tracks.asCoverArtist]);
-    const commentaryThings = C.sortByDate([...artist.albums.asCommentator, ...artist.tracks.asCommentator]);
-
-    const hasGallery = artThingsGallery.length > 0;
-
-    const getArtistsAndContrib = (thing, key) => ({
-        artists: thing[key]?.filter(({ who }) => who !== artist),
-        contrib: thing[key]?.find(({ who }) => who === artist),
-        thing,
-        key
-    });
-
-    const artListChunks = chunkByProperties(artThingsAll.flatMap(thing =>
-        (['coverArtists', 'wallpaperArtists', 'bannerArtists']
-            .map(key => getArtistsAndContrib(thing, key))
-            .filter(({ contrib }) => contrib)
-            .map(props => ({
-                album: thing.album || thing,
-                track: thing.album ? thing : null,
-                date: +(thing.coverArtDate || thing.date),
-                ...props
-            })))
-    ), ['date', 'album']);
-
-    const commentaryListChunks = chunkByProperties(commentaryThings.map(thing => ({
-        album: thing.album || thing,
-        track: thing.album ? thing : null
-    })), ['album']);
-
-    const allTracks = C.sortByDate(unique([...artist.tracks.asArtist, ...artist.tracks.asContributor]));
-    const unreleasedTracks = allTracks.filter(track => track.album.directory === C.UNRELEASED_TRACKS_DIRECTORY);
-    const releasedTracks = allTracks.filter(track => track.album.directory !== C.UNRELEASED_TRACKS_DIRECTORY);
-
-    const chunkTracks = tracks => (
-        chunkByProperties(tracks.map(track => ({
-            track,
-            date: +track.date,
-            album: track.album,
-            duration: track.duration,
-            artists: (track.artists.some(({ who }) => who === artist)
-                ? track.artists.filter(({ who }) => who !== artist)
-                : track.contributors.filter(({ who }) => who !== artist)),
-            contrib: {
-                who: artist,
-                what: [
-                    track.artists.find(({ who }) => who === artist)?.what,
-                    track.contributors.find(({ who }) => who === artist)?.what
-                ].filter(Boolean).join(', ')
-            }
-        })), ['date', 'album'])
-        .map(({date, album, chunk}) => ({
-            date, album, chunk,
-            duration: getTotalDuration(chunk),
-        })));
-
-    const unreleasedTrackListChunks = chunkTracks(unreleasedTracks);
-    const releasedTrackListChunks = chunkTracks(releasedTracks);
-
-    const totalReleasedDuration = getTotalDuration(releasedTracks);
-
-    const countGroups = things => {
-        const usedGroups = things.flatMap(thing => thing.groups || thing.album?.groups || []);
-        return groupData
-            .map(group => ({
-                group,
-                contributions: usedGroups.filter(g => g === group).length
-            }))
-            .filter(({ contributions }) => contributions > 0)
-            .sort((a, b) => b.contributions - a.contributions);
-    };
-
-    const musicGroups = countGroups(releasedTracks);
-    const artGroups = countGroups(artThingsAll);
-
-    let flashes, flashListChunks;
-    if (wikiInfo.features.flashesAndGames) {
-        flashes = C.sortByDate(artist.flashes.asContributor.slice());
-        flashListChunks = (
-            chunkByProperties(flashes.map(flash => ({
-                act: flash.act,
-                flash,
-                date: flash.date,
-                // Manual artists/contrib properties here, 8ecause we don't
-                // want to show the full list of other contri8utors inline.
-                // (It can often 8e very, very large!)
-                artists: [],
-                contrib: flash.contributors.find(({ who }) => who === artist)
-            })), ['act'])
-            .map(({ act, chunk }) => ({
-                act, chunk,
-                dateFirst: chunk[0].date,
-                dateLast: chunk[chunk.length - 1].date
-            })));
-    }
-
-    const generateEntryAccents = ({ aka, entry, artists, contrib, strings, to }) =>
-        (aka
-            ? strings('artistPage.creditList.entry.rerelease', {entry})
-            : (artists.length
-                ? (contrib.what
-                    ? strings('artistPage.creditList.entry.withArtists.withContribution', {
-                        entry,
-                        artists: getArtistString(artists, {strings, to}),
-                        contribution: contrib.what
-                    })
-                    : strings('artistPage.creditList.entry.withArtists', {
-                        entry,
-                        artists: getArtistString(artists, {strings, to})
-                    }))
-                : (contrib.what
-                    ? strings('artistPage.creditList.entry.withContribution', {
-                        entry,
-                        contribution: contrib.what
-                    })
-                    : entry)));
-
-    const generateTrackList = (chunks, {strings, to}) => fixWS`
-        <dl>
-            ${chunks.map(({date, album, chunk, duration}) => fixWS`
-                <dt>${strings('artistPage.creditList.album.withDate.withDuration', {
-                    album: strings.link.album(album, {to}),
-                    date: strings.count.date(date),
-                    duration: strings.count.duration(duration, {approximate: true})
-                })}</dt>
-                <dd><ul>
-                    ${(chunk
-                        .map(({track, ...props}) => ({
-                            aka: track.aka,
-                            entry: strings('artistPage.creditList.entry.track.withDuration', {
-                                track: strings.link.track(track, {to}),
-                                duration: strings.count.duration(track.duration, {to})
-                            }),
-                            ...props
-                        }))
-                        .map(({aka, ...opts}) => `<li ${classes(aka && 'rerelease')}>${generateEntryAccents({strings, to, aka, ...opts})}</li>`)
-                        .join('\n'))}
-                </ul></dd>
-            `).join('\n')}
-        </dl>
-    `;
-
-    const serializeArtistsAndContrib = key => thing => {
-        const { artists, contrib } = getArtistsAndContrib(thing, key);
-        const ret = {};
-        ret.link = serializeLink(thing);
-        if (contrib.what) ret.contribution = contrib.what;
-        if (artists.length) ret.otherArtists = serializeContribs(artists);
-        return ret;
-    };
-
-    const serializeTrackListChunks = chunks =>
-        chunks.map(({date, album, chunk, duration}) => ({
-            album: serializeLink(album),
-            date,
-            duration,
-            tracks: chunk.map(({ track }) => ({
-                link: serializeLink(track),
-                duration: track.duration
-            }))
-        }));
-
-    const data = {
-        type: 'data',
-        path: ['artist', artist.directory],
-        data: () => ({
-            albums: {
-                asCoverArtist: artist.albums.asCoverArtist.map(serializeArtistsAndContrib('coverArtists')),
-                asWallpaperArtist: artist.albums.asWallpaperArtist.map(serializeArtistsAndContrib('wallpaperArtists')),
-                asBannerArtist: artist.albums.asBannerArtist.map(serializeArtistsAndContrib('bannerArtists'))
-            },
-            flashes: wikiInfo.features.flashesAndGames ? {
-                asContributor: artist.flashes.asContributor
-                    .map(flash => getArtistsAndContrib(flash, 'contributors'))
-                    .map(({ contrib, thing: flash }) => ({
-                        link: serializeLink(flash),
-                        contribution: contrib.what
-                    }))
-            } : null,
-            tracks: {
-                asArtist: artist.tracks.asArtist.map(serializeArtistsAndContrib('artists')),
-                asContributor: artist.tracks.asContributor.map(serializeArtistsAndContrib('contributors')),
-                chunked: {
-                    released: serializeTrackListChunks(releasedTrackListChunks),
-                    unreleased: serializeTrackListChunks(unreleasedTrackListChunks)
-                }
-            }
-        })
-    };
-
-    const infoPage = {
-        type: 'page',
-        path: ['artist', artist.directory],
-        page: ({strings, to}) => ({
-            title: strings('artistPage.title', {artist: name}),
-
-            main: {
-                content: fixWS`
-                    ${artist.hasAvatar && generateCoverLink({
-                        strings, to,
-                        src: to('localized.artistAvatar', artist.directory),
-                        alt: strings('misc.alt.artistAvatar')
-                    })}
-                    <h1>${strings('artistPage.title', {artist: name})}</h1>
-                    ${note && fixWS`
-                        <p>${strings('releaseInfo.note')}</p>
-                        <blockquote>
-                            ${transformMultiline(note, {strings, to})}
-                        </blockquote>
-                        <hr>
-                    `}
-                    ${urls.length && `<p>${strings('releaseInfo.visitOn', {
-                        links: strings.list.or(urls.map(url => fancifyURL(url, {strings})))
-                    })}</p>`}
-                    ${hasGallery && `<p>${strings('artistPage.viewArtGallery', {
-                        link: strings.link.artistGallery(artist, {
-                            to,
-                            text: strings('artistPage.viewArtGallery.link')
-                        })
-                    })}</p>`}
-                    <p>${strings('misc.jumpTo.withLinks', {
-                        links: strings.list.unit([
-                            [
-                                [...releasedTracks, ...unreleasedTracks].length && `<a href="#tracks">${strings('artistPage.trackList.title')}</a>`,
-                                unreleasedTracks.length && `(<a href="#unreleased-tracks">${strings('artistPage.unreleasedTrackList.title')}</a>)`
-                            ].filter(Boolean).join(' '),
-                            artThingsAll.length && `<a href="#art">${strings('artistPage.artList.title')}</a>`,
-                            wikiInfo.features.flashesAndGames && flashes.length && `<a href="#flashes">${strings('artistPage.flashList.title')}</a>`,
-                            commentaryThings.length && `<a href="#commentary">${strings('artistPage.commentaryList.title')}</a>`
-                        ].filter(Boolean))
-                    })}</p>
-                    ${(releasedTracks.length || unreleasedTracks.length) && fixWS`
-                        <h2 id="tracks">${strings('artistPage.trackList.title')}</h2>
-                    `}
-                    ${releasedTracks.length && fixWS`
-                        <p>${strings('artistPage.contributedDurationLine', {
-                            artist: artist.name,
-                            duration: strings.count.duration(totalReleasedDuration, {approximate: true, unit: true})
-                        })}</p>
-                        <p>${strings('artistPage.musicGroupsLine', {
-                            groups: strings.list.unit(musicGroups
-                                .map(({ group, contributions }) => strings('artistPage.groupsLine.item', {
-                                    group: strings.link.groupInfo(group, {to}),
-                                    contributions: strings.count.contributions(contributions)
-                                })))
-                        })}</p>
-                        ${generateTrackList(releasedTrackListChunks, {strings, to})}
-                    `}
-                    ${unreleasedTracks.length && fixWS`
-                        <h3 id="unreleased-tracks">${strings('artistPage.unreleasedTrackList.title')}</h3>
-                        ${generateTrackList(unreleasedTrackListChunks, {strings, to})}
-                    `}
-                    ${artThingsAll.length && fixWS`
-                        <h2 id="art">${strings('artistPage.artList.title')}</h2>
-                        ${hasGallery && `<p>${strings('artistPage.viewArtGallery.orBrowseList', {
-                            link: strings.link.artistGallery(artist, {
-                                to,
-                                text: strings('artistPage.viewArtGallery.link')
-                            })
-                        })}</p>`}
-                        <p>${strings('artistPage.artGroupsLine', {
-                            groups: strings.list.unit(artGroups
-                                .map(({ group, contributions }) => strings('artistPage.groupsLine.item', {
-                                    group: strings.link.groupInfo(group, {to}),
-                                    contributions: strings.count.contributions(contributions)
-                                })))
-                        })}</p>
-                        <dl>
-                            ${artListChunks.map(({date, album, chunk}) => fixWS`
-                                <dt>${strings('artistPage.creditList.album.withDate', {
-                                    album: strings.link.album(album, {to}),
-                                    date: strings.count.date(date)
-                                })}</dt>
-                                <dd><ul>
-                                    ${(chunk
-                                        .map(({album, track, key, ...props}) => ({
-                                            entry: (track
-                                                ? strings('artistPage.creditList.entry.track', {
-                                                    track: strings.link.track(track, {to})
-                                                })
-                                                : `<i>${strings('artistPage.creditList.entry.album.' + {
-                                                    wallpaperArtists: 'wallpaperArt',
-                                                    bannerArtists: 'bannerArt',
-                                                    coverArtists: 'coverArt'
-                                                }[key])}</i>`),
-                                            ...props
-                                        }))
-                                        .map(opts => generateEntryAccents({strings, to, ...opts}))
-                                        .map(row => `<li>${row}</li>`)
-                                        .join('\n'))}
-                                </ul></dd>
-                            `).join('\n')}
-                        </dl>
-                    `}
-                    ${wikiInfo.features.flashesAndGames && flashes.length && fixWS`
-                        <h2 id="flashes">${strings('artistPage.flashList.title')}</h2>
-                        <dl>
-                            ${flashListChunks.map(({act, chunk, dateFirst, dateLast}) => fixWS`
-                                <dt>${strings('artistPage.creditList.flashAct.withDateRange', {
-                                    act: strings.link.flash(chunk[0].flash, {to, text: act.name}),
-                                    dateRange: strings.count.dateRange([dateFirst, dateLast])
-                                })}</dt>
-                                <dd><ul>
-                                    ${(chunk
-                                        .map(({flash, ...props}) => ({
-                                            entry: strings('artistPage.creditList.entry.flash', {
-                                                flash: strings.link.flash(flash, {to})
-                                            }),
-                                            ...props
-                                        }))
-                                        .map(opts => generateEntryAccents({strings, to, ...opts}))
-                                        .map(row => `<li>${row}</li>`)
-                                        .join('\n'))}
-                                </ul></dd>
-                            `).join('\n')}
-                        </dl>
-                    `}
-                    ${commentaryThings.length && fixWS`
-                        <h2 id="commentary">${strings('artistPage.commentaryList.title')}</h2>
-                        <dl>
-                            ${commentaryListChunks.map(({album, chunk}) => fixWS`
-                                <dt>${strings('artistPage.creditList.album', {
-                                    album: strings.link.album(album, {to})
-                                })}</dt>
-                                <dd><ul>
-                                    ${(chunk
-                                        .map(({album, track, ...props}) => track
-                                            ? strings('artistPage.creditList.entry.track', {
-                                                track: strings.link.track(track, {to})
-                                            })
-                                            : `<i>${strings('artistPage.creditList.entry.album.commentary')}</i>`)
-                                        .map(row => `<li>${row}</li>`)
-                                        .join('\n'))}
-                                </ul></dd>
-                            `).join('\n')}
-                        </dl>
-                    `}
-                `
-            },
-
-            nav: generateNavForArtist(artist, {strings, to, isGallery: false, hasGallery})
-        })
-    };
-
-    const galleryPage = hasGallery && {
-        type: 'page',
-        path: ['artistGallery', artist.directory],
-        page: ({strings, to}) => ({
-            title: strings('artistGalleryPage.title', {artist: name}),
-
-            main: {
-                classes: ['top-index'],
-                content: fixWS`
-                    <h1>${strings('artistGalleryPage.title', {artist: name})}</h1>
-                    <p class="quick-info">${strings('artistGalleryPage.infoLine', {
-                        coverArts: strings.count.coverArts(artThingsGallery.length, {unit: true})
-                    })}</p>
-                    <div class="grid-listing">
-                        ${getGridHTML({
-                            strings, to,
-                            entries: artThingsGallery.map(item => ({item})),
-                            srcFn: thing => (thing.album
-                                ? getTrackCover(thing, {to})
-                                : getAlbumCover(thing, {to})),
-                            hrefFn: thing => (thing.album
-                                ? to('localized.track', thing.directory)
-                                : to('localized.album', thing.directory))
-                        })}
-                    </div>
-                `
-            },
-
-            nav: generateNavForArtist(artist, {strings, to, isGallery: true, hasGallery})
-        })
-    };
-
-    return [data, infoPage, galleryPage].filter(Boolean);
-}
-
-function generateNavForArtist(artist, {strings, to, isGallery, hasGallery}) {
-    const infoGalleryLinks = (hasGallery &&
-        generateInfoGalleryLinks('artist', 'artistGallery', artist, isGallery, {strings, to}))
-
-    return {
-        links: [
-            {
-                href: to('localized.home'),
-                title: wikiInfo.shortName
-            },
-            wikiInfo.features.listings &&
-            {
-                href: to('localized.listingIndex'),
-                title: strings('listingIndex.title')
-            },
-            {
-                html: strings('artistPage.nav.artist', {
-                    artist: strings.link.artist(artist, {class: 'current', to})
-                })
-            },
-            hasGallery &&
-            {
-                divider: false,
-                html: `(${infoGalleryLinks})`
-            }
-        ]
-    };
-}
-
-function writeArtistAliasPage(artist) {
-    const { alias } = artist;
-
-    return async ({baseDirectory, strings, writePage}) => {
-        const { code } = strings;
-        const paths = writePage.paths(baseDirectory, 'artist', alias.directory);
-        const content = generateRedirectPage(alias.name, paths.pathname, {strings});
-        await writePage.write(content, {paths});
-    };
-}
-
-function generateRedirectPage(title, target, {strings}) {
-    return fixWS`
-        <!DOCTYPE html>
-        <html>
-            <head>
-                <title>${strings('redirectPage.title', {title})}</title>
-                <meta charset="utf-8">
-                <meta http-equiv="refresh" content="0;url=${target}">
-                <link rel="canonical" href="${target}">
-                <link rel="stylesheet" href="static/site-basic.css">
-            </head>
-            <body>
-                <main>
-                    <h1>${strings('redirectPage.title', {title})}</h1>
-                    <p>${strings('redirectPage.infoLine', {
-                        target: `<a href="${target}">${target}</a>`
-                    })}</p>
-                </main>
-            </body>
-        </html>
-    `;
-}
-
-function writeFlashPages() {
-    if (!wikiInfo.features.flashesAndGames) {
-        return;
-    }
-
-    return [
-        writeFlashIndex(),
-        ...flashData.map(writeFlashPage)
-    ];
-}
-
-function writeFlashIndex() {
-    return ({strings, writePage}) => writePage('flashIndex', '', ({to}) => ({
-        title: strings('flashIndex.title'),
-
-        main: {
-            classes: ['flash-index'],
-            content: fixWS`
-                <h1>${strings('flashIndex.title')}</h1>
-                <div class="long-content">
-                    <p class="quick-info">${strings('misc.jumpTo')}</p>
-                    <ul class="quick-info">
-                        ${flashActData.filter(act => act.jump).map(({ anchor, jump, jumpColor }) => fixWS`
-                            <li><a href="#${anchor}" style="${getLinkThemeString({color: jumpColor})}">${jump}</a></li>
-                        `).join('\n')}
-                    </ul>
-                </div>
-                ${flashActData.map((act, i) => fixWS`
-                    <h2 id="${act.anchor}" style="${getLinkThemeString(act)}"><a href="${to('localized.flash', act.flashes[0].directory)}">${act.name}</a></h2>
-                    <div class="grid-listing">
-                        ${getFlashGridHTML({
-                            strings, to,
-                            entries: act.flashes.map(flash => ({item: flash})),
-                            lazy: i === 0 ? 4 : true
-                        })}
-                    </div>
-                `).join('\n')}
-            `
-        },
-
-        nav: {simple: true}
-    }));
-}
-
-function writeFlashPage(flash) {
-    return ({strings, writePage}) => writePage('flash', flash.directory, ({to}) => ({
-        title: strings('flashPage.title', {flash: flash.name}),
-        theme: getThemeString(flash, [
-            `--flash-directory: ${flash.directory}`
-        ]),
-
-        main: {
-            content: fixWS`
-                <h1>${strings('flashPage.title', {flash: flash.name})}</h1>
-                ${generateCoverLink({
-                    strings, to,
-                    src: to('media.flashArt', flash.directory),
-                    alt: strings('misc.alt.flashArt')
-                })}
-                <p>${strings('releaseInfo.released', {date: strings.count.date(flash.date)})}</p>
-                ${(flash.page || flash.urls.length) && `<p>${strings('releaseInfo.playOn', {
-                    links: strings.list.or([
-                        flash.page && getFlashLink(flash),
-                        ...flash.urls
-                    ].map(url => fancifyFlashURL(url, flash, {strings})))
-                })}</p>`}
-                ${flash.tracks.length && fixWS`
-                    <p>Tracks featured in <i>${flash.name.replace(/\.$/, '')}</i>:</p>
-                    <ul>
-                        ${(flash.tracks
-                            .map(track => strings('trackList.item.withArtists', {
-                                track: strings.link.track(track, {strings, to}),
-                                by: `<span class="by">${
-                                    strings('trackList.item.withArtists.by', {
-                                        artists: getArtistString(track.artists, {strings, to})
-                                    })
-                                }</span>`
-                            }))
-                            .map(row => `<li>${row}</li>`)
-                            .join('\n'))}
-                    </ul>
-                `}
-                ${flash.contributors.textContent && fixWS`
-                    <p>
-                        ${strings('releaseInfo.contributors')}
-                        <br>
-                        ${transformInline(flash.contributors.textContent, {strings, to})}
-                    </p>
-                `}
-                ${flash.contributors.length && fixWS`
-                    <p>${strings('releaseInfo.contributors')}</p>
-                    <ul>
-                        ${flash.contributors
-                            .map(contrib => `<li>${getArtistString([contrib], {
-                                strings, to,
-                                showContrib: true,
-                                showIcons: true
-                            })}</li>`)
-                            .join('\n')}
-                    </ul>
-                `}
-            `
-        },
-
-        sidebarLeft: generateSidebarForFlash(flash, {strings, to}),
-        nav: generateNavForFlash(flash, {strings, to})
-    }));
-}
-
-function generateNavForFlash(flash, {strings, to}) {
-    const previousNextLinks = generatePreviousNextLinks('localized.flash', flash, flashData, {strings, to});
-
-    return {
-        links: [
-            {
-                href: to('localized.home'),
-                title: wikiInfo.shortName
-            },
-            {
-                href: to('localized.flashIndex'),
-                title: strings('flashIndex.title')
-            },
-            {
-                html: strings('flashPage.nav.flash', {
-                    flash: strings.link.flash(flash, {class: 'current', to})
-                })
-            },
-            previousNextLinks &&
-            {
-                divider: false,
-                html: `(${previousNextLinks})`
-            }
-        ],
-
-        content: fixWS`
-            <div>
-                ${chronologyLinks(flash, {
-                    strings, to,
-                    headingString: 'misc.chronology.heading.flash',
-                    contribKey: 'contributors',
-                    getThings: artist => artist.flashes.asContributor
-                })}
-            </div>
-        `
-    };
-}
-
-function generateSidebarForFlash(flash, {strings, to}) {
-    // all hard-coded, sorry :(
-    // this doesnt have a super portable implementation/design...yet!!
-
-    const act6 = flashActData.findIndex(act => act.name.startsWith('Act 6'));
-    const postCanon = flashActData.findIndex(act => act.name.includes('Post Canon'));
-    const outsideCanon = postCanon + flashActData.slice(postCanon).findIndex(act => !act.name.includes('Post Canon'));
-    const actIndex = flashActData.indexOf(flash.act);
-    const side = (
-        (actIndex < 0) ? 0 :
-        (actIndex < act6) ? 1 :
-        (actIndex <= outsideCanon) ? 2 :
-        3
-    );
-    const currentAct = flash && flash.act;
-
-    return {
-        content: fixWS`
-            <h1>${strings.link.flashIndex('', {to, text: strings('flashIndex.title')})}</h1>
-            <dl>
-                ${flashActData.filter(act =>
-                    act.name.startsWith('Act 1') ||
-                    act.name.startsWith('Act 6 Act 1') ||
-                    act.name.startsWith('Hiveswap') ||
-                    // Sorry not sorry -Yiffy
-                    (({index = flashActData.indexOf(act)} = {}) => (
-                        index < act6 ? side === 1 :
-                        index < outsideCanon ? side === 2 :
-                        true
-                    ))()
-                ).flatMap(act => [
-                    act.name.startsWith('Act 1') && `<dt ${classes('side', side === 1 && 'current')}><a href="${to('localized.flash', act.flashes[0].directory)}" style="--primary-color: #4ac925">Side 1 (Acts 1-5)</a></dt>`
-                    || act.name.startsWith('Act 6 Act 1') && `<dt ${classes('side', side === 2 && 'current')}><a href="${to('localized.flash', act.flashes[0].directory)}" style="--primary-color: #1076a2">Side 2 (Acts 6-7)</a></dt>`
-                    || act.name.startsWith('Hiveswap Act 1') && `<dt ${classes('side', side === 3 && 'current')}><a href="${to('localized.flash', act.flashes[0].directory)}" style="--primary-color: #008282">Outside Canon (Misc. Games)</a></dt>`,
-                    (({index = flashActData.indexOf(act)} = {}) => (
-                        index < act6 ? side === 1 :
-                        index < outsideCanon ? side === 2 :
-                        true
-                    ))()
-                    && `<dt ${classes(act === currentAct && 'current')}><a href="${to('localized.flash', act.flashes[0].directory)}" style="${getLinkThemeString(act)}">${act.name}</a></dt>`,
-                    act === currentAct && fixWS`
-                        <dd><ul>
-                            ${act.flashes.map(f => fixWS`
-                                <li ${classes(f === flash && 'current')}>${strings.link.flash(f, {to})}</li>
-                            `).join('\n')}
-                        </ul></dd>
-                    `
-                ]).filter(Boolean).join('\n')}
-            </dl>
-        `
-    };
-}
-
-const listingSpec = [
-    {
-        directory: 'albums/by-name',
-        title: ({strings}) => strings('listingPage.listAlbums.byName.title'),
-
-        data() {
-            return albumData.slice()
-                .sort(sortByName);
-        },
-
-        row(album, {strings, to}) {
-            return strings('listingPage.listAlbums.byName.item', {
-                album: strings.link.album(album, {to}),
-                tracks: strings.count.tracks(album.tracks.length, {unit: true})
-            });
-        }
-    },
-
-    {
-        directory: 'albums/by-tracks',
-        title: ({strings}) => strings('listingPage.listAlbums.byTracks.title'),
-
-        data() {
-            return albumData.slice()
-                .sort((a, b) => b.tracks.length - a.tracks.length);
-        },
-
-        row(album, {strings, to}) {
-            return strings('listingPage.listAlbums.byTracks.item', {
-                album: strings.link.album(album, {to}),
-                tracks: strings.count.tracks(album.tracks.length, {unit: true})
-            });
-        }
-    },
-
-    {
-        directory: 'albums/by-duration',
-        title: ({strings}) => strings('listingPage.listAlbums.byDuration.title'),
-
-        data() {
-            return albumData
-                .map(album => ({album, duration: getTotalDuration(album.tracks)}))
-                .sort((a, b) => b.duration - a.duration);
-        },
-
-        row({album, duration}, {strings, to}) {
-            return strings('listingPage.listAlbums.byDuration.item', {
-                album: strings.link.album(album, {to}),
-                duration: strings.count.duration(duration)
-            });
-        }
-    },
-
-    {
-        directory: 'albums/by-date',
-        title: ({strings}) => strings('listingPage.listAlbums.byDate.title'),
-
-        data() {
-            return C.sortByDate(albumData
-                .filter(album => album.directory !== C.UNRELEASED_TRACKS_DIRECTORY));
-        },
-
-        row(album, {strings, to}) {
-            return strings('listingPage.listAlbums.byDate.item', {
-                album: strings.link.album(album, {to}),
-                date: strings.count.date(album.date)
-            });
-        }
-    },
-
-    {
-        directory: 'albusm/by-date-added',
-        title: ({strings}) => strings('listingPage.listAlbums.byDateAdded.title'),
-
-        data() {
-            return chunkByProperties(albumData.slice().sort((a, b) => {
-                if (a.dateAdded < b.dateAdded) return -1;
-                if (a.dateAdded > b.dateAdded) return 1;
-            }), ['dateAdded']);
-        },
-
-        html(chunks, {strings, to}) {
-            return fixWS`
-                <dl>
-                    ${chunks.map(({dateAdded, chunk: albums}) => fixWS`
-                        <dt>${strings('listingPage.listAlbums.byDateAdded.date', {
-                            date: strings.count.date(dateAdded)
-                        })}</dt>
-                        <dd><ul>
-                            ${(albums
-                                .map(album => strings('listingPage.listAlbums.byDateAdded.album', {
-                                    album: strings.link.album(album, {to})
-                                }))
-                                .map(row => `<li>${row}</li>`)
-                                .join('\n'))}
-                        </ul></dd>
-                    `).join('\n')}
-                </dl>
-            `;
-        }
-    },
-
-    {
-        directory: 'artists/by-name',
-        title: ({strings}) => strings('listingPage.listArtists.byName.title'),
-
-        data() {
-            return artistData.slice()
-                .sort(sortByName)
-                .map(artist => ({artist, contributions: C.getArtistNumContributions(artist)}));
-        },
-
-        row({artist, contributions}, {strings, to}) {
-            return strings('listingPage.listArtists.byName.item', {
-                artist: strings.link.artist(artist, {to}),
-                contributions: strings.count.contributions(contributions, {to, unit: true})
-            });
-        }
-    },
-
-    {
-        directory: 'artists/by-contribs',
-        title: ({strings}) => strings('listingPage.listArtists.byContribs.title'),
-
-        data() {
-            return {
-                toTracks: (artistData
-                    .map(artist => ({
-                        artist,
-                        contributions: (
-                            artist.tracks.asContributor.length +
-                            artist.tracks.asArtist.length
-                        )
-                    }))
-                    .sort((a, b) => b.contributions - a.contributions)
-                    .filter(({ contributions }) => contributions)),
-
-                toArtAndFlashes: (artistData
-                    .map(artist => ({
-                        artist,
-                        contributions: (
-                            artist.tracks.asCoverArtist.length +
-                            artist.albums.asCoverArtist.length +
-                            artist.albums.asWallpaperArtist.length +
-                            artist.albums.asBannerArtist.length +
-                            (wikiInfo.features.flashesAndGames
-                                ? artist.flashes.asContributor.length
-                                : 0)
-                        )
-                    }))
-                    .sort((a, b) => b.contributions - a.contributions)
-                    .filter(({ contributions }) => contributions))
-            };
-        },
-
-        html({toTracks, toArtAndFlashes}, {strings, to}) {
-            return fixWS`
-                <div class="content-columns">
-                    <div class="column">
-                        <h2>${strings('listingPage.misc.trackContributors')}</h2>
-                        <ul>
-                            ${(toTracks
-                                .map(({ artist, contributions }) => strings('listingPage.listArtists.byContribs.item', {
-                                    artist: strings.link.artist(artist, {to}),
-                                    contributions: strings.count.contributions(contributions, {unit: true})
-                                }))
-                                .map(row => `<li>${row}</li>`)
-                                .join('\n'))}
-                         </ul>
-                    </div>
-                    <div class="column">
-                        <h2>${strings('listingPage.misc' +
-                            (wikiInfo.features.flashesAndGames
-                                ? '.artAndFlashContributors'
-                                : '.artContributors'))}</h2>
-                        <ul>
-                            ${(toArtAndFlashes
-                                .map(({ artist, contributions }) => strings('listingPage.listArtists.byContribs.item', {
-                                    artist: strings.link.artist(artist, {to}),
-                                    contributions: strings.count.contributions(contributions, {unit: true})
-                                }))
-                                .map(row => `<li>${row}</li>`)
-                                .join('\n'))}
-                        </ul>
-                    </div>
-                </div>
-            `;
-        }
-    },
-
-    {
-        directory: 'artists/by-commentary',
-        title: ({strings}) => strings('listingPage.listArtists.byCommentary.title'),
-
-        data() {
-            return artistData
-                .map(artist => ({artist, entries: artist.tracks.asCommentator.length + artist.albums.asCommentator.length}))
-                .filter(({ entries }) => entries)
-                .sort((a, b) => b.entries - a.entries);
-        },
-
-        row({artist, entries}, {strings, to}) {
-            return strings('listingPage.listArtists.byCommentary.item', {
-                artist: strings.link.artist(artist, {to}),
-                entries: strings.count.commentaryEntries(entries, {unit: true})
-            });
-        }
-    },
-
-    {
-        directory: 'artists/by-duration',
-        title: ({strings}) => strings('listingPage.listArtists.byDuration.title'),
-
-        data() {
-            return artistData
-                .map(artist => ({artist, duration: getTotalDuration(
-                    [...artist.tracks.asArtist, ...artist.tracks.asContributor].filter(track => track.album.directory !== C.UNRELEASED_TRACKS_DIRECTORY))
-                }))
-                .filter(({ duration }) => duration > 0)
-                .sort((a, b) => b.duration - a.duration);
-        },
-
-        row({artist, duration}, {strings, to}) {
-            return strings('listingPage.listArtists.byDuration.item', {
-                artist: strings.link.artist(artist, {to}),
-                duration: strings.count.duration(duration)
-            });
-        }
-    },
-
-    {
-        directory: 'artists/by-latest',
-        title: ({strings}) => strings('listingPage.listArtists.byLatest.title'),
-
-        data() {
-            const reversedTracks = trackData.slice().reverse();
-            const reversedArtThings = justEverythingSortedByArtDateMan.slice().reverse();
-
-            return {
-                toTracks: C.sortByDate(artistData
-                    .filter(artist => !artist.alias)
-                    .map(artist => ({
-                        artist,
-                        date: reversedTracks.find(({ album, artists, contributors }) => (
-                            album.directory !== C.UNRELEASED_TRACKS_DIRECTORY &&
-                            [...artists, ...contributors].some(({ who }) => who === artist)
-                        ))?.date
-                    }))
-                    .filter(({ date }) => date)
-                    .sort((a, b) => a.name < b.name ? 1 : a.name > b.name ? -1 : 0)).reverse(),
-
-                toArtAndFlashes: C.sortByDate(artistData
-                    .filter(artist => !artist.alias)
-                    .map(artist => {
-                        const thing = reversedArtThings.find(({ album, coverArtists, contributors }) => (
-                            album?.directory !== C.UNRELEASED_TRACKS_DIRECTORY &&
-                            [...coverArtists || [], ...!album && contributors || []].some(({ who }) => who === artist)
-                        ));
-                        return thing && {
-                            artist,
-                            date: (thing.coverArtists?.some(({ who }) => who === artist)
-                                ? thing.coverArtDate
-                                : thing.date)
-                        };
-                    })
-                    .filter(Boolean)
-                    .sort((a, b) => a.name < b.name ? 1 : a.name > b.name ? -1 : 0)
-                ).reverse()
-            };
-        },
-
-        html({toTracks, toArtAndFlashes}, {strings, to}) {
-            return fixWS`
-                <div class="content-columns">
-                    <div class="column">
-                        <h2>${strings('listingPage.misc.trackContributors')}</h2>
-                        <ul>
-                            ${(toTracks
-                                .map(({ artist, date }) => strings('listingPage.listArtists.byLatest.item', {
-                                    artist: strings.link.artist(artist, {to}),
-                                    date: strings.count.date(date)
-                                }))
-                                .map(row => `<li>${row}</li>`)
-                                .join('\n'))}
-                        </ul>
-                    </div>
-                    <div class="column">
-                        <h2>${strings('listingPage.misc' +
-                            (wikiInfo.features.flashesAndGames
-                                ? '.artAndFlashContributors'
-                                : '.artContributors'))}</h2>
-                        <ul>
-                            ${(toArtAndFlashes
-                                .map(({ artist, date }) => strings('listingPage.listArtists.byLatest.item', {
-                                    artist: strings.link.artist(artist, {to}),
-                                    date: strings.count.date(date)
-                                }))
-                                .map(row => `<li>${row}</li>`)
-                                .join('\n'))}
-                        </ul>
-                    </div>
-                </div>
-            `;
-        }
-    },
-
-    {
-        directory: 'groups/by-name',
-        title: ({strings}) => strings('listingPage.listGroups.byName.title'),
-        condition: () => wikiInfo.features.groupUI,
-
-        data() {
-            return groupData.slice().sort(sortByName);
-        },
-
-        row(group, {strings, to}) {
-            return strings('listingPage.listGroups.byCategory.group', {
-                group: strings.link.groupInfo(group, {to}),
-                gallery: strings.link.groupGallery(group, {
-                    to,
-                    text: strings('listingPage.listGroups.byCategory.group.gallery')
-                })
-            });
-        }
-    },
-
-    {
-        directory: 'groups/by-category',
-        title: ({strings}) => strings('listingPage.listGroups.byCategory.title'),
-        condition: () => wikiInfo.features.groupUI,
-
-        html({strings, to}) {
-            return fixWS`
-                <dl>
-                    ${groupCategoryData.map(category => fixWS`
-                        <dt>${strings('listingPage.listGroups.byCategory.category', {
-                            category: strings.link.groupInfo(category.groups[0], {to, text: category.name})
-                        })}</dt>
-                        <dd><ul>
-                            ${(category.groups
-                                .map(group => strings('listingPage.listGroups.byCategory.group', {
-                                    group: strings.link.groupInfo(group, {to}),
-                                    gallery: strings.link.groupGallery(group, {
-                                        to,
-                                        text: strings('listingPage.listGroups.byCategory.group.gallery')
-                                    })
-                                }))
-                                .map(row => `<li>${row}</li>`)
-                                .join('\n'))}
-                        </ul></dd>
-                    `).join('\n')}
-                </dl>
-            `;
-        }
-    },
-
-    {
-        directory: 'groups/by-albums',
-        title: ({strings}) => strings('listingPage.listGroups.byAlbums.title'),
-        condition: () => wikiInfo.features.groupUI,
-
-        data() {
-            return groupData
-                .map(group => ({group, albums: group.albums.length}))
-                .sort((a, b) => b.albums - a.albums);
-        },
-
-        row({group, albums}, {strings, to}) {
-            return strings('listingPage.listGroups.byAlbums.item', {
-                group: strings.link.groupInfo(group, {to}),
-                albums: strings.count.albums(albums, {unit: true})
-            });
-        }
-    },
-
-    {
-        directory: 'groups/by-tracks',
-        title: ({strings}) => strings('listingPage.listGroups.byTracks.title'),
-        condition: () => wikiInfo.features.groupUI,
-
-        data() {
-            return groupData
-                .map(group => ({group, tracks: group.albums.reduce((acc, album) => acc + album.tracks.length, 0)}))
-                .sort((a, b) => b.tracks - a.tracks);
-        },
-
-        row({group, tracks}, {strings, to}) {
-            return strings('listingPage.listGroups.byTracks.item', {
-                group: strings.link.groupInfo(group, {to}),
-                tracks: strings.count.tracks(tracks, {unit: true})
-            });
-        }
-    },
-
-    {
-        directory: 'groups/by-duration',
-        title: ({strings}) => strings('listingPage.listGroups.byDuration.title'),
-        condition: () => wikiInfo.features.groupUI,
-
-        data() {
-            return groupData
-                .map(group => ({group, duration: getTotalDuration(group.albums.flatMap(album => album.tracks))}))
-                .sort((a, b) => b.duration - a.duration);
-        },
-
-        row({group, duration}, {strings, to}) {
-            return strings('listingPage.listGroups.byDuration.item', {
-                group: strings.link.groupInfo(group, {to}),
-                duration: strings.count.duration(duration)
-            });
-        }
-    },
-
-    {
-        directory: 'groups/by-latest-album',
-        title: ({strings}) => strings('listingPage.listGroups.byLatest.title'),
-        condition: () => wikiInfo.features.groupUI,
-
-        data() {
-            return C.sortByDate(groupData
-                .map(group => ({group, date: group.albums[group.albums.length - 1].date}))
-                // So this is kinda tough to explain, 8ut 8asically, when we reverse the list after sorting it 8y d8te
-                // (so that the latest d8tes come first), it also flips the order of groups which share the same d8te.
-                // This happens mostly when a single al8um is the l8test in two groups. So, say one such al8um is in
-                // the groups "Fandom" and "UMSPAF". Per category order, Fandom is meant to show up 8efore UMSPAF, 8ut
-                // when we do the reverse l8ter, that flips them, and UMSPAF ends up displaying 8efore Fandom. So we do
-                // an extra reverse here, which will fix that and only affect groups that share the same d8te (8ecause
-                // groups that don't will 8e moved 8y the sortByDate call surrounding this).
-                .reverse()).reverse()
-        },
-
-        row({group, date}, {strings, to}) {
-            return strings('listingPage.listGroups.byLatest.item', {
-                group: strings.link.groupInfo(group, {to}),
-                date: strings.count.date(date)
-            });
-        }
-    },
-
-    {
-        directory: 'tracks/by-name',
-        title: ({strings}) => strings('listingPage.listTracks.byName.title'),
-
-        data() {
-            return trackData.slice().sort(sortByName);
-        },
-
-        row(track, {strings, to}) {
-            return strings('listingPage.listTracks.byName.item', {
-                track: strings.link.track(track, {to})
-            });
-        }
-    },
-
-    {
-        directory: 'tracks/by-album',
-        title: ({strings}) => strings('listingPage.listTracks.byAlbum.title'),
-
-        html({strings, to}) {
-            return fixWS`
-                <dl>
-                    ${albumData.map(album => fixWS`
-                        <dt>${strings('listingPage.listTracks.byAlbum.album', {
-                            album: strings.link.album(album, {to})
-                        })}</dt>
-                        <dd><ol>
-                            ${(album.tracks
-                                .map(track => strings('listingPage.listTracks.byAlbum.track', {
-                                    track: strings.link.track(track, {to})
-                                }))
-                                .map(row => `<li>${row}</li>`)
-                                .join('\n'))}
-                        </ol></dd>
-                    `).join('\n')}
-                </dl>
-            `;
-        }
-    },
-
-    {
-        directory: 'tracks/by-date',
-        title: ({strings}) => strings('listingPage.listTracks.byDate.title'),
-
-        data() {
-            return chunkByProperties(
-                C.sortByDate(trackData.filter(track => track.album.directory !== C.UNRELEASED_TRACKS_DIRECTORY)),
-                ['album', 'date']
-            );
-        },
-
-        html(chunks, {strings, to}) {
-            return fixWS`
-                <dl>
-                    ${chunks.map(({album, date, chunk: tracks}) => fixWS`
-                        <dt>${strings('listingPage.listTracks.byDate.album', {
-                            album: strings.link.album(album, {to}),
-                            date: strings.count.date(date)
-                        })}</dt>
-                        <dd><ul>
-                            ${(tracks
-                                .map(track => track.aka
-                                    ? `<li class="rerelease">${strings('listingPage.listTracks.byDate.track.rerelease', {
-                                        track: strings.link.track(track, {to})
-                                    })}</li>`
-                                    : `<li>${strings('listingPage.listTracks.byDate.track', {
-                                        track: strings.link.track(track, {to})
-                                    })}</li>`)
-                                .join('\n'))}
-                        </ul></dd>
-                    `).join('\n')}
-                </dl>
-            `;
-        }
-    },
-
-    {
-        directory: 'tracks/by-duration',
-        title: ({strings}) => strings('listingPage.listTracks.byDuration.title'),
-
-        data() {
-            return trackData
-                .filter(track => track.album.directory !== C.UNRELEASED_TRACKS_DIRECTORY)
-                .map(track => ({track, duration: track.duration}))
-                .filter(({ duration }) => duration > 0)
-                .sort((a, b) => b.duration - a.duration);
-        },
-
-        row({track, duration}, {strings, to}) {
-            return strings('listingPage.listTracks.byDuration.item', {
-                track: strings.link.track(track, {to}),
-                duration: strings.count.duration(duration)
-            });
-        }
-    },
-
-    {
-        directory: 'tracks/by-duration-in-album',
-        title: ({strings}) => strings('listingPage.listTracks.byDurationInAlbum.title'),
-
-        data() {
-            return albumData.map(album => ({
-                album,
-                tracks: album.tracks.slice().sort((a, b) => b.duration - a.duration)
-            }));
-        },
-
-        html(albums, {strings, to}) {
-            return fixWS`
-                <dl>
-                    ${albums.map(({album, tracks}) => fixWS`
-                        <dt>${strings('listingPage.listTracks.byDurationInAlbum.album', {
-                            album: strings.link.album(album, {to})
-                        })}</dt>
-                        <dd><ul>
-                            ${(tracks
-                                .map(track => strings('listingPage.listTracks.byDurationInAlbum.track', {
-                                    track: strings.link.track(track, {to}),
-                                    duration: strings.count.duration(track.duration)
-                                }))
-                                .map(row => `<li>${row}</li>`)
-                                .join('\n'))}
-                        </dd></ul>
-                    `).join('\n')}
-                </dl>
-            `;
-        }
-    },
-
-    {
-        directory: 'tracks/by-times-referenced',
-        title: ({strings}) => strings('listingPage.listTracks.byTimesReferenced.title'),
-
-        data() {
-            return trackData
-                .map(track => ({track, timesReferenced: track.referencedBy.length}))
-                .filter(({ timesReferenced }) => timesReferenced > 0)
-                .sort((a, b) => b.timesReferenced - a.timesReferenced);
-        },
-
-        row({track, timesReferenced}, {strings, to}) {
-            return strings('listingPage.listTracks.byTimesReferenced.item', {
-                track: strings.link.track(track, {to}),
-                timesReferenced: strings.count.timesReferenced(timesReferenced, {unit: true})
-            });
-        }
-    },
-
-    {
-        directory: 'tracks/in-flashes/by-album',
-        title: ({strings}) => strings('listingPage.listTracks.inFlashes.byAlbum.title'),
-        condition: () => wikiInfo.features.flashesAndGames,
-
-        data() {
-            return chunkByProperties(trackData.filter(t => t.flashes.length > 0), ['album'])
-                .filter(({ album }) => album.directory !== C.UNRELEASED_TRACKS_DIRECTORY);
-        },
-
-        html(chunks, {strings, to}) {
-            return fixWS`
-                <dl>
-                    ${chunks.map(({album, chunk: tracks}) => fixWS`
-                        <dt>${strings('listingPage.listTracks.inFlashes.byAlbum.album', {
-                            album: strings.link.album(album, {to}),
-                            date: strings.count.date(album.date)
-                        })}</dt>
-                        <dd><ul>
-                            ${(tracks
-                                .map(track => strings('listingPage.listTracks.inFlashes.byAlbum.track', {
-                                    track: strings.link.track(track, {to}),
-                                    flashes: strings.list.and(track.flashes.map(flash => strings.link.flash(flash, {to})))
-                                }))
-                                .map(row => `<li>${row}</li>`)
-                                .join('\n'))}
-                        </dd></ul>
-                    `).join('\n')}
-                </dl>
-            `;
-        }
-    },
-
-    {
-        directory: 'tracks/in-flashes/by-flash',
-        title: ({strings}) => strings('listingPage.listTracks.inFlashes.byFlash.title'),
-        condition: () => wikiInfo.features.flashesAndGames,
-
-        html({strings, to}) {
-            return fixWS`
-                <dl>
-                    ${C.sortByDate(flashData.slice()).map(flash => fixWS`
-                        <dt>${strings('listingPage.listTracks.inFlashes.byFlash.flash', {
-                            flash: strings.link.flash(flash, {to}),
-                            date: strings.count.date(flash.date)
-                        })}</dt>
-                        <dd><ul>
-                            ${(flash.tracks
-                                .map(track => strings('listingPage.listTracks.inFlashes.byFlash.track', {
-                                    track: strings.link.track(track, {to}),
-                                    album: strings.link.album(track.album, {to})
-                                }))
-                                .map(row => `<li>${row}</li>`)
-                                .join('\n'))}
-                        </ul></dd>
-                    `).join('\n')}
-                </dl>
-            `;
-        }
-    },
-
-    {
-        directory: 'tracks/with-lyrics',
-        title: ({strings}) => strings('listingPage.listTracks.withLyrics.title'),
-
-        data() {
-            return chunkByProperties(trackData.filter(t => t.lyrics), ['album']);
-        },
-
-        html(chunks, {strings, to}) {
-            return fixWS`
-                <dl>
-                    ${chunks.map(({album, chunk: tracks}) => fixWS`
-                        <dt>${strings('listingPage.listTracks.withLyrics.album', {
-                            album: strings.link.album(album, {to}),
-                            date: strings.count.date(album.date)
-                        })}</dt>
-                        <dd><ul>
-                            ${(tracks
-                                .map(track => strings('listingPage.listTracks.withLyrics.track', {
-                                    track: strings.link.track(track, {to}),
-                                }))
-                                .map(row => `<li>${row}</li>`)
-                                .join('\n'))}
-                        </dd></ul>
-                    `).join('\n')}
-                </dl>
-            `;
-        }
-    },
-
-    {
-        directory: 'tags/by-name',
-        title: ({strings}) => strings('listingPage.listTags.byName.title'),
-        condition: () => wikiInfo.features.artTagUI,
-
-        data() {
-            return tagData
-                .filter(tag => !tag.isCW)
-                .sort(sortByName)
-                .map(tag => ({tag, timesUsed: tag.things.length}));
-        },
-
-        row({tag, timesUsed}, {strings, to}) {
-            return strings('listingPage.listTags.byName.item', {
-                tag: strings.link.tag(tag, {to}),
-                timesUsed: strings.count.timesUsed(timesUsed, {unit: true})
-            });
-        }
-    },
-
-    {
-        directory: 'tags/by-uses',
-        title: ({strings}) => strings('listingPage.listTags.byUses.title'),
-        condition: () => wikiInfo.features.artTagUI,
-
-        data() {
-            return tagData
-                .filter(tag => !tag.isCW)
-                .map(tag => ({tag, timesUsed: tag.things.length}))
-                .sort((a, b) => b.timesUsed - a.timesUsed);
-        },
-
-        row({tag, timesUsed}, {strings, to}) {
-            return strings('listingPage.listTags.byUses.item', {
-                tag: strings.link.tag(tag, {to}),
-                timesUsed: strings.count.timesUsed(timesUsed, {unit: true})
-            });
-        }
-    },
-
-    {
-        directory: 'random',
-        title: ({strings}) => `Random Pages`,
-        html: ({strings, to}) => fixWS`
-            <p>Choose a link to go to a random page in that category or album! If your browser doesn't support relatively modern JavaScript or you've disabled it, these links won't work - sorry.</p>
-            <p class="js-hide-once-data">(Data files are downloading in the background! Please wait for data to load.)</p>
-            <p class="js-show-once-data">(Data files have finished being downloaded. The links should work!)</p>
-            <dl>
-                <dt>Miscellaneous:</dt>
-                <dd><ul>
-                    <li>
-                        <a href="#" data-random="artist">Random Artist</a>
-                        (<a href="#" data-random="artist-more-than-one-contrib">&gt;1 contribution</a>)
-                    </li>
-                    <li><a href="#" data-random="album">Random Album (whole site)</a></li>
-                    <li><a href="#" data-random="track">Random Track (whole site)</a></li>
-                </ul></dd>
-                ${[
-                    {name: 'Official', albumData: officialAlbumData, code: 'official'},
-                    {name: 'Fandom', albumData: fandomAlbumData, code: 'fandom'}
-                ].map(category => fixWS`
-                    <dt>${category.name}: (<a href="#" data-random="album-in-${category.code}">Random Album</a>, <a href="#" data-random="track-in-${category.code}">Random Track</a>)</dt>
-                    <dd><ul>${category.albumData.map(album => fixWS`
-                        <li><a style="${getLinkThemeString(album)}; --album-directory: ${album.directory}" href="#" data-random="track-in-album">${album.name}</a></li>
-                    `).join('\n')}</ul></dd>
-                `).join('\n')}
-            </dl>
-        `
-    }
-];
-
-function writeListingPages() {
-    if (!wikiInfo.features.listings) {
-        return;
-    }
-
-    return [
-        writeListingIndex(),
-        ...listingSpec.map(writeListingPage).filter(Boolean)
-    ];
-}
-
-function writeListingIndex() {
-    const releasedTracks = trackData.filter(track => track.album.directory !== C.UNRELEASED_TRACKS_DIRECTORY);
-    const releasedAlbums = albumData.filter(album => album.directory !== C.UNRELEASED_TRACKS_DIRECTORY);
-    const duration = getTotalDuration(releasedTracks);
-
-    return ({strings, writePage}) => writePage('listingIndex', '', ({to}) => ({
-        title: strings('listingIndex.title'),
-
-        main: {
-            content: fixWS`
-                <h1>${strings('listingIndex.title')}</h1>
-                <p>${strings('listingIndex.infoLine', {
-                    wiki: wikiInfo.name,
-                    tracks: `<b>${strings.count.tracks(releasedTracks.length, {unit: true})}</b>`,
-                    albums: `<b>${strings.count.albums(releasedAlbums.length, {unit: true})}</b>`,
-                    duration: `<b>${strings.count.duration(duration, {approximate: true, unit: true})}</b>`
-                })}</p>
-                <hr>
-                <p>${strings('listingIndex.exploreList')}</p>
-                ${generateLinkIndexForListings(null, {strings, to})}
-            `
-        },
-
-        sidebarLeft: {
-            content: generateSidebarForListings(null, {strings, to})
-        },
-
-        nav: {simple: true}
-    }))
-}
-
-function writeListingPage(listing) {
-    if (listing.condition && !listing.condition()) {
-        return null;
-    }
-
-    const data = (listing.data
-        ? listing.data()
-        : null);
-
-    return ({strings, writePage}) => writePage('listing', listing.directory, ({to}) => ({
-        title: listing.title({strings}),
-
-        main: {
-            content: fixWS`
-                <h1>${listing.title({strings})}</h1>
-                ${listing.html && (listing.data
-                    ? listing.html(data, {strings, to})
-                    : listing.html({strings, to}))}
-                ${listing.row && fixWS`
-                    <ul>
-                        ${(data
-                            .map(item => listing.row(item, {strings, to}))
-                            .map(row => `<li>${row}</li>`)
-                            .join('\n'))}
-                    </ul>
-                `}
-            `
-        },
-
-        sidebarLeft: {
-            content: generateSidebarForListings(listing, {strings, to})
-        },
-
-        nav: {
-            links: [
-                {
-                    href: to('localized.home'),
-                    title: wikiInfo.shortName
-                },
-                {
-                    href: to('localized.listingIndex'),
-                    title: strings('listingIndex.title')
-                },
-                {
-                    href: '',
-                    title: listing.title({strings})
-                }
-            ]
-        }
-    }));
-}
-
-function generateSidebarForListings(currentListing, {strings, to}) {
-    return fixWS`
-        <h1>${strings.link.listingIndex('', {text: strings('listingIndex.title'), to})}</h1>
-        ${generateLinkIndexForListings(currentListing, {strings, to})}
-    `;
-}
-
-function generateLinkIndexForListings(currentListing, {strings, to}) {
-    return fixWS`
-        <ul>
-            ${(listingSpec
-                .filter(({ condition }) => !condition || condition())
-                .map(listing => fixWS`
-                    <li ${classes(listing === currentListing && 'current')}>
-                        <a href="${to('localized.listing', listing.directory)}">${listing.title({strings})}</a>
-                    </li>
-                `)
-                .join('\n'))}
-        </ul>
-    `;
-}
-
-function filterAlbumsByCommentary() {
-    return albumData.filter(album => [album, ...album.tracks].some(x => x.commentary));
-}
-
-function writeCommentaryPages() {
-    if (!filterAlbumsByCommentary().length) {
-        return;
-    }
-
-    return [
-        writeCommentaryIndex(),
-        ...filterAlbumsByCommentary().map(writeAlbumCommentaryPage)
-    ];
-}
-
-function writeCommentaryIndex() {
-    const data = filterAlbumsByCommentary()
-        .map(album => ({
-            album,
-            entries: [album, ...album.tracks].filter(x => x.commentary).map(x => x.commentary)
-        }))
-        .map(({ album, entries }) => ({
-            album, entries,
-            words: entries.join(' ').split(' ').length
-        }));
-
-    const totalEntries = data.reduce((acc, {entries}) => acc + entries.length, 0);
-    const totalWords = data.reduce((acc, {words}) => acc + words, 0);
-
-    return ({strings, writePage}) => writePage('commentaryIndex', '', ({to}) => ({
-        title: strings('commentaryIndex.title'),
-
-        main: {
-            content: fixWS`
-                <div class="long-content">
-                    <h1>${strings('commentaryIndex.title')}</h1>
-                    <p>${strings('commentaryIndex.infoLine', {
-                        words: `<b>${strings.count.words(totalWords, {unit: true})}</b>`,
-                        entries: `<b>${strings.count.commentaryEntries(totalEntries, {unit: true})}</b>`
-                    })}</p>
-                    <p>${strings('commentaryIndex.albumList.title')}</p>
-                    <ul>
-                        ${data
-                            .map(({ album, entries, words }) => fixWS`
-                                <li>${strings('commentaryIndex.albumList.item', {
-                                    album: strings.link.albumCommentary(album, {to}),
-                                    words: strings.count.words(words, {unit: true}),
-                                    entries: strings.count.commentaryEntries(entries.length, {unit: true})
-                                })}</li>
-                            `)
-                            .join('\n')}
-                    </ul>
-                </div>
-            `
-        },
-
-        nav: {simple: true}
-    }));
-}
-
-function writeAlbumCommentaryPage(album) {
-    const entries = [album, ...album.tracks].filter(x => x.commentary).map(x => x.commentary);
-    const words = entries.join(' ').split(' ').length;
-
-    return ({strings, writePage}) => writePage('albumCommentary', album.directory, ({to}) => ({
-        title: strings('albumCommentaryPage.title', {album: album.name}),
-        stylesheet: getAlbumStylesheet(album, {to}),
-        theme: getThemeString(album),
-
-        main: {
-            content: fixWS`
-                <div class="long-content">
-                    <h1>${strings('albumCommentaryPage.title', {
-                        album: strings.link.album(album, {to})
-                    })}</h1>
-                    <p>${strings('albumCommentaryPage.infoLine', {
-                        words: `<b>${strings.count.words(words, {unit: true})}</b>`,
-                        entries: `<b>${strings.count.commentaryEntries(entries.length, {unit: true})}</b>`
-                    })}</p>
-                    ${album.commentary && fixWS`
-                        <h3>${strings('albumCommentaryPage.entry.title.albumCommentary')}</h3>
-                        <blockquote>
-                            ${transformMultiline(album.commentary, {strings, to})}
-                        </blockquote>
-                    `}
-                    ${album.tracks.filter(t => t.commentary).map(track => fixWS`
-                        <h3 id="${track.directory}">${strings('albumCommentaryPage.entry.title.trackCommentary', {
-                            track: strings.link.track(track, {to})
-                        })}</h3>
-                        <blockquote style="${getLinkThemeString(track)}">
-                            ${transformMultiline(track.commentary, {strings, to})}
-                        </blockquote>
-                    `).join('\n')}
-                </div>
-            `
-        },
-
-        nav: {
-            links: [
-                {
-                    href: to('localized.home'),
-                    title: wikiInfo.shortName
-                },
-                {
-                    href: to('localized.commentaryIndex'),
-                    title: strings('commentaryIndex.title')
-                },
-                {
-                    html: strings('albumCommentaryPage.nav.album', {
-                        album: strings.link.albumCommentary(album, {class: 'current', to})
-                    })
-                }
-            ]
-        }
-    }));
-}
-
-function writeTagPages() {
-    if (!wikiInfo.features.artTagUI) {
-        return;
-    }
-
-    return tagData.filter(tag => !tag.isCW).map(writeTagPage);
-}
-
-function writeTagPage(tag) {
-    const { things } = tag;
-
-    return ({strings, writePage}) => writePage('tag', tag.directory, ({to}) => ({
-        title: strings('tagPage.title', {tag: tag.name}),
-        theme: getThemeString(tag),
-
-        main: {
-            classes: ['top-index'],
-            content: fixWS`
-                <h1>${strings('tagPage.title', {tag: tag.name})}</h1>
-                <p class="quick-info">${strings('tagPage.infoLine', {
-                    coverArts: strings.count.coverArts(things.length, {unit: true})
-                })}</p>
-                <div class="grid-listing">
-                    ${getGridHTML({
-                        strings, to,
-                        entries: things.map(item => ({item})),
-                        srcFn: thing => (thing.album
-                            ? getTrackCover(thing, {to})
-                            : getAlbumCover(thing, {to})),
-                        hrefFn: thing => (thing.album
-                            ? to('localized.track', thing.directory)
-                            : to('localized.album', thing.directory))
-                    })}
-                </div>
-            `
-        },
-
-        nav: {
-            links: [
-                {
-                    href: to('localized.home'),
-                    title: wikiInfo.shortName
-                },
-                wikiInfo.features.listings &&
-                {
-                    href: to('localized.listingIndex'),
-                    title: strings('listingIndex.title')
-                },
-                {
-                    html: strings('tagPage.nav.tag', {
-                        tag: strings.link.tag(tag, {class: 'current', to})
-                    })
-                }
-            ]
-        }
-    }));
-}
-
-function getArtistString(artists, {strings, to, showIcons = false, showContrib = false}) {
-    return strings.list.and(artists.map(({ who, what }) => {
-        const { urls, directory, name } = who;
-        return [
-            strings.link.artist(who, {to}),
-            showContrib && what && `(${what})`,
-            showIcons && urls.length && `<span class="icons">(${
-                strings.list.unit(urls.map(url => iconifyURL(url, {strings, to})))
-            })</span>`
-        ].filter(Boolean).join(' ');
-    }));
-}
-
-function getLinkThemeString(thing) {
-    const { primary, dim } = C.getColors(thing.color || wikiInfo.color);
-    return `--primary-color: ${primary}; --dim-color: ${dim}`;
-}
-
-function getThemeString(thing, additionalVariables = []) {
-    const { primary, dim } = C.getColors(thing.color || wikiInfo.color);
-
-    const variables = [
-        `--primary-color: ${primary}`,
-        `--dim-color: ${dim}`,
-        ...additionalVariables
-    ].filter(Boolean);
-
-    return fixWS`
-        ${variables.length && fixWS`
-            :root {
-                ${variables.map(line => line + ';').join('\n')}
-            }
-        `}
-    `;
-}
-
-function getFlashDirectory(flash) {
-    // const kebab = getKebabCase(flash.name.replace('[S] ', ''));
-    // return flash.page + (kebab ? '-' + kebab : '');
-    // return '' + flash.page;
-    return '' + flash.directory;
-}
-
-function getTagDirectory({name}) {
-    return C.getKebabCase(name);
-}
-
-function getAlbumListTag(album) {
-    if (album.directory === C.UNRELEASED_TRACKS_DIRECTORY) {
-        return 'ul';
-    } else {
-        return 'ol';
-    }
-}
-
-function fancifyURL(url, {strings, album = false} = {}) {
-    const domain = new URL(url).hostname;
-    return fixWS`<a href="${url}" class="nowrap">${
-        domain.includes('bandcamp.com') ? strings('misc.external.bandcamp') :
-        [
-            'music.solatrux.com'
-        ].includes(domain) ? strings('misc.external.bandcamp.domain', {domain}) :
-        [
-            'types.pl'
-        ].includes(domain) ? strings('misc.external.mastodon.domain', {domain}) :
-        domain.includes('youtu') ? (album
-            ? (url.includes('list=')
-                ? strings('misc.external.youtube.playlist')
-                : strings('misc.external.youtube.fullAlbum'))
-            : strings('misc.external.youtube')) :
-        domain.includes('soundcloud') ? strings('misc.external.soundcloud') :
-        domain.includes('tumblr.com') ? strings('misc.external.tumblr') :
-        domain.includes('twitter.com') ? strings('misc.external.twitter') :
-        domain.includes('deviantart.com') ? strings('misc.external.deviantart') :
-        domain.includes('wikipedia.org') ? strings('misc.external.wikipedia') :
-        domain.includes('poetryfoundation.org') ? strings('misc.external.poetryFoundation') :
-        domain.includes('instagram.com') ? strings('misc.external.instagram') :
-        domain.includes('patreon.com') ? strings('misc.external.patreon') :
-        domain
-    }</a>`;
-}
-
-function fancifyFlashURL(url, flash, {strings}) {
-    const link = fancifyURL(url, {strings});
-    return `<span class="nowrap">${
-        url.includes('homestuck.com') ? (isNaN(Number(flash.page))
-            ? strings('misc.external.flash.homestuck.secret', {link})
-            : strings('misc.external.flash.homestuck.page', {link, page: flash.page})) :
-        url.includes('bgreco.net') ? strings('misc.external.flash.bgreco', {link}) :
-        url.includes('youtu') ? strings('misc.external.flash.youtube', {link}) :
-        link
-    }</span>`;
-}
-
-function iconifyURL(url, {strings, to}) {
-    const domain = new URL(url).hostname;
-    const [ id, msg ] = (
-        domain.includes('bandcamp.com') ? ['bandcamp', strings('misc.external.bandcamp')] :
-        (
-            domain.includes('music.solatrus.com')
-        ) ? ['bandcamp', strings('misc.external.bandcamp.domain', {domain})] :
-        (
-            domain.includes('types.pl')
-        ) ? ['mastodon', strings('misc.external.mastodon.domain', {domain})] :
-        domain.includes('youtu') ? ['youtube', strings('misc.external.youtube')] :
-        domain.includes('soundcloud') ? ['soundcloud', strings('misc.external.soundcloud')] :
-        domain.includes('tumblr.com') ? ['tumblr', strings('misc.external.tumblr')] :
-        domain.includes('twitter.com') ? ['twitter', strings('misc.external.twitter')] :
-        domain.includes('deviantart.com') ? ['deviantart', strings('misc.external.deviantart')] :
-        domain.includes('instagram.com') ? ['instagram', strings('misc.external.bandcamp')] :
-        ['globe', strings('misc.external.domain', {domain})]
-    );
-    return fixWS`<a href="${url}" class="icon"><svg><title>${msg}</title><use href="${to('shared.staticFile', `icons.svg#icon-${id}`)}"></use></svg></a>`;
-}
-
-function chronologyLinks(currentThing, {
-    strings, to,
-    headingString,
-    contribKey,
-    getThings
-}) {
-    const contributions = currentThing[contribKey];
-    if (!contributions) {
-        return '';
-    }
-
-    if (contributions.length > 8) {
-        return `<div class="chronology">${strings('misc.chronology.seeArtistPages')}</div>`;
-    }
-
-    return contributions.map(({ who: artist }) => {
-        const things = C.sortByDate(unique(getThings(artist)));
-        const releasedThings = things.filter(thing => {
-            const album = albumData.includes(thing) ? thing : thing.album;
-            return !(album && album.directory === C.UNRELEASED_TRACKS_DIRECTORY);
-        });
-        const index = releasedThings.indexOf(currentThing);
-
-        if (index === -1) return '';
-
-        // TODO: This can pro8a8ly 8e made to use generatePreviousNextLinks?
-        // We'd need to make generatePreviousNextLinks use toAnythingMan tho.
-        const previous = releasedThings[index - 1];
-        const next = releasedThings[index + 1];
-        const parts = [
-            previous && `<a href="${toAnythingMan(previous, to)}" title="${previous.name}">Previous</a>`,
-            next && `<a href="${toAnythingMan(next, to)}" title="${next.name}">Next</a>`
-        ].filter(Boolean);
-
-        const stringOpts = {
-            index: strings.count.index(index + 1, {strings}),
-            artist: strings.link.artist(artist, {to})
-        };
-
-        return fixWS`
-            <div class="chronology">
-                <span class="heading">${strings(headingString, stringOpts)}</span>
-                ${parts.length && `<span class="buttons">(${parts.join(', ')})</span>`}
-            </div>
-        `;
-    }).filter(Boolean).join('\n');
-}
-
-function generateAlbumNavLinks(album, currentTrack, {strings, to}) {
-    if (album.tracks.length <= 1) {
-        return '';
-    }
-
-    const previousNextLinks = currentTrack && generatePreviousNextLinks('localized.track', currentTrack, album.tracks, {strings, to})
-    const randomLink = `<a href="#" data-random="track-in-album" id="random-button">${
-        (currentTrack
-            ? strings('trackPage.nav.random')
-            : strings('albumPage.nav.randomTrack'))
-    }</a>`;
-
-    return (previousNextLinks
-        ? `(${previousNextLinks}<span class="js-hide-until-data">, ${randomLink}</span>)`
-        : `<span class="js-hide-until-data">(${randomLink})</span>`);
-}
-
-function generateAlbumChronologyLinks(album, currentTrack, {strings, to}) {
-    return [
-        currentTrack && chronologyLinks(currentTrack, {
-            strings, to,
-            headingString: 'misc.chronology.heading.track',
-            contribKey: 'artists',
-            getThings: artist => [...artist.tracks.asArtist, ...artist.tracks.asContributor]
-        }),
-        chronologyLinks(currentTrack || album, {
-            strings, to,
-            headingString: 'misc.chronology.heading.coverArt',
-            contribKey: 'coverArtists',
-            getThings: artist => [...artist.albums.asCoverArtist, ...artist.tracks.asCoverArtist]
-        })
-    ].filter(Boolean).join('\n');
-}
-
-function generateSidebarForAlbum(album, currentTrack, {strings, to}) {
-    const listTag = getAlbumListTag(album);
-
-    const trackToListItem = track => `<li ${classes(track === currentTrack && 'current')}>${
-        strings('albumSidebar.trackList.item', {
-            track: strings.link.track(track, {to})
-        })
-    }</li>`;
-
-    const trackListPart = fixWS`
-        <h1><a href="${to('localized.album', album.directory)}">${album.name}</a></h1>
-        ${album.trackGroups ? fixWS`
-            <dl>
-                ${album.trackGroups.map(({ name, color, startIndex, tracks }) => fixWS`
-                    <dt ${classes(tracks.includes(currentTrack) && 'current')}>${
-                        (listTag === 'ol'
-                            ? strings('albumSidebar.trackList.group.withRange', {
-                                group: strings.link.track(tracks[0], {to, text: name}),
-                                range: `${startIndex + 1}&ndash;${startIndex + tracks.length}`
-                            })
-                            : strings('albumSidebar.trackList.group', {
-                                group: strings.link.track(tracks[0], {to, text: name})
-                            }))
-                    }</dt>
-                    ${(!currentTrack || tracks.includes(currentTrack)) && fixWS`
-                        <dd><${listTag === 'ol' ? `ol start="${startIndex + 1}"` : listTag}>
-                            ${tracks.map(trackToListItem).join('\n')}
-                        </${listTag}></dd>
-                    `}
-                `).join('\n')}
-            </dl>
-        ` : fixWS`
-            <${listTag}>
-                ${album.tracks.map(trackToListItem).join('\n')}
-            </${listTag}>
-        `}
-    `;
-
-    const { groups } = album;
-
-    const groupParts = groups.map(group => {
-        const index = group.albums.indexOf(album);
-        const next = group.albums[index + 1];
-        const previous = group.albums[index - 1];
-        return {group, next, previous};
-    }).map(({group, next, previous}) => fixWS`
-        <h1>${
-            strings('albumSidebar.groupBox.title', {
-                group: `<a href="${to('localized.groupInfo', group.directory)}">${group.name}</a>`
-            })
-        }</h1>
-        ${!currentTrack && transformMultiline(group.descriptionShort, {strings, to})}
-        ${group.urls.length && `<p>${
-            strings('releaseInfo.visitOn', {
-                links: strings.list.or(group.urls.map(url => fancifyURL(url, {strings})))
-            })
-        }</p>`}
-        ${!currentTrack && fixWS`
-            ${next && `<p class="group-chronology-link">${
-                strings('albumSidebar.groupBox.next', {
-                    album: `<a href="${to('localized.album', next.directory)}" style="${getLinkThemeString(next)}">${next.name}</a>`
-                })
-            }</p>`}
-            ${previous && `<p class="group-chronology-link">${
-                strings('albumSidebar.groupBox.previous', {
-                    album: `<a href="${to('localized.album', previous.directory)}" style="${getLinkThemeString(previous)}">${previous.name}</a>`
-                })
-            }</p>`}
-        `}
-    `);
-
-    if (groupParts.length) {
-        if (currentTrack) {
-            const combinedGroupPart = groupParts.join('\n<hr>\n');
-            return {
-                multiple: [
-                    trackListPart,
-                    combinedGroupPart
-                ]
-            };
-        } else {
-            return {
-                multiple: [
-                    ...groupParts,
-                    trackListPart
-                ]
-            };
-        }
-    } else {
-        return {
-            content: trackListPart
-        };
-    }
-}
-
-function generateSidebarForGroup(currentGroup, {strings, to, isGallery}) {
-    if (!wikiInfo.features.groupUI) {
-        return null;
-    }
-
-    const urlKey = isGallery ? 'localized.groupGallery' : 'localized.groupInfo';
-
-    return {
-        content: fixWS`
-            <h1>${strings('groupSidebar.title')}</h1>
-            <dl>
-                ${groupCategoryData.map(category => [
-                    fixWS`
-                        <dt ${classes(category === currentGroup.category && 'current')}>${
-                            strings('groupSidebar.groupList.category', {
-                                category: `<a href="${to(urlKey, category.groups[0].directory)}" style="${getLinkThemeString(category)}">${category.name}</a>`
-                            })
-                        }</dt>
-                        <dd><ul>
-                            ${category.groups.map(group => fixWS`
-                                <li ${classes(group === currentGroup && 'current')} style="${getLinkThemeString(group)}">${
-                                    strings('groupSidebar.groupList.item', {
-                                        group: `<a href="${to(urlKey, group.directory)}">${group.name}</a>`
-                                    })
-                                }</li>
-                            `).join('\n')}
-                        </ul></dd>
-                    `
-                ]).join('\n')}
-            </dl>
-        `
-    };
-}
-
-function generateInfoGalleryLinks(urlKeyInfo, urlKeyGallery, currentThing, isGallery, {strings, to}) {
-    return [
-        strings.link[urlKeyInfo](currentThing, {
-            to,
-            class: isGallery ? '' : 'current',
-            text: strings('misc.nav.info')
-        }),
-        strings.link[urlKeyGallery](currentThing, {
-            to,
-            class: isGallery ? 'current' : '',
-            text: strings('misc.nav.gallery')
-        })
-    ].join(', ');
-}
-
-function generatePreviousNextLinks(urlKey, currentThing, thingData, {strings, to}) {
-    const index = thingData.indexOf(currentThing);
-    const previous = thingData[index - 1];
-    const next = thingData[index + 1];
-
-    return [
-        previous && `<a href="${to(urlKey, previous.directory)}" id="previous-button" title="${previous.name}">${strings('misc.nav.previous')}</a>`,
-        next && `<a href="${to(urlKey, next.directory)}" id="next-button" title="${next.name}">${strings('misc.nav.next')}</a>`
-    ].filter(Boolean).join(', ');
-}
-
-function generateNavForGroup(currentGroup, {strings, to, isGallery}) {
-    if (!wikiInfo.features.groupUI) {
-        return {simple: true};
-    }
-
-    const urlKey = isGallery ? 'localized.groupGallery' : 'localized.groupInfo';
-    const linkKey = isGallery ? 'groupGallery' : 'groupInfo';
-
-    const infoGalleryLinks = generateInfoGalleryLinks('groupInfo', 'groupGallery', currentGroup, isGallery, {strings, to});
-    const previousNextLinks = generatePreviousNextLinks(urlKey, currentGroup, groupData, {strings, to})
-
-    return {
-        links: [
-            {
-                href: to('localized.home'),
-                title: wikiInfo.shortName
-            },
-            wikiInfo.features.listings &&
-            {
-                href: to('localized.listingIndex'),
-                title: strings('listingIndex.title')
-            },
-            {
-                html: strings('groupPage.nav.group', {
-                    group: strings.link[linkKey](currentGroup, {class: 'current', to})
-                })
-            },
-            {
-                divider: false,
-                html: (previousNextLinks
-                    ? `(${infoGalleryLinks}; ${previousNextLinks})`
-                    : `(${previousNextLinks})`)
-            }
-        ]
-    };
-}
-
-function writeGroupPages() {
-    return groupData.map(writeGroupPage);
-}
-
-function writeGroupPage(group) {
-    const releasedAlbums = group.albums.filter(album => album.directory !== C.UNRELEASED_TRACKS_DIRECTORY);
-    const releasedTracks = releasedAlbums.flatMap(album => album.tracks);
-    const totalDuration = getTotalDuration(releasedTracks);
-
-    return async ({strings, writePage}) => {
-        await writePage('groupInfo', group.directory, ({to}) => ({
-            title: strings('groupInfoPage.title', {group: group.name}),
-            theme: getThemeString(group),
-
-            main: {
-                content: fixWS`
-                    <h1>${strings('groupInfoPage.title', {group: group.name})}</h1>
-                    ${group.urls.length && `<p>${
-                        strings('releaseInfo.visitOn', {
-                            links: strings.list.or(group.urls.map(url => fancifyURL(url, {strings})))
-                        })
-                    }</p>`}
-                    <blockquote>
-                        ${transformMultiline(group.description, {strings, to})}
-                    </blockquote>
-                    <h2>${strings('groupInfoPage.albumList.title')}</h2>
-                    <p>${
-                        strings('groupInfoPage.viewAlbumGallery', {
-                            link: `<a href="${to('localized.groupGallery', group.directory)}">${
-                                strings('groupInfoPage.viewAlbumGallery.link')
-                            }</a>`
-                        })
-                    }</p>
-                    <ul>
-                        ${group.albums.map(album => fixWS`
-                            <li>${
-                                strings('groupInfoPage.albumList.item', {
-                                    year: album.date.getFullYear(),
-                                    album: `<a href="${to('localized.album', album.directory)}" style="${getLinkThemeString(album)}">${album.name}</a>`
-                                })
-                            }</li>
-                        `).join('\n')}
-                    </ul>
-                `
-            },
-
-            sidebarLeft: generateSidebarForGroup(group, {strings, to, isGallery: false}),
-            nav: generateNavForGroup(group, {strings, to, isGallery: false})
-        }));
-
-        await writePage('groupGallery', group.directory, ({to}) => ({
-            title: strings('groupGalleryPage.title', {group: group.name}),
-            theme: getThemeString(group),
-
-            main: {
-                classes: ['top-index'],
-                content: fixWS`
-                    <h1>${strings('groupGalleryPage.title', {group: group.name})}</h1>
-                    <p class="quick-info">${
-                        strings('groupGalleryPage.infoLine', {
-                            tracks: `<b>${strings.count.tracks(releasedTracks.length, {unit: true})}</b>`,
-                            albums: `<b>${strings.count.albums(releasedAlbums.length, {unit: true})}</b>`,
-                            time: `<b>${strings.count.duration(totalDuration, {unit: true})}</b>`
-                        })
-                    }</p>
-                    ${wikiInfo.features.groupUI && wikiInfo.features.listings && `<p class="quick-info">(<a href="${to('localized.listing', 'groups/by-category')}">Choose another group to filter by!</a>)</p>`}
-                    <div class="grid-listing">
-                        ${getAlbumGridHTML({
-                            strings, to,
-                            entries: C.sortByDate(group.albums.map(item => ({item}))).reverse(),
-                            details: true
-                        })}
-                    </div>
-                `
-            },
-
-            sidebarLeft: generateSidebarForGroup(group, {strings, to, isGallery: true}),
-            nav: generateNavForGroup(group, {strings, to, isGallery: true})
-        }));
-    };
-}
-
-function toAnythingMan(anythingMan, to) {
-    return (
-        albumData.includes(anythingMan) ? to('localized.album', anythingMan.directory) :
-        trackData.includes(anythingMan) ? to('localized.track', anythingMan.directory) :
-        flashData?.includes(anythingMan) ? to('localized.flash', anythingMan.directory) :
-        'idk-bud'
-    )
-}
-
-function getAlbumCover(album, {to}) {
-    return to('media.albumCover', album.directory);
-}
-
-function getTrackCover(track, {to}) {
-    // Some al8ums don't have any track art at all, and in those, every track
-    // just inherits the al8um's own cover art.
-    if (track.coverArtists === null) {
-        return getAlbumCover(track.album, {to});
-    } else {
-        return to('media.trackCover', track.album.directory, track.directory);
-    }
-}
-
-function getFlashLink(flash) {
-    return `https://homestuck.com/story/${flash.page}`;
-}
-
-function classes(...args) {
-    const values = args.filter(Boolean);
-    return `class="${values.join(' ')}"`;
-}
-
-async function processLanguageFile(file, defaultStrings = null) {
-    let contents;
-    try {
-        contents = await readFile(file, 'utf-8');
-    } catch (error) {
-        return {error: `Could not read ${file} (${error.code}).`};
-    }
-
-    let json;
-    try {
-        json = JSON.parse(contents);
-    } catch (error) {
-        return {error: `Could not parse JSON from ${file} (${error}).`};
-    }
-
-    return genStrings(json, defaultStrings);
-}
-
-// Wrapper function for running a function once for all languages. It provides:
-// * the language strings
-// * a shadowing writePages function for outputing to the appropriate subdir
-// * a shadowing urls object for linking to the appropriate relative paths
-async function wrapLanguages(fn, writeOneLanguage = null) {
-    const k = writeOneLanguage
-    const languagesToRun = (k
-        ? {[k]: languages[k]}
-        : languages)
-
-    const entries = Object.entries(languagesToRun)
-        .filter(([ key ]) => key !== 'default');
-
-    for (let i = 0; i < entries.length; i++) {
-        const [ key, strings ] = entries[i];
-
-        const baseDirectory = (strings === languages.default ? '' : strings.code);
-
-        const shadow_writePage = (urlKey, directory, pageFn) => writePage(strings, baseDirectory, urlKey, directory, pageFn);
-
-        // 8ring the utility functions over too!
-        Object.assign(shadow_writePage, writePage);
-
-        await fn({
-            baseDirectory,
-            strings,
-            writePage: shadow_writePage
-        }, i, entries);
-    }
-}
-
-async function main() {
-    const miscOptions = await parseOptions(process.argv.slice(2), {
-        // Data files for the site, including flash, artist, and al8um data,
-        // and like a jillion other things too. Pretty much everything which
-        // makes an individual wiki what it is goes here!
-        'data-path': {
-            type: 'value'
-        },
-
-        // Static media will 8e referenced in the site here! The contents are
-        // categorized; check out MEDIA_DIRECTORY and rel8ted constants in
-        // common/common.js. (This gets symlinked into the --data directory.)
-        'media-path': {
-            type: 'value'
-        },
-
-        // String files! For the most part, this is used for translating the
-        // site to different languages, though you can also customize strings
-        // for your own 8uild of the site if you'd like. Files here should all
-        // match the format in strings-default.json in this repository. (If a
-        // language file is missing any strings, the site code will fall 8ack
-        // to what's specified in strings-default.json.)
-        //
-        // Unlike the other options here, this one's optional - the site will
-        // 8uild with the default (English) strings if this path is left
-        // unspecified.
-        'lang-path': {
-            type: 'value'
-        },
-
-        // This is the output directory. It's the one you'll upload online with
-        // rsync or whatever when you're pushing an upd8, and also the one
-        // you'd archive if you wanted to make a 8ackup of the whole dang
-        // site. Just keep in mind that the gener8ted result will contain a
-        // couple symlinked directories, so if you're uploading, you're pro8a8ly
-        // gonna want to resolve those yourself.
-        'out-path': {
-            type: 'value'
-        },
-
-        // Thum8nail gener8tion is *usually* something you want, 8ut it can 8e
-        // kinda a pain to run every time, since it does necessit8te reading
-        // every media file at run time. Pass this to skip it.
-        'skip-thumbs': {
-            type: 'flag'
-        },
-
-        // Only want 8uild one language during testing? This can chop down
-        // 8uild times a pretty 8ig chunk! Just pass a single language code.
-        'lang': {
-            type: 'value'
-        },
-
-        'queue-size': {
-            type: 'value',
-            validate(size) {
-                if (parseInt(size) !== parseFloat(size)) return 'an integer';
-                if (parseInt(size) < 0) return 'a counting number or zero';
-                return true;
-            }
-        },
-        queue: {alias: 'queue-size'},
-
-        [parseOptions.handleUnknown]: () => {}
-    });
-
-    dataPath = miscOptions['data-path'] || process.env.HSMUSIC_DATA;
-    mediaPath = miscOptions['media-path'] || process.env.HSMUSIC_MEDIA;
-    langPath = miscOptions['lang-path'] || process.env.HSMUSIC_LANG; // Can 8e left unset!
-    outputPath = miscOptions['out-path'] || process.env.HSMUSIC_OUT;
-
-    const writeOneLanguage = miscOptions['lang'];
-
-    {
-        let errored = false;
-        const error = (cond, msg) => {
-            if (cond) {
-                console.error(`\x1b[31;1m${msg}\x1b[0m`);
-                errored = true;
-            }
-        };
-        error(!dataPath,   `Expected --data option or HSMUSIC_DATA to be set`);
-        error(!mediaPath,  `Expected --media option or HSMUSIC_MEDIA to be set`);
-        error(!outputPath, `Expected --out option or HSMUSIC_OUT to be set`);
-        if (errored) {
-            return;
-        }
-    }
-
-    const skipThumbs = miscOptions['skip-thumbs'] ?? false;
-
-    if (skipThumbs) {
-        logInfo`Skipping thumbnail generation.`;
-    } else {
-        logInfo`Begin thumbnail generation... -----+`;
-        const result = await genThumbs(mediaPath, {queueSize, quiet: true});
-        logInfo`Done thumbnail generation! --------+`;
-        if (!result) {
-            return;
-        }
-    }
-
-    const defaultStrings = await processLanguageFile(path.join(__dirname, DEFAULT_STRINGS_FILE));
-    if (defaultStrings.error) {
-        logError`Error loading default strings: ${defaultStrings.error}`;
-        return;
-    }
-
-    if (langPath) {
-        const languageDataFiles = await findFiles(langPath, f => path.extname(f) === '.json');
-        const results = await progressPromiseAll(`Reading & processing language files.`, languageDataFiles
-            .map(file => processLanguageFile(file, defaultStrings.json)));
-
-        let error = false;
-        for (const strings of results) {
-            if (strings.error) {
-                logError`Error loading provided strings: ${strings.error}`;
-                error = true;
-            }
-        }
-        if (error) return;
-
-        languages = Object.fromEntries(results.map(strings => [strings.code, strings]));
-    } else {
-        languages = {};
-    }
-
-    if (!languages[defaultStrings.code]) {
-        languages[defaultStrings.code] = defaultStrings;
-    }
-
-    logInfo`Loaded language strings: ${Object.keys(languages).join(', ')}`;
-
-    if (writeOneLanguage && !(writeOneLanguage in languages)) {
-        logError`Specified to write only ${writeOneLanguage}, but there is no strings file with this language code!`;
-        return;
-    } else if (writeOneLanguage) {
-        logInfo`Writing only language ${writeOneLanguage} this run.`;
-    } else {
-        logInfo`Writing all languages.`;
-    }
-
-    wikiInfo = await processWikiInfoFile(path.join(dataPath, WIKI_INFO_FILE));
-    if (wikiInfo.error) {
-        console.log(`\x1b[31;1m${wikiInfo.error}\x1b[0m`);
-        return;
-    }
-
-    // Update languages o8ject with the wiki-specified default language!
-    // This will make page files for that language 8e gener8ted at the root
-    // directory, instead of the language-specific su8directory.
-    if (wikiInfo.defaultLanguage) {
-        if (Object.keys(languages).includes(wikiInfo.defaultLanguage)) {
-            languages.default = languages[wikiInfo.defaultLanguage];
-        } else {
-            logError`Wiki info file specified default language is ${wikiInfo.defaultLanguage}, but no such language file exists!`;
-            if (langPath) {
-                logError`Check if an appropriate file exists in ${langPath}?`;
-            } else {
-                logError`Be sure to specify ${'--lang'} or ${'HSMUSIC_LANG'} with the path to language files.`;
-            }
-            return;
-        }
-    } else {
-        languages.default = defaultStrings;
-    }
-
-    homepageInfo = await processHomepageInfoFile(path.join(dataPath, HOMEPAGE_INFO_FILE));
-
-    if (homepageInfo.error) {
-        console.log(`\x1b[31;1m${homepageInfo.error}\x1b[0m`);
-        return;
-    }
-
-    {
-        const errors = homepageInfo.rows.filter(obj => obj.error);
-        if (errors.length) {
-            for (const error of errors) {
-                console.log(`\x1b[31;1m${error.error}\x1b[0m`);
-            }
-            return;
-        }
-    }
-
-    // 8ut wait, you might say, how do we know which al8um these data files
-    // correspond to???????? You wouldn't dare suggest we parse the actual
-    // paths returned 8y this function, which ought to 8e of effectively
-    // unknown format except for their purpose as reada8le data files!?
-    // To that, I would say, yeah, you're right. Thanks a 8unch, my projection
-    // of "you". We're going to read these files later, and contained within
-    // will 8e the actual directory names that the data correspond to. Yes,
-    // that's redundant in some ways - we COULD just return the directory name
-    // in addition to the data path, and duplicating that name within the file
-    // itself suggests we 8e careful to avoid mismatching it - 8ut doing it
-    // this way lets the data files themselves 8e more porta8le (meaning we
-    // could store them all in one folder, if we wanted, and this program would
-    // still output to the correct al8um directories), and also does make the
-    // function's signature simpler (an array of strings, rather than some kind
-    // of structure containing 8oth data file paths and output directories).
-    // This is o8jectively a good thing, 8ecause it means the function can stay
-    // truer to its name, and have a narrower purpose: it doesn't need to
-    // concern itself with where we *output* files, or whatever other reasons
-    // we might (hypothetically) have for knowing the containing directory.
-    // And, in the strange case where we DO really need to know that info, we
-    // callers CAN use path.dirname to find out that data. 8ut we'll 8e
-    // avoiding that in our code 8ecause, again, we want to avoid assuming the
-    // format of the returned paths here - they're only meant to 8e used for
-    // reading as-is.
-    const albumDataFiles = await findFiles(path.join(dataPath, C.DATA_ALBUM_DIRECTORY));
-
-    // Technically, we could do the data file reading and output writing at the
-    // same time, 8ut that kinda makes the code messy, so I'm not 8othering
-    // with it.
-    albumData = await progressPromiseAll(`Reading & processing album files.`, albumDataFiles.map(processAlbumDataFile));
-
-    {
-        const errors = albumData.filter(obj => obj.error);
-        if (errors.length) {
-            for (const error of errors) {
-                console.log(`\x1b[31;1m${error.error}\x1b[0m`);
-            }
-            return;
-        }
-    }
-
-    C.sortByDate(albumData);
-
-    artistData = await processArtistDataFile(path.join(dataPath, ARTIST_DATA_FILE));
-    if (artistData.error) {
-        console.log(`\x1b[31;1m${artistData.error}\x1b[0m`);
-        return;
-    }
-
-    {
-        const errors = artistData.filter(obj => obj.error);
-        if (errors.length) {
-            for (const error of errors) {
-                console.log(`\x1b[31;1m${error.error}\x1b[0m`);
-            }
-            return;
-        }
-    }
-
-    artistAliasData = artistData.filter(x => x.alias);
-    artistData = artistData.filter(x => !x.alias);
-
-    trackData = C.getAllTracks(albumData);
-
-    if (wikiInfo.features.flashesAndGames) {
-        flashData = await processFlashDataFile(path.join(dataPath, FLASH_DATA_FILE));
-        if (flashData.error) {
-            console.log(`\x1b[31;1m${flashData.error}\x1b[0m`);
-            return;
-        }
-
-        const errors = flashData.filter(obj => obj.error);
-        if (errors.length) {
-            for (const error of errors) {
-                console.log(`\x1b[31;1m${error.error}\x1b[0m`);
-            }
-            return;
-        }
-    }
-
-    flashActData = flashData?.filter(x => x.act8r8k);
-    flashData = flashData?.filter(x => !x.act8r8k);
-
-    artistNames = Array.from(new Set([
-        ...artistData.filter(artist => !artist.alias).map(artist => artist.name),
-        ...[
-            ...albumData.flatMap(album => [
-                ...album.artists || [],
-                ...album.coverArtists || [],
-                ...album.wallpaperArtists || [],
-                ...album.tracks.flatMap(track => [
-                    ...track.artists,
-                    ...track.coverArtists || [],
-                    ...track.contributors || []
-                ])
-            ]),
-            ...(flashData?.flatMap(flash => [
-                ...flash.contributors || []
-            ]) || [])
-        ].map(contribution => contribution.who)
-    ]));
-
-    tagData = await processTagDataFile(path.join(dataPath, TAG_DATA_FILE));
-    if (tagData.error) {
-        console.log(`\x1b[31;1m${tagData.error}\x1b[0m`);
-        return;
-    }
-
-    {
-        const errors = tagData.filter(obj => obj.error);
-        if (errors.length) {
-            for (const error of errors) {
-                console.log(`\x1b[31;1m${error.error}\x1b[0m`);
-            }
-            return;
-        }
-    }
-
-    groupData = await processGroupDataFile(path.join(dataPath, GROUP_DATA_FILE));
-    if (groupData.error) {
-        console.log(`\x1b[31;1m${groupData.error}\x1b[0m`);
-        return;
-    }
-
-    {
-        const errors = groupData.filter(obj => obj.error);
-        if (errors.length) {
-            for (const error of errors) {
-                console.log(`\x1b[31;1m${error.error}\x1b[0m`);
-            }
-            return;
-        }
-    }
-
-    groupCategoryData = groupData.filter(x => x.isCategory);
-    groupData = groupData.filter(x => x.isGroup);
-
-    staticPageData = await processStaticPageDataFile(path.join(dataPath, STATIC_PAGE_DATA_FILE));
-    if (staticPageData.error) {
-        console.log(`\x1b[31;1m${staticPageData.error}\x1b[0m`);
-        return;
-    }
-
-    {
-        const errors = staticPageData.filter(obj => obj.error);
-        if (errors.length) {
-            for (const error of errors) {
-                console.log(`\x1b[31;1m${error.error}\x1b[0m`);
-            }
-            return;
-        }
-    }
-
-    if (wikiInfo.features.news) {
-        newsData = await processNewsDataFile(path.join(dataPath, NEWS_DATA_FILE));
-        if (newsData.error) {
-            console.log(`\x1b[31;1m${newsData.error}\x1b[0m`);
-            return;
-        }
-
-        const errors = newsData.filter(obj => obj.error);
-        if (errors.length) {
-            for (const error of errors) {
-                console.log(`\x1b[31;1m${error.error}\x1b[0m`);
-            }
-            return;
-        }
-
-        C.sortByDate(newsData);
-        newsData.reverse();
-    }
-
-    {
-        const tagNames = new Set([...trackData, ...albumData].flatMap(thing => thing.artTags));
-
-        for (let { name, isCW } of tagData) {
-            if (isCW) {
-                name = 'cw: ' + name;
-            }
-            tagNames.delete(name);
-        }
-
-        if (tagNames.size) {
-            for (const name of Array.from(tagNames).sort()) {
-                console.log(`\x1b[33;1m- Missing tag: "${name}"\x1b[0m`);
-            }
-            return;
-        }
-    }
-
-    artistNames.sort((a, b) => a.toLowerCase() < b.toLowerCase() ? -1 : a.toLowerCase() > b.toLowerCase() ? 1 : 0);
-
-    justEverythingMan = C.sortByDate([...albumData, ...trackData, ...(flashData || [])]);
-    justEverythingSortedByArtDateMan = C.sortByArtDate(justEverythingMan.slice());
-    // console.log(JSON.stringify(justEverythingSortedByArtDateMan.map(toAnythingMan), null, 2));
-
-    {
-        let buffer = [];
-        const clearBuffer = function() {
-            if (buffer.length) {
-                for (const entry of buffer.slice(0, -1)) {
-                    console.log(`\x1b[2m... ${entry.name} ...\x1b[0m`);
-                }
-                const lastEntry = buffer[buffer.length - 1];
-                console.log(`\x1b[2m... \x1b[0m${lastEntry.name}\x1b[0;2m ...\x1b[0m`);
-                buffer = [];
-            }
-        };
-        const showWhere = (name, color) => {
-            const where = justEverythingMan.filter(thing => [
-                ...thing.coverArtists || [],
-                ...thing.contributors || [],
-                ...thing.artists || []
-            ].some(({ who }) => who === name));
-            for (const thing of where) {
-                console.log(`\x1b[${color}m- ` + (thing.album ? `(\x1b[1m${thing.album.name}\x1b[0;${color}m)` : '') + ` \x1b[1m${thing.name}\x1b[0m`);
-            }
-        };
-        let CR4SH = false;
-        for (let name of artistNames) {
-            const entry = [...artistData, ...artistAliasData].find(entry => entry.name === name || entry.name.toLowerCase() === name.toLowerCase());
-            if (!entry) {
-                clearBuffer();
-                console.log(`\x1b[31mMissing entry for artist "\x1b[1m${name}\x1b[0;31m"\x1b[0m`);
-                showWhere(name, 31);
-                CR4SH = true;
-            } else if (entry.alias) {
-                console.log(`\x1b[33mArtist "\x1b[1m${name}\x1b[0;33m" should be named "\x1b[1m${entry.alias}\x1b[0;33m"\x1b[0m`);
-                showWhere(name, 33);
-                CR4SH = true;
-            } else if (entry.name !== name) {
-                console.log(`\x1b[33mArtist "\x1b[1m${name}\x1b[0;33m" should be named "\x1b[1m${entry.name}\x1b[0;33m"\x1b[0m`);
-                showWhere(name, 33);
-                CR4SH = true;
-            } else {
-                buffer.push(entry);
-                if (buffer.length > 3) {
-                    buffer.shift();
-                }
-            }
-        }
-        if (CR4SH) {
-            return;
-        }
-    }
-
-    {
-        const directories = [];
-        for (const { directory, name } of albumData) {
-            if (directories.includes(directory)) {
-                console.log(`\x1b[31;1mDuplicate album directory "${directory}" (${name})\x1b[0m`);
-                return;
-            }
-            directories.push(directory);
-        }
-    }
-
-    {
-        const directories = [];
-        const where = {};
-        for (const { directory, album } of trackData) {
-            if (directories.includes(directory)) {
-                console.log(`\x1b[31;1mDuplicate track directory "${directory}"\x1b[0m`);
-                console.log(`Shows up in:`);
-                console.log(`- ${album.name}`);
-                console.log(`- ${where[directory].name}`);
-                return;
-            }
-            directories.push(directory);
-            where[directory] = album;
-        }
-    }
-
-    {
-        const artists = [];
-        const artistsLC = [];
-        for (const name of artistNames) {
-            if (!artists.includes(name) && artistsLC.includes(name.toLowerCase())) {
-                const other = artists.find(oth => oth.toLowerCase() === name.toLowerCase());
-                console.log(`\x1b[31;1mMiscapitalized artist name: ${name}, ${other}\x1b[0m`);
-                return;
-            }
-            artists.push(name);
-            artistsLC.push(name.toLowerCase());
-        }
-    }
-
-    {
-        for (const { references, name, album } of trackData) {
-            for (const ref of references) {
-                if (!search.track(ref)) {
-                    logWarn`Track not found "${ref}" in ${name} (${album.name})`;
-                }
-            }
-        }
-    }
-
-    contributionData = Array.from(new Set([
-        ...trackData.flatMap(track => [...track.artists || [], ...track.contributors || [], ...track.coverArtists || []]),
-        ...albumData.flatMap(album => [...album.artists || [], ...album.coverArtists || [], ...album.wallpaperArtists || [], ...album.bannerArtists || []]),
-        ...(flashData?.flatMap(flash => [...flash.contributors || []]) || [])
-    ]));
-
-    // Now that we have all the data, resolve references all 8efore actually
-    // gener8ting any of the pages, 8ecause page gener8tion is going to involve
-    // accessing these references a lot, and there's no reason to resolve them
-    // more than once. (We 8uild a few additional links that can't 8e cre8ted
-    // at initial data processing time here too.)
-
-    const filterNullArray = (parent, key) => {
-        for (const obj of parent) {
-            const array = obj[key];
-            for (let i = 0; i < array.length; i++) {
-                if (!array[i]) {
-                    const prev = array[i - 1] && array[i - 1].name;
-                    const next = array[i + 1] && array[i + 1].name;
-                    logWarn`Unexpected null in ${obj.name} (${obj.what}) (array key ${key} - prev: ${prev}, next: ${next})`;
-                }
-            }
-            array.splice(0, array.length, ...array.filter(Boolean));
-        }
-    };
-
-    const filterNullValue = (parent, key) => {
-        parent.splice(0, parent.length, ...parent.filter(obj => {
-            if (!obj[key]) {
-                logWarn`Unexpected null in ${obj.name} (value key ${key})`;
-            }
-        }));
-    };
-
-    trackData.forEach(track => mapInPlace(track.references, search.track));
-    trackData.forEach(track => track.aka = search.track(track.aka));
-    trackData.forEach(track => mapInPlace(track.artTags, search.tag));
-    albumData.forEach(album => mapInPlace(album.groups, search.group));
-    albumData.forEach(album => mapInPlace(album.artTags, search.tag));
-    artistAliasData.forEach(artist => artist.alias = search.artist(artist.alias));
-    contributionData.forEach(contrib => contrib.who = search.artist(contrib.who));
-
-    filterNullArray(trackData, 'references');
-    filterNullArray(trackData, 'artTags');
-    filterNullArray(albumData, 'groups');
-    filterNullArray(albumData, 'artTags');
-    filterNullValue(artistAliasData, 'alias');
-    filterNullValue(contributionData, 'who');
-
-    trackData.forEach(track1 => track1.referencedBy = trackData.filter(track2 => track2.references.includes(track1)));
-    groupData.forEach(group => group.albums = albumData.filter(album => album.groups.includes(group)));
-    tagData.forEach(tag => tag.things = C.sortByArtDate([...albumData, ...trackData]).filter(thing => thing.artTags.includes(tag)));
-
-    groupData.forEach(group => group.category = groupCategoryData.find(x => x.name === group.category));
-    groupCategoryData.forEach(category => category.groups = groupData.filter(x => x.category === category));
-
-    trackData.forEach(track => track.otherReleases = [
-        track.aka,
-        ...trackData.filter(({ aka }) => aka === track || (track.aka && aka === track.aka)),
-    ].filter(x => x && x !== track));
-
-    if (wikiInfo.features.flashesAndGames) {
-        flashData.forEach(flash => mapInPlace(flash.tracks, search.track));
-        flashData.forEach(flash => flash.act = flashActData.find(act => act.name === flash.act));
-        flashActData.forEach(act => act.flashes = flashData.filter(flash => flash.act === act));
-
-        filterNullArray(flashData, 'tracks');
-
-        trackData.forEach(track => track.flashes = flashData.filter(flash => flash.tracks.includes(track)));
-    }
-
-    artistData.forEach(artist => {
-        const filterProp = (array, prop) => array.filter(thing => thing[prop]?.some(({ who }) => who === artist));
-        const filterCommentary = array => array.filter(thing => thing.commentary && thing.commentary.replace(/<\/?b>/g, '').includes('<i>' + artist.name + ':</i>'));
-        artist.tracks = {
-            asArtist: filterProp(trackData, 'artists'),
-            asCommentator: filterCommentary(trackData),
-            asContributor: filterProp(trackData, 'contributors'),
-            asCoverArtist: filterProp(trackData, 'coverArtists'),
-            asAny: trackData.filter(track => (
-                [...track.artists, ...track.contributors, ...track.coverArtists || []].some(({ who }) => who === artist)
-            ))
-        };
-        artist.albums = {
-            asArtist: filterProp(albumData, 'artists'),
-            asCommentator: filterCommentary(albumData),
-            asCoverArtist: filterProp(albumData, 'coverArtists'),
-            asWallpaperArtist: filterProp(albumData, 'wallpaperArtists'),
-            asBannerArtist: filterProp(albumData, 'bannerArtists')
-        };
-        if (wikiInfo.features.flashesAndGames) {
-            artist.flashes = {
-                asContributor: filterProp(flashData, 'contributors')
-            };
-        }
-    });
-
-    officialAlbumData = albumData.filter(album => album.groups.some(group => group.directory === C.OFFICIAL_GROUP_DIRECTORY));
-    fandomAlbumData = albumData.filter(album => album.groups.every(group => group.directory !== C.OFFICIAL_GROUP_DIRECTORY));
-
-    // Makes writing a little nicer on CPU theoretically, 8ut also costs in
-    // performance right now 'cuz it'll w8 for file writes to 8e completed
-    // 8efore moving on to more data processing. So, defaults to zero, which
-    // disa8les the queue feature altogether.
-    queueSize = +(miscOptions['queue-size'] ?? 0);
-
-    // NOT for ena8ling or disa8ling specific features of the site!
-    // This is only in charge of what general groups of files to 8uild.
-    // They're here to make development quicker when you're only working
-    // on some particular area(s) of the site rather than making changes
-    // across all of them.
-    const writeFlags = await parseOptions(process.argv.slice(2), {
-        all: {type: 'flag'}, // Defaults to true if none 8elow specified.
-
-        album: {type: 'flag'},
-        artist: {type: 'flag'},
-        commentary: {type: 'flag'},
-        flash: {type: 'flag'},
-        group: {type: 'flag'},
-        list: {type: 'flag'},
-        misc: {type: 'flag'},
-        news: {type: 'flag'},
-        static: {type: 'flag'},
-        tag: {type: 'flag'},
-        track: {type: 'flag'},
-
-        [parseOptions.handleUnknown]: () => {}
-    });
-
-    const writeAll = !Object.keys(writeFlags).length || writeFlags.all;
-
-    logInfo`Writing site pages: ${writeAll ? 'all' : Object.keys(writeFlags).join(', ')}`;
-
-    await writeSymlinks();
-    await writeSharedFilesAndPages({strings: defaultStrings});
-
-    const buildDictionary = {
-        misc: writeMiscellaneousPages,
-        news: writeNewsPages,
-        list: writeListingPages,
-        tag: writeTagPages,
-        commentary: writeCommentaryPages,
-        static: writeStaticPages,
-        group: writeGroupPages,
-        album: writeAlbumPages,
-        track: writeTrackPages,
-        artist: writeArtistPages,
-        flash: writeFlashPages
-    };
-
-    const buildSteps = (writeAll
-        ? Object.values(buildDictionary)
-        : (Object.entries(buildDictionary)
-            .filter(([ flag ]) => writeFlags[flag])
-            .map(([ flag, fn ]) => fn)));
-
-    // *NB: While what's 8elow is 8asically still true in principle, the
-    //      format is QUITE DIFFERENT than what's descri8ed here! There
-    //      will 8e actual document8tion on like, what the return format
-    //      looks like soon, once we implement a 8unch of other pages and
-    //      are certain what they actually, uh, will look like, in the end.*
-    //
-    // The writeThingPages functions don't actually immediately do any file
-    // writing themselves; an initial call will only gather the relevant data
-    // which is *then* used for writing. So the return value is a function
-    // (or an array of functions) which expects {writePage, strings}, and
-    // *that's* what we call after -- multiple times, once for each language.
-    let writes;
-    {
-        let error = false;
-
-        writes = buildSteps.flatMap(fn => {
-            const fns = fn() || [];
-
-            // Do a quick valid8tion! If one of the writeThingPages functions go
-            // wrong, this will stall out early and tell us which did.
-            if (!Array.isArray(fns)) {
-                logError`${fn.name} didn't return an array!`;
-                error = true;
-            } else if (fns.every(entry => Array.isArray(entry))) {
-                if (!(
-                    fns.every(entry => entry.every(obj => typeof obj === 'object')) &&
-                    fns.every(entry => entry.every(obj => {
-                        const result = validateWriteObject(obj);
-                        if (result.error) {
-                            logError`Validating write object failed: ${result.error}`;
-                            return false;
-                        } else {
-                            return true;
-                        }
-                    }))
-                )) {
-                    logError`${fn.name} uses updated format, but entries are invalid!`;
-                    error = true;
-                }
-
-                return fns.flatMap(writes => writes);
-            } else if (fns.some(fn => typeof fn !== 'function')) {
-                logError`${fn.name} didn't return all functions or all arrays!`;
-                error = true;
-            }
-
-            return fns;
-        });
-
-        if (error) {
-            return;
-        }
-
-        // The modern(TM) return format for each writeThingPages function is an
-        // array of arrays, each of which's items are 8ig Complicated Objects
-        // that 8asically look like {type, path, content}. 8ut surprise, these
-        // aren't actually implemented in most places yet! So, we transform
-        // stuff in the old format here. 'Scept keep in mind, the OLD FORMAT
-        // doesn't really give us most of the info we want for Cool And Modern
-        // Reasons, so they're going into a fancy {type: 'legacy'} sort of
-        // o8ject, with a plain {write} property for, uh, the writing stuff,
-        // same as usual.
-        //
-        // I promise this document8tion will get 8etter when we make progress
-        // actually moving old pages over. Also it'll 8e hecks of less work
-        // than previous restructures, don't worry.
-        writes = writes.map(entry =>
-            typeof entry === 'object' ? entry :
-            typeof entry === 'function' ? {type: 'legacy', write: entry} :
-            {type: 'wut', entry});
-
-        const wut = writes.filter(({ type }) => type === 'wut');
-        if (wut.length) {
-            // Oh g*d oh h*ck.
-            logError`Uhhhhh writes contains something 8esides o8jects and functions?`;
-            logError`Definitely a 8ug!`;
-            console.log(wut);
-            return;
-        }
-    }
-
-    const localizedWrites = writes.filter(({ type }) => type === 'page' || type === 'legacy');
-    const dataWrites = writes.filter(({ type }) => type === 'data');
-
-    await progressPromiseAll(`Writing data files shared across languages.`, queue(
-        // TODO: This only supports one <>-style argument.
-        dataWrites.map(({path, data}) => () => writeData(path[0], path[1], data())),
-        queueSize
-    ));
-
-    await wrapLanguages(async ({strings, ...opts}, i, entries) => {
-        console.log(`\x1b[34;1m${
-            (`[${i + 1}/${entries.length}] ${strings.code} (-> /${opts.baseDirectory}) `
-                .padEnd(60, '-'))
-        }\x1b[0m`);
-        await progressPromiseAll(`Writing ${strings.code}`, queue(
-            localizedWrites.map(({type, ...props}) => () => {
-                switch (type) {
-                    case 'legacy': {
-                        const { write } = props;
-                        return write({strings, ...opts});
-                    }
-                    case 'page': {
-                        const { path, page } = props;
-                        // TODO: This only supports one <>-style argument.
-                        return opts.writePage(path[0], path[1], ({to}) => page({strings, to}));
-                    }
-                }
-            }),
-            queueSize
-        ));
-    }, writeOneLanguage);
-
-    decorateTime.displayTime();
-
-    // The single most important step.
-    logInfo`Written!`;
-}
-
-main().catch(error => console.error(error));