@gentbajko/slopify 2.0.3 → 2.1.1

package/dist/slices/document/pages.js

@@ -0,0 +1,198 @@
+import { useFace } from "./fonts.js";
+const dateFormat = new Intl.DateTimeFormat("en-US", {
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+});
+export function writtenOn(date) {
+    return dateFormat.format(date);
+}
+// Brand, tagline, title, the cover when there is one, then the date, word count and link.
+export function titlePage(w, title, words, date, cover) {
+    const { theme, doc } = w;
+    const { fonts, sizes, titlePage: layout, brand } = theme;
+    const centre = w.width / 2;
+    if (brand.name !== null) {
+        w.write(brand.name, centre, layout.brandY, fonts.dramatic, sizes.brand, "heading", "center");
+        if (brand.url !== null) {
+            const width = doc.getTextWidth(brand.name);
+            doc.link(centre - width / 2, layout.brandY - 8, width, 10, { url: brand.url });
+        }
+    }
+    if (brand.tagline !== null)
+        w.write(brand.tagline, centre, layout.brandY + layout.taglineOffset, fonts.decorative, sizes.body, "heading", "center");
+    useFace(doc, fonts.heading, sizes.title);
+    let y = layout.titleY;
+    for (const line of doc.splitTextToSize(title, w.contentWidth)) {
+        w.write(line, centre, y, fonts.heading, sizes.title, "text", "center");
+        y += layout.titleLine;
+    }
+    // Without a cover the details sit where lore2script2 put them; with one, just under it.
+    let meta = y + layout.metaOffset;
+    if (cover !== null && layout.cover.enabled) {
+        const top = y - layout.titleLine + layout.cover.gap;
+        const below = layout.cover.gap + layout.metaLine * 3;
+        const room = Math.min(layout.cover.maxHeight, w.bottom - below - top);
+        const { width, height } = doc.getImageProperties(cover.data);
+        if (room > 0 && width > 0 && height > 0) {
+            const scale = Math.min(w.contentWidth / width, room / height);
+            doc.addImage(cover.data, cover.format, centre - (width * scale) / 2, top, width * scale, height * scale);
+            meta = top + height * scale + layout.cover.gap + layout.metaLine;
+        }
+    }
+    const line = (text, color, decorative = false) => {
+        w.write(text, centre, meta, decorative ? fonts.decorative : fonts.body, sizes.meta, color, "center");
+        meta += layout.metaLine;
+    };
+    if (layout.showDate)
+        line(`Written on ${writtenOn(date)}`, "muted");
+    if (layout.showWordCount)
+        line(`Word Count: ${words.toLocaleString("en-US")}`, "muted");
+    if (brand.linkLabel !== null) {
+        const at = meta;
+        line(brand.linkLabel, "heading", true);
+        if (brand.url !== null) {
+            const width = doc.getTextWidth(brand.linkLabel);
+            doc.link(centre - width / 2, at - 8, width, 10, { url: brand.url });
+        }
+    }
+}
+// How many pages the contents need for `entries` one-line entries, laid out exactly as
+// fillContents lays them out, so they can be kept free before the body is written.
+export function contentsPages(w, entries) {
+    const { contents } = w.theme;
+    if (!contents.enabled || entries === 0)
+        return 0;
+    let pages = 1;
+    let y = w.left + contents.firstEntryOffset;
+    for (let entry = 0; entry < entries; entry += 1) {
+        if (y + contents.line > w.bottom) {
+            pages += 1;
+            y = w.theme.header.top + contents.titleOffset;
+        }
+        y += contents.line;
+    }
+    return pages;
+}
+export function fillContents(w, first, entries) {
+    const { doc, theme } = w;
+    const { contents, fonts, sizes } = theme;
+    if (!contents.enabled || entries.length === 0)
+        return;
+    let page = first;
+    doc.setPage(page);
+    w.write(contents.title, w.width / 2, w.left + contents.titleOffset, fonts.heading, sizes.section, "heading", "center");
+    const top = Math.min(...entries.map((entry) => entry.level));
+    let y = w.left + contents.firstEntryOffset;
+    for (const entry of entries) {
+        if (y + contents.line > w.bottom) {
+            page += 1;
+            doc.setPage(page);
+            y = theme.header.top + contents.titleOffset;
+        }
+        const indent = (entry.level - top) * contents.indent;
+        const number = String(entry.page);
+        useFace(doc, fonts.body, sizes.body);
+        const numberX = w.width - w.left - doc.getTextWidth(number);
+        const room = numberX - (w.left + indent) - 10;
+        let label = entry.title;
+        if (doc.getTextWidth(label) > room) {
+            while (label.length > 1 && doc.getTextWidth(`${label}...`) > room)
+                label = label.slice(0, -1);
+            label = `${label.trimEnd()}...`;
+        }
+        w.write(label, w.left + indent, y, fonts.body, sizes.body, "text");
+        const labelEnd = w.left + indent + doc.getTextWidth(label) + 3;
+        w.write(number, numberX, y, fonts.body, sizes.body, "text");
+        doc.link(w.left, y - 6, w.contentWidth, 8, { pageNumber: entry.page });
+        const dot = doc.getTextWidth(".") * 1.5;
+        for (let x = labelEnd; x + dot < numberX - 3; x += dot)
+            w.write(".", x, y, fonts.body, sizes.body, "muted");
+        y += contents.line;
+    }
+}
+export function sourcesPage(w, items) {
+    const { doc, theme } = w;
+    const { fonts, sizes, sources } = theme;
+    if (!sources.enabled || items.length === 0)
+        return null;
+    w.addPage();
+    w.write(sources.title, w.left, w.left + sources.titleOffset, fonts.heading, sizes.section, "heading");
+    const entry = { title: sources.title, level: 1, page: w.page() };
+    w.y = w.left + sources.bodyOffset;
+    useFace(doc, fonts.body, sizes.body);
+    const bullet = doc.getTextWidth("• ");
+    for (const item of items) {
+        useFace(doc, fonts.body, sizes.body);
+        const lines = doc.splitTextToSize(item.text, w.contentWidth - bullet - 5);
+        w.ensure(sources.line);
+        w.write("•", w.left, w.y, fonts.body, sizes.body, "muted");
+        for (const line of lines) {
+            w.ensure(sources.line);
+            w.write(line, w.left + bullet, w.y, fonts.body, sizes.body, item.href === null ? "text" : "heading");
+            if (item.href !== null)
+                doc.link(w.left + bullet, w.y - 5, doc.getTextWidth(line), 7, { url: item.href });
+            w.y += sources.line;
+        }
+        w.y += sources.gap;
+    }
+    return entry;
+}
+// The closing page: the theme's lines, then the document's details and the call to action.
+export function endPage(w, words, date) {
+    const { doc, theme } = w;
+    const { fonts, sizes, endPage: end } = theme;
+    if (!end.enabled)
+        return null;
+    w.addPage();
+    w.write(end.title, w.left, w.left + end.titleOffset, fonts.heading, sizes.section, "heading");
+    const entry = { title: end.title, level: 1, page: w.page() };
+    const lines = [...end.lines];
+    if (end.showDocumentDetails) {
+        if (lines.length > 0)
+            lines.push("");
+        lines.push("Document Details:", `• Written On: ${writtenOn(date)}`, `• Total Words: ${words.toLocaleString("en-US")}`, `• Total Pages: ${doc.getNumberOfPages()}`);
+    }
+    const line = theme.spacing.bodyLine;
+    let y = w.left + end.bodyOffset;
+    for (const text of lines) {
+        if (text.startsWith("•"))
+            w.write(text, w.left + 5, y, fonts.body, sizes.body, "muted");
+        else if (text.endsWith(":"))
+            w.write(text, w.left, y, fonts.strong, sizes.body, "text");
+        else if (text !== "")
+            w.write(text, w.left, y, fonts.body, sizes.body, "text");
+        y += line;
+    }
+    const calls = [end.link?.text, end.closing].filter((text) => Boolean(text));
+    if (calls.length > 0)
+        y += line;
+    for (const text of calls) {
+        w.write(text, w.left, y, fonts.decorative, sizes.body, "heading");
+        if (text === end.link?.text && end.link.url !== null)
+            doc.link(w.left, y - 6, doc.getTextWidth(text), 8, { url: end.link.url });
+        y += line;
+    }
+    return entry;
+}
+// The running header ("Brand | Title") and page number on every page after the title page.
+export function headsAndFeet(w, title) {
+    const { doc, theme } = w;
+    const { fonts, sizes, header, footer, brand } = theme;
+    for (let page = 2; page <= doc.getNumberOfPages(); page += 1) {
+        doc.setPage(page);
+        if (header.enabled) {
+            useFace(doc, fonts.body, sizes.footer);
+            const shown = doc.getTextWidth(title) > w.contentWidth - 40
+                ? `${title.slice(0, header.maxTitleCharacters)}...`
+                : title;
+            const text = [brand.name, shown].filter(Boolean).join(" | ");
+            if (text !== "")
+                w.write(text, w.left, header.top, fonts.body, sizes.footer, "faint");
+            if (brand.name !== null && brand.url !== null)
+                doc.link(w.left, header.top - 6, doc.getTextWidth(brand.name), 8, { url: brand.url });
+        }
+        if (footer.enabled)
+            w.write(footer.text.replaceAll("{page}", String(page)), w.width / 2, w.height - footer.bottom, fonts.footer, sizes.footer, "faint", "center");
+    }
+}

