bookish-press 0.8.2 → 0.9.2

package/dist/epub/package.js

@@ -0,0 +1,392 @@
+/**
+ * Assembles the documents that make up an EPUB 3 package.
+ *
+ * Nothing here touches the network or the DOM, so it can be unit tested and is
+ * safe to import during server rendering.
+ */
+import Reference from '../models/book/Reference';
+import FormatNode from '../models/chapter/FormatNode';
+import Parser from '../models/chapter/Parser';
+import { chapterPath, document_, endnoteSection, escapeAttribute, escapeText, serializeChapter, serializeFormat, } from './xhtml';
+export const MIMETYPE = 'application/epub+zip';
+/** Where the package's documents live inside the archive. */
+export const CONTENT_DIRECTORY = 'OEBPS';
+export const CONTAINER = `<?xml version="1.0" encoding="utf-8"?>
+<container version="1.0" xmlns="urn:oasis:names:tc:opendocument:xmlns:container">
+<rootfiles>
+<rootfile full-path="${CONTENT_DIRECTORY}/content.opf" media-type="application/oebps-package+xml"/>
+</rootfiles>
+</container>`;
+/**
+ * The packaged stylesheet.
+ *
+ * Two rules govern it. First, it sets no typeface and no absolute size for
+ * prose: e-reader users choose their own, and overriding that is the most
+ * common way an EPUB becomes unpleasant to read. (Code is the one exception --
+ * code that doesn't look like code is just wrong.) The book's own theme is not
+ * carried across either, since it imports fonts an offline reader can't fetch
+ * and encodes color e-ink can't show.
+ *
+ * Second, and learned the hard way on an XTeink X3: it assumes the reading
+ * system has *no* default stylesheet. Small readers often have barely any, so
+ * anything left unsaid is left unrendered -- headings came out all one size,
+ * ordered lists came out bulleted, and a definition list ran together into a
+ * paragraph. Every element the serializer can emit is given its display,
+ * spacing and emphasis here rather than being assumed. The contract test in
+ * stylesheet.test.ts derives that element list from the serializer itself, so
+ * a new node type that emits a new element fails until this file covers it.
+ */
+export const STYLESHEET = `/* Reading systems with a minimal default stylesheet render unknown elements
+   inline, so every block element states that it is one. */
+article, aside, details, div, dl, dd, dt, figcaption, figure, footer,
+header, hgroup, main, nav, section, blockquote, p, h1, h2, h3, h4, h5, h6,
+hr, ol, ul, pre { display: block; }
+li { display: list-item; }
+table { display: table; }
+thead { display: table-header-group; }
+tbody { display: table-row-group; }
+tr { display: table-row; }
+th, td { display: table-cell; }
+caption { display: table-caption; }
+
+body { margin: 0 5%; line-height: 1.5; widows: 2; orphans: 2; }
+
+/* An explicit scale, in em so the reader's chosen size still governs. Without
+   it a reader with no defaults renders every level at body size. */
+h1, h2, h3, h4, h5, h6 {
+    font-weight: bold;
+    line-height: 1.2;
+    margin: 1.2em 0 0.6em;
+    page-break-after: avoid;
+    break-after: avoid;
+}
+h1 { font-size: 1.6em; margin: 2em 0 1em; }
+h2 { font-size: 1.35em; }
+h3 { font-size: 1.2em; }
+h4 { font-size: 1.1em; }
+h5 { font-size: 1em; }
+h6 { font-size: 0.9em; }
+
+p { margin: 0; text-indent: 1.2em; }
+/* The first paragraph of a section is not a continuation, so it isn't indented. */
+p.first, h1 + p, h2 + p, h3 + p, h4 + p, h5 + p, h6 + p,
+blockquote p:first-child, li > p:first-child { text-indent: 0; }
+
+strong { font-weight: bold; }
+em { font-style: italic; }
+sup { vertical-align: super; font-size: 0.75em; line-height: 0; }
+sub { vertical-align: sub; font-size: 0.75em; line-height: 0; }
+a { text-decoration: underline; }
+
+.chapter-number { display: block; margin-bottom: 0.5em; text-transform: uppercase; letter-spacing: 0.1em; font-size: 0.8em; }
+.section-name { display: block; font-style: italic; }
+.authors { display: block; font-style: italic; }
+
+figure { margin: 1.5em 0; text-align: center; page-break-inside: avoid; break-inside: avoid; }
+img { max-width: 100%; }
+figcaption { font-size: 0.85em; text-align: left; margin-top: 0.5em; }
+figcaption p { margin: 0; text-indent: 0; }
+.credit { font-style: italic; }
+.missing-image figcaption { text-align: center; font-style: italic; }
+
+blockquote { margin: 1.5em 2em; font-style: italic; }
+blockquote p { text-indent: 0; }
+cite { font-style: normal; font-size: 0.85em; }
+
+.callout { margin: 1.5em 1em; padding-left: 1em; border-left: 3px solid currentColor; }
+.callout p { text-indent: 0; }
+
+/* The one place a family is set: monospace is what distinguishes code from
+   prose, and without it the two are indistinguishable. */
+pre, code, pre code, kbd, samp { font-family: monospace; }
+pre { font-size: 0.8em; white-space: pre-wrap; overflow-wrap: break-word; margin: 1.5em 0; }
+code { font-size: 0.9em; }
+
+table { border-collapse: collapse; margin: 1.5em auto; font-size: 0.9em; }
+th, td { border: 1px solid currentColor; padding: 0.3em 0.5em; text-align: left; }
+th { font-weight: bold; }
+caption { font-size: 0.85em; margin-bottom: 0.5em; }
+caption p { margin: 0; text-indent: 0; }
+
+/* Outside, so a wrapped item hangs with its text aligned rather than tucking
+   under the marker. Types are stated because a reader with no defaults numbers
+   nothing, and mirror how the web reader nests them. */
+ul, ol { margin: 1em 0; padding-left: 1.5em; list-style-position: outside; }
+ul { list-style-type: disc; }
+ul ul { list-style-type: circle; }
+ul ul ul { list-style-type: square; }
+ol { list-style-type: decimal; }
+ol ol { list-style-type: lower-alpha; }
+ol ol ol { list-style-type: upper-alpha; }
+li { margin-bottom: 0.25em; }
+
+hr { border: 0; border-top: 1px solid currentColor; margin: 2em auto; width: 30%; }
+
+.citation, .noteref { font-size: 0.75em; }
+.notes { margin-top: 3em; font-size: 0.9em; page-break-before: always; break-before: page; }
+.note { margin-bottom: 0.5em; }
+.note p { text-indent: 0; margin-bottom: 0.5em; }
+
+.reference { margin-bottom: 0.8em; }
+
+/* The glossary is paragraphs rather than a definition list: see
+   glossaryDocument. Terms and meanings are distinguished by class. */
+.definition { margin-bottom: 1em; }
+.term { font-weight: bold; text-indent: 0; margin-top: 1em; }
+.meaning { text-indent: 0; margin-left: 1.5em; }
+.synonyms { font-size: 0.85em; font-style: italic; text-indent: 0; margin: 0.25em 0 0 1.5em; }
+`;
+/** Chapters that get their own document, in reading order. */
+export function includedChapters(edition) {
+    // Forthcoming chapters have no text to include, matching the print view.
+    return edition.getChapters().filter((chapter) => !chapter.isForthcoming());
+}
+/** Turn a title into something usable as a filename. */
+export function safeFilename(title) {
+    const cleaned = title
+        .replace(/[^\p{L}\p{N}]+/gu, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase();
+    return cleaned.length > 0 ? cleaned.slice(0, 80) : 'book';
+}
+/** The plain-text form of a Bookdown string, for metadata. */
+function text(edition, bookdown) {
+    return Parser.parseFormat(edition, bookdown).toText().trim();
+}
+/** The title page, which carries the metadata a reader wants up front. */
+export function titleDocument(edition, context) {
+    const title = edition.getTitle();
+    const authors = edition.getAuthors();
+    const description = edition.getDescription();
+    const acknowledgements = edition.getAcknowledgements();
+    const license = edition.getLicense();
+    const body = `<section class="title-page" epub:type="titlepage">
+<h1>${escapeText(title)}</h1>
+${authors.length > 0
+        ? `<p class="authors">${authors
+            .map((author) => serializeFormat(Parser.parseFormat(edition, author), context))
+            .join(', ')}</p>`
+        : ''}
+<p class="edition">${escapeText(edition.getEditionLabel())} edition</p>
+${description.trim().length > 0
+        ? `<p class="description">${serializeFormat(Parser.parseFormat(edition, description), context)}</p>`
+        : ''}
+${acknowledgements.trim().length > 0
+        ? `<section class="acknowledgements"><h2>${escapeText(edition.getHeader('acknowledgements'))}</h2><p>${serializeFormat(Parser.parseFormat(edition, acknowledgements), context)}</p></section>`
+        : ''}
+${license.trim().length > 0
+        ? `<section class="license"><h2>${escapeText(edition.getHeader('license'))}</h2><p>${serializeFormat(Parser.parseFormat(edition, license), context)}</p></section>`
+        : ''}
+</section>`;
+    return {
+        path: 'title.xhtml',
+        id: 'title',
+        content: document_(title, body),
+        navTitle: 'Title Page',
+    };
+}
+/** A page that displays the cover image, which some readers expect. */
+export function coverDocument(imagePath) {
+    return {
+        path: 'cover.xhtml',
+        id: 'cover',
+        content: document_('Cover', `<section epub:type="cover" class="cover"><figure><img src="${escapeAttribute(imagePath)}" alt="Cover"/></figure></section>`),
+    };
+}
+/** One chapter, with its footnotes gathered into endnotes at the end. */
+export function chapterDocument(edition, chapter, context) {
+    const ast = chapter.getAST(edition);
+    if (ast === undefined)
+        return undefined;
+    const { body, endnotes } = serializeChapter(ast, context);
+    const number = edition.getChapterNumber(chapter.getID());
+    const section = chapter.getSection();
+    const authors = chapter.getAuthors();
+    const header = `<header>
+${number !== undefined
+        ? `<span class="chapter-number">Chapter ${number}</span>`
+        : ''}
+<h1>${escapeText(chapter.getTitle())}</h1>
+${section ? `<span class="section-name">${escapeText(section)}</span>` : ''}
+${authors.length > 0
+        ? `<p class="authors">${authors
+            .map((author) => serializeFormat(Parser.parseFormat(edition, author), context))
+            .join(', ')}</p>`
+        : ''}
+</header>`;
+    return {
+        path: chapterPath(chapter.getID()),
+        id: `chapter-${chapter.getID()}`,
+        content: document_(chapter.getTitle(), `${header}\n${body}\n${endnoteSection(endnotes)}`),
+        navTitle: number !== undefined
+            ? `${number}. ${chapter.getTitle()}`
+            : chapter.getTitle(),
+    };
+}
+/** Render a reference the way the web reader's Reference.svelte does. */
+function referenceContent(reference, context) {
+    if (reference instanceof FormatNode)
+        return serializeFormat(reference, context);
+    const title = escapeText(reference.title);
+    // The web reader omits the period when the title already ends in one.
+    const period = reference.title.trim().endsWith('?') ? '' : '.';
+    return `${escapeText(reference.authors)} (${escapeText(reference.year)}). ${reference.url
+        ? `<a href="${escapeAttribute(encodeURI(String(reference.url)))}">${title}</a>`
+        : title}${period} <em>${escapeText(reference.source)}</em>${reference.summary ? ` ${escapeText(reference.summary)}` : ''}`;
+}
+/** The references back matter, whose anchors the citations link to. */
+export function referencesDocument(edition, context) {
+    const references = edition.getReferences();
+    const ids = Object.keys(references).sort();
+    if (ids.length === 0)
+        return undefined;
+    const header = edition.getHeader('references');
+    const body = `<section epub:type="bibliography">
+<h1>${escapeText(header)}</h1>
+${ids
+        .map((id) => `<p class="reference" id="ref-${escapeAttribute(id)}">${referenceContent(references[id], context)}</p>`)
+        .join('\n')}
+</section>`;
+    return {
+        path: 'references.xhtml',
+        id: 'references',
+        content: document_(header, body),
+        navTitle: header,
+    };
+}
+/** The glossary back matter, whose anchors the definitions link to. */
+export function glossaryDocument(edition, context) {
+    const glossary = edition.getGlossary();
+    const ids = Object.keys(glossary).sort((a, b) => glossary[a].phrase.localeCompare(glossary[b].phrase));
+    if (ids.length === 0)
+        return undefined;
+    const header = edition.getHeader('glossary');
+    // Paragraphs rather than a <dl>. Definition lists are poorly supported by
+    // e-readers -- a term and its meaning run together into one paragraph on a
+    // reader that doesn't know <dt>/<dd> -- and <dt> takes only phrasing
+    // content, so there is no way to put a block inside it that would survive.
+    // The semantics are carried by the classes instead.
+    const body = `<section epub:type="glossary">
+<h1>${escapeText(header)}</h1>
+${ids
+        .map((id) => {
+        const entry = glossary[id];
+        const synonyms = entry.synonyms ?? [];
+        // The web glossary renders no id, so its anchors don't resolve; here
+        // they must, because every definition in the text links to one.
+        return `<div class="definition">
+<p class="term" id="gloss-${escapeAttribute(id)}"><strong>${escapeText(entry.phrase)}</strong></p>
+<p class="meaning">${serializeFormat(Parser.parseFormat(edition, entry.definition), context)}</p>${synonyms.length > 0
+            ? `\n<p class="synonyms">${escapeText(synonyms.join(', '))}</p>`
+            : ''}
+</div>`;
+    })
+        .join('\n')}
+</section>`;
+    return {
+        path: 'glossary.xhtml',
+        id: 'glossary',
+        content: document_(header, body),
+        navTitle: header,
+    };
+}
+/** The EPUB 3 navigation document. */
+export function navigationDocument(documents) {
+    const listed = documents.filter((d) => d.navTitle !== undefined);
+    const body = `<nav epub:type="toc" id="toc">
+<h1>Contents</h1>
+<ol>
+${listed
+        .map((d) => `<li><a href="${escapeAttribute(d.path)}">${escapeText(d.navTitle)}</a></li>`)
+        .join('\n')}
+</ol>
+</nav>`;
+    return {
+        path: 'nav.xhtml',
+        id: 'nav',
+        content: document_('Contents', body),
+    };
+}
+/**
+ * The EPUB 2 navigation document. Superseded by nav.xhtml, but older Kindle and
+ * Kobo firmware still looks for it, and it costs a few hundred bytes.
+ */
+export function ncxDocument(identifier, title, documents) {
+    const listed = documents.filter((d) => d.navTitle !== undefined);
+    return `<?xml version="1.0" encoding="utf-8"?>
+<ncx xmlns="http://www.daisy.org/z3986/2005/ncx/" version="2005-1">
+<head>
+<meta name="dtb:uid" content="${escapeAttribute(identifier)}"/>
+<meta name="dtb:depth" content="1"/>
+<meta name="dtb:totalPageCount" content="0"/>
+<meta name="dtb:maxPageNumber" content="0"/>
+</head>
+<docTitle><text>${escapeText(title)}</text></docTitle>
+<navMap>
+${listed
+        .map((d, index) => `<navPoint id="nav-${index}" playOrder="${index + 1}">
+<navLabel><text>${escapeText(d.navTitle)}</text></navLabel>
+<content src="${escapeAttribute(d.path)}"/>
+</navPoint>`)
+        .join('\n')}
+</navMap>
+</ncx>`;
+}
+/** The package document: metadata, manifest, and reading order. */
+export function packageDocument(edition, identifier, documents, images, modified) {
+    const cover = images.find((image) => image.cover);
+    const authors = edition.getAuthors().map((a) => text(edition, a));
+    const published = edition.published;
+    const metadata = [
+        `<dc:identifier id="pub-id">${escapeText(identifier)}</dc:identifier>`,
+        `<dc:title>${escapeText(edition.getTitle())}</dc:title>`,
+        // The edition model has no language field, so this is a fixed guess.
+        `<dc:language>en</dc:language>`,
+        ...authors.map((author, index) => `<dc:creator id="creator-${index}">${escapeText(author)}</dc:creator>`),
+        published !== null
+            ? `<dc:date>${new Date(published).toISOString()}</dc:date>`
+            : '',
+        edition.getLicense().trim().length > 0
+            ? `<dc:rights>${escapeText(text(edition, edition.getLicense()))}</dc:rights>`
+            : '',
+        edition.getDescription().trim().length > 0
+            ? `<dc:description>${escapeText(text(edition, edition.getDescription()))}</dc:description>`
+            : '',
+        ...edition
+            .getTags()
+            .map((tag) => `<dc:subject>${escapeText(tag)}</dc:subject>`),
+        // Required by EPUB 3, and must not carry milliseconds.
+        `<meta property="dcterms:modified">${modified
+            .toISOString()
+            .replace(/\.\d{3}Z$/, 'Z')}</meta>`,
+        // The legacy way to declare a cover, which EPUB 2 readers look for.
+        cover ? `<meta name="cover" content="${cover.id}"/>` : '',
+    ]
+        .filter((line) => line.length > 0)
+        .join('\n');
+    const manifest = [
+        `<item id="nav" href="nav.xhtml" media-type="application/xhtml+xml" properties="nav"/>`,
+        `<item id="ncx" href="toc.ncx" media-type="application/x-dtbncx+xml"/>`,
+        `<item id="style" href="style.css" media-type="text/css"/>`,
+        ...documents
+            .filter((d) => d.id !== 'nav')
+            .map((d) => `<item id="${escapeAttribute(d.id)}" href="${escapeAttribute(d.path)}" media-type="application/xhtml+xml"/>`),
+        ...images.map((image) => `<item id="${escapeAttribute(image.id)}" href="${escapeAttribute(image.path)}" media-type="${escapeAttribute(image.mediaType)}"${image.cover ? ' properties="cover-image"' : ''}/>`),
+    ].join('\n');
+    const spine = documents
+        .filter((d) => d.id !== 'nav')
+        .map((d) => `<itemref idref="${escapeAttribute(d.id)}"/>`)
+        .join('\n');
+    return `<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://www.idpf.org/2007/opf" version="3.0" unique-identifier="pub-id">
+<metadata xmlns:dc="http://purl.org/dc/elements/1.1/">
+${metadata}
+</metadata>
+<manifest>
+${manifest}
+</manifest>
+<spine toc="ncx">
+${spine}
+</spine>
+</package>`;
+}

package/dist/epub/stylesheet.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/epub/stylesheet.test.js

@@ -0,0 +1,243 @@
+import { expect, test } from 'vitest';
+import Parser from '../models/chapter/Parser';
+import Edition from '../models/book/Edition';
+import { STYLESHEET, chapterDocument, coverDocument, glossaryDocument, navigationDocument, referencesDocument, titleDocument, } from './package';
+import { document_, endnoteSection, serializeChapter, } from './xhtml';
+/**
+ * The packaged stylesheet has to assume the reading system supplies nothing.
+ * Small e-readers often have almost no default stylesheet, so anything left
+ * unsaid is left unrendered: headings came out all one size, ordered lists came
+ * out bulleted, and a definition list ran together into one paragraph on an
+ * XTeink X3 until this was covered.
+ */
+function makeEdition(options = {}) {
+    return Edition.fromJSON(undefined, {
+        title: 'Test',
+        authors: [],
+        number: 1,
+        summary: '',
+        published: null,
+        images: {},
+        description: '',
+        chapters: [
+            {
+                id: 'sample',
+                title: 'Sample',
+                authors: ['An Author'],
+                image: null,
+                numbered: true,
+                forthcoming: false,
+                section: 'A Section',
+                text: EVERYTHING,
+                uids: [],
+            },
+        ],
+        license: '',
+        acknowledgements: '',
+        tags: [],
+        sources: {},
+        references: options.references ?? {},
+        symbols: {},
+        glossary: options.glossary ?? {},
+        theme: null,
+        uids: [],
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    });
+}
+/** Bookdown exercising every construct the serializer can render. */
+const EVERYTHING = `:label A paragraph with *bold*, _italic_, ^sup^, ^vsub^, \`code\`js and a [link|https://example.com].
+
+# Header one
+
+## Header two
+
+### Header three
+
+#### Header four
+
+* A bullet
+
+* Another bullet
+
+A paragraph, because the parser merges adjacent lists into one.
+
+1. Numbered
+
+2. Also numbered
+
+\`python
+print(1)
+\`A code caption
+
+"
+A quotation.
+"Someone
+
+=
+A callout.
+=
+
+,Head A|Head B
+,Cell one|Cell two
+A table caption
+
+|photo.jpg|Alt text|A caption|A credit|
+
+-
+
+A footnote{a note}, a citation<ref>, and a ~term~gloss.`;
+/**
+ * Every element name the packager can put into an EPUB: the chapter serializer
+ * plus each of the standalone documents. The glossary's definition list only
+ * comes from the last of those, which is exactly where the device bug was.
+ */
+function emittedElements() {
+    const edition = makeEdition({
+        references: { ref: 'A reference.' },
+        glossary: {
+            gloss: { phrase: 'term', definition: 'A meaning', synonyms: ['x'] },
+        },
+    });
+    const context = {
+        edition,
+        images: new Map([['photo.jpg', 'images/0.jpg']]),
+        chapters: new Set(['other']),
+    };
+    const { body, endnotes } = serializeChapter(Parser.parseChapter(edition, EVERYTHING), context);
+    const documents = [
+        // The whole document, so the head and body wrappers are covered too.
+        document_('Title', body + endnoteSection(endnotes)),
+        // The chapter document adds the header block around that body.
+        chapterDocument(edition, edition.getChapters()[0], context)?.content,
+        titleDocument(edition, context).content,
+        coverDocument('images/0.jpg').content,
+        referencesDocument(edition, context)?.content,
+        glossaryDocument(edition, context)?.content,
+        navigationDocument([titleDocument(edition, context)]).content,
+    ].filter((content) => content !== undefined);
+    const elements = new Set();
+    for (const content of documents)
+        for (const match of content.matchAll(/<([a-zA-Z][a-zA-Z0-9]*)[\s/>]/g))
+            elements.add(match[1].toLowerCase());
+    return elements;
+}
+/** Elements that are inline or structural, so they need no display rule. */
+const NO_DISPLAY_RULE_NEEDED = new Set([
+    // Document structure, styled by the reading system's chrome.
+    'html',
+    'head',
+    'body',
+    'title',
+    'meta',
+    'link',
+    // Genuinely inline.
+    'a',
+    'span',
+    'strong',
+    'em',
+    'sup',
+    'sub',
+    'code',
+    'cite',
+    'br',
+    'img',
+]);
+/** Whether the stylesheet gives an element an explicit display. */
+function hasDisplayRule(element) {
+    // Match the element as a whole selector token in any rule that sets display.
+    for (const [, selectors, body] of STYLESHEET.matchAll(/([^{}]+)\{([^}]*)\}/g)) {
+        if (!/(^|[;\s])display\s*:/.test(body))
+            continue;
+        const tokens = selectors
+            .split(',')
+            .map((selector) => selector.trim().split(/\s+/).pop() ?? '');
+        if (tokens.includes(element))
+            return true;
+    }
+    return false;
+}
+test('every element the serializer emits has an explicit display', () => {
+    const missing = [...emittedElements()]
+        .filter((element) => !NO_DISPLAY_RULE_NEEDED.has(element))
+        .filter((element) => !hasDisplayRule(element))
+        .sort();
+    expect(missing, `these elements would render inline on a reader with no default stylesheet: ${missing.join(', ')}`).toEqual([]);
+});
+test('the fixture really does exercise the elements that broke on a device', () => {
+    // Guards the test above: if the fixture stopped emitting these, it would
+    // pass while covering nothing.
+    const emitted = emittedElements();
+    for (const element of [
+        'table',
+        'thead',
+        'tbody',
+        'tr',
+        'th',
+        'td',
+        'caption',
+        'figure',
+        'figcaption',
+        'section',
+        'aside',
+        'header',
+        'ol',
+        'ul',
+        'li',
+        'pre',
+        'code',
+        'h1',
+        'h2',
+    ])
+        expect(emitted, `fixture no longer emits ${element}`).toContain(element);
+});
+test('headings are given distinct, decreasing sizes', () => {
+    const sizes = [1, 2, 3, 4, 5, 6].map((level) => {
+        const match = STYLESHEET.match(new RegExp(`(^|\\n)h${level}\\s*\\{[^}]*font-size:\\s*([\\d.]+)em`));
+        expect(match, `h${level} has no font-size`).not.toBeNull();
+        return Number(match?.[2]);
+    });
+    // Strictly decreasing, so levels are distinguishable.
+    for (let i = 1; i < sizes.length; i++)
+        expect(sizes[i], `h${i + 1} is not smaller than h${i}`).toBeLessThan(sizes[i - 1]);
+    // Relative units only, so the reader's chosen base size still governs.
+    expect(STYLESHEET).not.toMatch(/font-size:\s*\d+(px|pt)/);
+});
+test('code is monospace, and it is the only family the stylesheet sets', () => {
+    expect(STYLESHEET).toMatch(/pre[^{}]*\{[^}]*font-family:\s*monospace/);
+    // Prose keeps whatever the reader chose.
+    const families = [...STYLESHEET.matchAll(/font-family:\s*([^;]+);/g)].map((match) => match[1].trim());
+    expect(families).toEqual(families.map(() => 'monospace'));
+});
+test('ordered lists are numbered and unordered ones are not', () => {
+    expect(STYLESHEET).toMatch(/(^|\n)ol\s*\{[^}]*list-style-type:\s*decimal/);
+    expect(STYLESHEET).toMatch(/(^|\n)ul\s*\{[^}]*list-style-type:\s*disc/);
+});
+test('list markers sit outside, so wrapped items hang', () => {
+    expect(STYLESHEET).toMatch(/list-style-position:\s*outside/);
+});
+test('a glossary term and its meaning are separate paragraphs', () => {
+    // Definition lists flatten on readers that don't know <dt>/<dd>, and <dt>
+    // takes only phrasing content so nothing block-level can be nested inside
+    // it. The glossary uses classed paragraphs instead.
+    const glossary = glossaryDocument(makeEdition({
+        glossary: {
+            gloss: {
+                phrase: 'term',
+                definition: 'A meaning',
+                synonyms: ['x'],
+            },
+        },
+    }), {
+        edition: makeEdition(),
+        images: new Map(),
+        chapters: new Set(),
+    })?.content;
+    expect(glossary).not.toContain('<dl');
+    expect(glossary).toContain('<p class="term" id="gloss-gloss">');
+    expect(glossary).toContain('<p class="meaning">');
+    // Bold via an element, since font-weight is one of the few properties a
+    // minimal reader honours but the term must survive even without CSS.
+    expect(glossary).toContain('<strong>term</strong>');
+    expect(STYLESHEET).toMatch(/\.term\s*\{[^}]*font-weight:\s*bold/);
+    expect(STYLESHEET).toMatch(/\.definition\s*\{[^}]*margin/);
+});