package/dist/slices/document/render.js

@@ -0,0 +1,242 @@
+import { jsPDF } from "jspdf";
+import { runsText } from "./blocks.js";
+import { drawLine, wrapRuns } from "./flow.js";
+import { faceWidth, registerFonts, useFace } from "./fonts.js";
+import { contentsPages, endPage, fillContents, headsAndFeet, sourcesPage, titlePage, } from "./pages.js";
+import { documentText } from "./sources.js";
+import { createWriter } from "./writer.js";
+export function renderDocument(input) {
+    const { theme } = input;
+    const text = documentText(input.articleMarkdown, input.researchNotes);
+    const blocks = withoutTitle(text.blocks, input.title);
+    if (blocks.length === 0)
+        throw new Error("The article has no text to put in the document. Write or regenerate the article (Edit project → Article), then use Retry stage on Document.");
+    const words = blocks
+        .map((block) => block.kind === "heading" ? block.text : "runs" in block ? runsText(block.runs) : "")
+        .join(" ")
+        .split(/\s+/)
+        .filter((word) => word !== "").length;
+    const doc = new jsPDF({
+        orientation: "portrait",
+        unit: "mm",
+        format: theme.page.format,
+        compress: true,
+    });
+    registerFonts(doc, input.assets.cinzel);
+    const fill = (template) => template.replaceAll("{title}", input.title).trim();
+    doc.setProperties({
+        title: input.title,
+        author: fill(theme.metadata.author),
+        subject: fill(theme.metadata.subject),
+        keywords: fill(theme.metadata.keywords),
+        creator: fill(theme.metadata.creator),
+    });
+    const w = createWriter(doc, theme, input.assets);
+    const cover = coverImage(input.cover);
+    titlePage(w, input.title, words, input.writtenOn, cover === "unsupported" ? null : cover);
+    const listed = blocks.filter((block) => block.kind === "heading" && block.level <= theme.contents.depth).length;
+    const extra = (theme.sources.enabled && text.sources.length > 0 ? 1 : 0) + (theme.endPage.enabled ? 1 : 0);
+    const reserved = contentsPages(w, listed + extra);
+    for (let page = 0; page < reserved; page += 1)
+        w.addPage();
+    w.addPage();
+    const contents = [];
+    writeBody(w, blocks, contents);
+    // The sources and closing pages line up with the article's outermost headings.
+    const level = Math.min(3, ...contents.map((entry) => entry.level));
+    for (const page of [sourcesPage(w, text.sources), endPage(w, words, input.writtenOn)])
+        if (page !== null)
+            contents.push({ ...page, level });
+    if (reserved > 0)
+        fillContents(w, 2, contents);
+    headsAndFeet(w, input.title);
+    return {
+        bytes: new Uint8Array(doc.output("arraybuffer")),
+        pages: doc.getNumberOfPages(),
+        words,
+        contents,
+        sources: text.sources.length,
+        cover: cover === null ? "none" : cover === "unsupported" ? "unsupported" : "placed",
+    };
+}
+// The title page already carries the title, so an article that opens by repeating it
+// starts with its first real section instead.
+function withoutTitle(blocks, title) {
+    const at = blocks
+        .slice(0, 3)
+        .findIndex((block) => block.kind === "heading" && block.text.trim().toLowerCase() === title.trim().toLowerCase());
+    return at === -1 ? blocks : blocks.filter((_, index) => index !== at);
+}
+function coverImage(data) {
+    if (data === null)
+        return null;
+    const bytes = (...values) => values.every((value, index) => data[index] === value);
+    if (bytes(0x89, 0x50, 0x4e, 0x47))
+        return { data, format: "PNG" };
+    if (bytes(0xff, 0xd8, 0xff))
+        return { data, format: "JPEG" };
+    if (bytes(0x52, 0x49, 0x46, 0x46) && String.fromCharCode(...data.subarray(8, 12)) === "WEBP")
+        return { data, format: "WEBP" };
+    return "unsupported";
+}
+function writeBody(w, blocks, contents) {
+    const { theme } = w;
+    const line = theme.spacing.bodyLine;
+    const style = {
+        size: theme.sizes.body,
+        body: theme.fonts.body,
+        strong: theme.fonts.strong,
+        emphasis: theme.fonts.emphasis,
+        color: w.colors.text,
+        linkColor: w.colors.heading,
+    };
+    let afterHeading = false;
+    for (const [index, block] of blocks.entries()) {
+        if (block.kind === "heading") {
+            // A heading keeps the start of what follows it on its page: two lines, or all the
+            // room a drop-capped paragraph asks for, so the heading is never left at the foot.
+            const next = blocks[index + 1];
+            const keep = next?.kind === "paragraph" && dropCapLetter(theme, next.runs) !== null
+                ? dropCapRoom(w)
+                : theme.spacing.bodyLine * 2;
+            const entry = writeHeading(w, block, keep);
+            if (block.level <= theme.contents.depth)
+                contents.push(entry);
+            afterHeading = true;
+            continue;
+        }
+        if (block.kind === "rule") {
+            w.ensure(line);
+            const rgb = w.colors.muted;
+            w.doc.setDrawColor(rgb.r, rgb.g, rgb.b);
+            w.doc.setLineWidth(0.3);
+            const half = theme.spacing.ruleWidth / 2;
+            w.doc.line(w.width / 2 - half, w.y - line / 3, w.width / 2 + half, w.y - line / 3);
+            w.y += line;
+            continue;
+        }
+        if (block.kind === "paragraph") {
+            const cap = afterHeading ? dropCapLetter(theme, block.runs) : null;
+            if (cap === null)
+                writeLines(w, block.runs, style, 0, w.contentWidth);
+            else
+                writeDropCap(w, block.runs, style, cap);
+            w.y += line * theme.spacing.paragraphGap;
+        }
+        else if (block.kind === "item") {
+            const indent = block.depth * theme.spacing.listIndent;
+            w.ensure(line);
+            if (block.marker !== "")
+                w.write(block.marker, w.left + indent, w.y, theme.fonts.body, theme.sizes.body, "muted");
+            const text = indent + theme.spacing.listIndent;
+            writeLines(w, block.runs, style, text, w.contentWidth - text);
+            w.y += line * theme.spacing.itemGap;
+        }
+        else {
+            const indent = theme.spacing.quoteIndent;
+            const quote = { ...style, color: w.colors.muted };
+            const start = { page: w.page(), y: w.y };
+            writeLines(w, block.runs, quote, indent, w.contentWidth - indent * 2);
+            if (w.page() === start.page) {
+                const rgb = w.colors.heading;
+                w.doc.setDrawColor(rgb.r, rgb.g, rgb.b);
+                w.doc.setLineWidth(0.6);
+                const x = w.left + indent / 2;
+                w.doc.line(x, start.y - line * 0.6, x, w.y - line * 0.8);
+            }
+            w.y += line * theme.spacing.paragraphGap;
+        }
+        afterHeading = false;
+    }
+}
+function writeLines(w, runs, style, indent, width) {
+    const lines = wrapRuns(w.doc, runs, style, () => ({ indent, width }));
+    for (const one of lines) {
+        w.ensure(w.theme.spacing.bodyLine);
+        drawLine(w.doc, one, w.left, w.y, style.size);
+        w.y += w.theme.spacing.bodyLine;
+    }
+}
+const chapterHeading = /^(Chapter|Section|Part)\s+(\d+):?\s*([\s\S]*)$/i;
+// Level 1 and 2 are centred in the heading face at the section and heading sizes; a
+// "Chapter 3: Title – Subtitle" heading shows its number large with each part of the title
+// under it. Level 3 sits on the left, smaller.
+function writeHeading(w, block, keep) {
+    const { theme, doc } = w;
+    const { fonts, sizes, spacing } = theme;
+    if (w.y > theme.page.contentTop)
+        w.y += spacing.bodyLine * spacing.headingGap;
+    const sub = block.level === 3;
+    const size = block.level === 1 ? sizes.section : sub ? sizes.subheading : sizes.heading;
+    const lineHeight = sub ? spacing.subheadingLine : spacing.headingLine;
+    const chapter = sub ? null : chapterHeading.exec(block.text);
+    const parts = chapter === null
+        ? [block.text]
+        : (chapter[3] ?? "")
+            .split(/\s+[–—]\s+/)
+            .map((part) => part.trim())
+            .filter((part) => part !== "");
+    useFace(doc, fonts.heading, size);
+    const lines = parts.flatMap((part) => doc.splitTextToSize(part, w.contentWidth - (chapter === null ? 0 : 20)));
+    // The heading and the first lines under it stay on one page.
+    const height = lines.length * lineHeight + (chapter === null ? 0 : lineHeight * 1.5);
+    w.ensure(height + spacing.bodyLine * spacing.paragraphGap + keep);
+    const entry = { title: block.text, level: block.level, page: w.page() };
+    if (chapter !== null) {
+        w.write(chapter[2] ?? "", w.width / 2, w.y, fonts.dramatic, sizes.section, "heading", "center");
+        w.y += lineHeight * 1.5;
+    }
+    for (const text of lines) {
+        if (sub)
+            w.write(text, w.left, w.y, fonts.heading, size, "heading");
+        else
+            w.write(text, w.width / 2, w.y, fonts.heading, size, "heading", "center");
+        w.y += lineHeight;
+    }
+    w.y += spacing.bodyLine * spacing.paragraphGap;
+    return entry;
+}
+function dropCapLetter(theme, runs) {
+    const first = runs[0];
+    if (!theme.dropCap.enabled || first === undefined || first.href !== null)
+        return null;
+    if (runsText(runs).length < theme.dropCap.minLength)
+        return null;
+    const letter = [...first.text][0] ?? "";
+    return /\p{L}/u.test(letter) ? letter : null;
+}
+// The first letter set large across `lines` body lines, the text beside it narrowed, then
+// full width below it.
+function writeDropCap(w, runs, style, letter) {
+    const { theme, doc } = w;
+    const { dropCap } = theme;
+    const line = theme.spacing.bodyLine;
+    w.ensure(dropCapRoom(w));
+    const size = line * dropCap.lines * dropCap.scale;
+    const capital = letter.toUpperCase();
+    const capWidth = faceWidth(doc, theme.fonts.dropCap, size, capital) + dropCap.gap;
+    w.write(capital, w.left, w.y + line * (dropCap.lines - 1), theme.fonts.dropCap, size, "heading");
+    const [first, ...rest] = runs;
+    const remaining = first === undefined ? [] : [{ ...first, text: [...first.text].slice(1).join("") }, ...rest];
+    const top = w.y;
+    const lines = wrapRuns(doc, remaining, style, (index) => index < dropCap.lines
+        ? { indent: capWidth, width: w.contentWidth - capWidth }
+        : { indent: 0, width: w.contentWidth });
+    for (const [index, one] of lines.entries()) {
+        if (index >= dropCap.lines)
+            w.ensure(line);
+        drawLine(doc, one, w.left, w.y, style.size);
+        w.y += line;
+    }
+    // Text shorter than the initial still leaves its full height free.
+    w.y = Math.max(w.y, top + line * dropCap.lines);
+}
+// The room a drop-capped paragraph needs left on the page: the theme's share of it, and at
+// least the initial itself, which reaches about `lines * scale` body lines below its first
+// baseline.
+function dropCapRoom(w) {
+    const { theme } = w;
+    const { dropCap } = theme;
+    const usable = w.height - theme.page.margin - theme.header.top - theme.footer.bottom - theme.footer.reserve;
+    return Math.max(usable * dropCap.minRoom, theme.spacing.bodyLine * dropCap.lines * dropCap.scale);
+}

package/dist/slices/document/sources.js

@@ -0,0 +1,35 @@
+import { splitEndMatter } from "../article/split.js";
+import { markdownBlocks, markdownLinks, runsText } from "./blocks.js";
+// The pronunciation glossary is narration's business and is left out; the sources section
+// becomes the Sources page instead of being printed as body text.
+export function documentText(articleMarkdown, researchNotes) {
+    const parts = splitEndMatter(articleMarkdown);
+    const listed = sourceItems(parts.sources);
+    const seen = new Set(listed.flatMap((item) => (item.href === null ? [] : [item.href])));
+    const cited = [];
+    for (const link of researchNotes === null ? [] : markdownLinks(researchNotes)) {
+        if (seen.has(link.href) || !/^https?:\/\//i.test(link.href))
+            continue;
+        seen.add(link.href);
+        cited.push(link.text === link.href ? { text: link.href, href: link.href } : link);
+    }
+    return { blocks: markdownBlocks(parts.body), sources: [...listed, ...cited] };
+}
+function sourceItems(section) {
+    if (section.trim() === "")
+        return [];
+    // The section's own heading, whether a `#` line or a bold paragraph, is its first block.
+    return markdownBlocks(section)
+        .slice(1)
+        .flatMap((block) => {
+        if (block.kind !== "item" && block.kind !== "paragraph" && block.kind !== "quote")
+            return [];
+        const text = runsText(block.runs).trim();
+        if (text === "")
+            return [];
+        const href = block.runs.find((run) => run.href !== null)?.href ??
+            /https?:\/\/[^\s)>\]]+/.exec(text)?.[0] ??
+            null;
+        return [{ text, href }];
+    });
+}

package/dist/slices/document/theme.js

@@ -0,0 +1,158 @@
+import { defaultDocumentTheme } from "./model.js";
+// "Cinzel" is bundled (assets/document/fonts) in the styles below; the other three are the
+// PDF standard fonts every reader has.
+export const fontFamilies = ["Cinzel", "times", "helvetica", "courier"];
+export const fontStyles = ["normal", "medium", "bold", "black", "italic", "bolditalic"];
+const cinzel = (style, letterSpacing) => ({
+    family: "Cinzel",
+    style,
+    letterSpacing,
+});
+const dicemaster = {
+    page: { format: "a4", margin: 22, contentTop: 32 },
+    background: { image: "parchment", color: "#f5ebd7" },
+    colors: { heading: "#8c1e14", text: "#000000", muted: "#50463c", faint: "#786e5f" },
+    fonts: {
+        body: cinzel("normal", 0.01),
+        strong: cinzel("bold", 0.02),
+        // Cinzel has no italic, so emphasis borrows the standard serif's.
+        emphasis: { family: "times", style: "italic", letterSpacing: 0 },
+        heading: cinzel("bold", 0.02),
+        dramatic: cinzel("black", 0.03),
+        decorative: cinzel("medium", 0.015),
+        dropCap: cinzel("black", 0),
+        footer: { family: "times", style: "normal", letterSpacing: 0 },
+    },
+    // lore2script2 scaled its Cinzel sizes and line heights (by 1.1, 1.05 and 1.2) and
+    // rounded; these are the results.
+    sizes: {
+        brand: 31,
+        title: 22,
+        section: 19,
+        heading: 17,
+        subheading: 13,
+        body: 10.5,
+        footer: 9,
+        meta: 10,
+    },
+    spacing: {
+        bodyLine: 8,
+        headingLine: 11,
+        subheadingLine: 9,
+        paragraphGap: 0.5,
+        headingGap: 1,
+        itemGap: 0.2,
+        listIndent: 6,
+        quoteIndent: 8,
+        ruleWidth: 30,
+    },
+    dropCap: { enabled: true, lines: 3, scale: 3, gap: 4, minLength: 50, minRoom: 0.25 },
+    titlePage: {
+        brandY: 60,
+        taglineOffset: 10,
+        titleY: 80,
+        titleLine: 10,
+        metaOffset: 20,
+        metaLine: 10,
+        showDate: true,
+        showWordCount: true,
+        cover: { enabled: true, gap: 6, maxHeight: 110 },
+    },
+    contents: {
+        enabled: true,
+        title: "Table of Contents",
+        depth: 2,
+        titleOffset: 20,
+        firstEntryOffset: 40,
+        line: 8,
+        indent: 5,
+    },
+    header: { enabled: true, top: 15, maxTitleCharacters: 35 },
+    footer: { enabled: true, bottom: 10, reserve: 15, text: "Page {page}" },
+    brand: {
+        name: "DiceMaster.io",
+        url: "https://dicemaster.io/",
+        tagline: "Let us Handle the Crunch, You Focus on the Story",
+        linkLabel: "Visit DiceMaster.io",
+    },
+    metadata: {
+        author: "Created with DiceMaster.io",
+        subject: "{title} - Powered by DiceMaster.io",
+        keywords: "D&D, DnD, Dungeons and Dragons, lore, script, tabletop, RPG, TTRPG, DiceMaster.io",
+        creator: "DiceMaster.io - The AI-Powered Virtual Tabletop",
+    },
+    sources: {
+        enabled: true,
+        title: "Sources Consulted",
+        titleOffset: 20,
+        bodyOffset: 40,
+        line: 8,
+        gap: 2,
+    },
+    endPage: {
+        enabled: true,
+        title: "About DiceMaster.io",
+        titleOffset: 20,
+        bodyOffset: 40,
+        lines: [
+            "About DiceMaster.io:",
+            "• Character Engine - Form-driven creation with automatic leveling",
+            "• Automated Rules Engine - D&D mechanics and spells run automatically",
+            "• AI-Generated NPCs - Instant personalities with full stat blocks",
+            "• Granular Inventory Tracking - Live gear & condition management",
+            "• Real-Time Rule Guidance - Context-aware clarifications",
+            "• Dynamic Storytelling AI - On-the-fly narration & dialogue",
+            "• True-Physics Dice - RNG-driven rolls with animated suspense",
+            "• Cinematic Combat Module - Positional tracking & narrative summaries",
+            "• Voice Commands - Seamless STT/TTS multimodal interaction",
+            "• AI Dungeon Master Layer - Rules adjudication & encounter balancing",
+        ],
+        showDocumentDetails: true,
+        link: { text: "Visit DiceMaster.io", url: "https://dicemaster.io/" },
+        closing: "Experience the future of tabletop RPGs!",
+    },
+};
+const plain = {
+    background: { image: null, color: "#fdfaf3" },
+    colors: { heading: "#1f3a5f", text: "#1a1a1a", muted: "#555555", faint: "#888888" },
+    brand: { name: null, url: null, tagline: null, linkLabel: null },
+    metadata: { author: "", subject: "{title}", keywords: "D&D, lore", creator: "" },
+    endPage: { enabled: false },
+};
+export function builtInTheme(name) {
+    return name === "plain" ? resolveTheme(plain) : resolveTheme();
+}
+export function defaultTheme() {
+    return builtInTheme(defaultDocumentTheme);
+}
+// Unknown sections and keys throw, so a typo in a saved theme can't pass silently.
+export function resolveTheme(overrides = {}, base = dicemaster) {
+    const theme = structuredClone(base);
+    for (const [section, values] of Object.entries(overrides)) {
+        const target = theme[section];
+        if (target === undefined)
+            throw new Error(`Unknown document theme section "${section}" (expected one of: ${Object.keys(theme).join(", ")})`);
+        for (const [key, value] of Object.entries(values ?? {})) {
+            if (!(key in target))
+                throw new Error(`Unknown document theme setting "${section}.${key}" (expected one of: ${Object.keys(target).join(", ")})`);
+            target[key] = value;
+        }
+    }
+    const resolved = theme;
+    for (const [key, value] of Object.entries(resolved.colors))
+        parseHexColor(value, `colors.${key}`);
+    parseHexColor(resolved.background.color, "background.color");
+    return resolved;
+}
+export function parseHexColor(hex, label = "color") {
+    const match = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(hex.trim());
+    const digits = match?.[1];
+    if (digits === undefined)
+        throw new Error(`Invalid document theme ${label} "${hex}": expected a hex color like "#8c1e14"`);
+    const full = digits.length === 3 ? [...digits].map((digit) => digit + digit).join("") : digits;
+    return {
+        r: Number.parseInt(full.slice(0, 2), 16),
+        g: Number.parseInt(full.slice(2, 4), 16),
+        b: Number.parseInt(full.slice(4, 6), 16),
+    };
+}