bookish-press 0.4.47 → 0.4.49

package/src/lib/models/book/Edition.ts

@@ -1,1216 +0,0 @@
-import Chapter from './Chapter';
-import type { ChapterSpecification } from './Chapter';
-import Parser from '../chapter/Parser';
-import EmbedNode from '../chapter/EmbedNode';
-import Reference from './Reference';
-import type Theme from './Theme';
-import type Definition from './Definition.js';
-import ChapterIDs from './ChapterID.js';
-import type { DocumentReference } from 'firebase/firestore';
-import type Book from './Book';
-import type FormatNode from '../chapter/FormatNode';
-import type { EditionInfo } from './Book';
-
-export type EditionSpecification = {
-    bookRef: DocumentReference;
-    // The title of the book.
-    title: string;
-    // A numerical string indicating the version of the book. Can be any string, but is sorted alphanumerically.
-    number: number;
-    // A summary of the revisions in the edition
-    summary: string;
-    // A time stamp or nothing, indicating when the book was published.
-    published: number | null;
-    authors: string[];
-    images: Record<string, string | null>;
-    description: string;
-    chapters: ChapterSpecification[];
-    license: string;
-    acknowledgements: string;
-    tags: string[];
-    sources: Record<string, string>;
-    references: Record<string, string | string[]>;
-    symbols: Record<string, string>;
-    glossary: Record<string, Definition>;
-    theme: Theme | null;
-    base: string | null;
-    uids: string[];
-    chapteruids: string[];
-    active: Record<string, string>;
-};
-
-export default class Edition {
-    readonly bookRef: DocumentReference;
-    readonly editionRef: DocumentReference | undefined;
-    readonly uids: string[];
-    readonly title: string;
-    readonly authors: string[];
-    readonly number: number;
-    readonly summary: string;
-    readonly published: number | null;
-    readonly images: Record<string, string | null>;
-    readonly description: string;
-    readonly chapters: Chapter[];
-    readonly license: string;
-    readonly acknowledgements: string;
-    readonly tags: string[];
-    readonly sources: Record<string, string>;
-    readonly references: Record<string, Reference | FormatNode>;
-    readonly symbols: Record<string, string>;
-    readonly glossary: Record<string, Definition>;
-    readonly theme: Theme | null;
-    readonly base: string | null;
-    readonly active: Record<string, string>;
-
-    // Given an object with a valid specification and an object mapping chapter IDs to chapter text,
-    // construct an object representing a book.
-    constructor(
-        bookRef: DocumentReference,
-        editionRef: DocumentReference | undefined,
-        uids: string[],
-        title: string,
-        authors: string[],
-        number: number,
-        summary: string,
-        published: number | null,
-        images: Record<string, string | null>,
-        description: string,
-        chapters: Chapter[],
-        license: string,
-        acknowledgements: string,
-        tags: string[],
-        sources: Record<string, string>,
-        references:
-            | Record<string, string | string[]>
-            | Record<string, FormatNode | Reference>,
-        symbols: Record<string, string>,
-        glossary: Record<string, Definition>,
-        theme: Theme | null,
-        base: string | null,
-        active: Record<string, string>
-    ) {
-        this.bookRef = bookRef;
-        this.editionRef = editionRef;
-        this.uids = uids;
-        this.title = title;
-        this.authors = authors;
-        this.number = number;
-        this.summary = summary;
-        this.published = published;
-        this.images = images;
-        this.description = description;
-        this.chapters = chapters.slice();
-        this.license = license;
-        this.acknowledgements = acknowledgements;
-        this.tags = tags.slice();
-        this.sources = Object.assign({}, sources);
-        this.references = {};
-        for (const [citationID, ref] of Object.entries(references)) {
-            this.references[citationID] =
-                ref instanceof Reference
-                    ? ref
-                    : Edition.parseReference(citationID, ref, this);
-        }
-        this.symbols = Object.assign({}, symbols);
-        this.glossary = Object.assign({}, glossary);
-        this.theme = theme;
-        this.base = base;
-        this.active = active;
-    }
-
-    static fromJSON(
-        editionRef: DocumentReference | undefined,
-        spec: EditionSpecification
-    ) {
-        // Copy all of the specification metadata to fields.
-        // Choose suitable defaults if the spec is lacking a field.
-        return new Edition(
-            spec.bookRef,
-            editionRef,
-            spec.uids,
-            spec.title,
-            spec.authors,
-            spec.number,
-            spec.summary,
-            spec.published,
-            spec.images,
-            spec.description,
-            spec.chapters.map((chap) => Chapter.fromJSON(chap, '')),
-            spec.license,
-            spec.acknowledgements,
-            spec.tags ?? [],
-            spec.sources ?? {},
-            spec.references ?? {},
-            spec.symbols ?? {},
-            spec.glossary ?? {},
-            spec.theme,
-            spec.base ?? '',
-            spec.active
-        );
-    }
-
-    static parseReference(
-        citationID: string,
-        ref: string | string[],
-        edition: Edition,
-        short = false
-    ) {
-        if (typeof ref === 'string') return Parser.parseFormat(edition, ref);
-        else {
-            // APA Format. Could eventually support multiple formats.
-            let [authors, year, title, source, url, summary] = ref;
-
-            if (source.charAt(0) === '#') {
-                let src = edition.getSource(source);
-                if (src !== null) source = src;
-            }
-
-            return new Reference(
-                citationID,
-                authors ?? '',
-                year ?? '',
-                title ?? '',
-                source ?? '',
-                url ?? '',
-                summary ?? '',
-                short
-            );
-        }
-    }
-
-    // Convert the book to an object for storage.
-    toObject(): EditionSpecification {
-        const references: Record<string, string | string[]> = {};
-        for (const [citationID, ref] of Object.entries(this.references))
-            references[citationID] =
-                ref instanceof Reference ? ref.toList() : ref.toBookdown();
-
-        const editionJSON: EditionSpecification = {
-            bookRef: this.bookRef,
-            title: this.title,
-            authors: this.authors,
-            number: this.number,
-            summary: this.summary,
-            published: this.published,
-            images: Object.assign({}, this.images),
-            description: this.description,
-            chapters: this.chapters.map((chap) => chap.toJSON()),
-            license: this.license,
-            acknowledgements: this.acknowledgements,
-            tags: this.tags.slice(),
-            sources: Object.assign({}, this.sources),
-            references: references,
-            symbols: Object.assign({}, this.symbols),
-            glossary: Object.assign({}, this.glossary),
-            theme: this.theme,
-            base: this.base,
-            uids: this.uids.slice(),
-            chapteruids: this.getChapterUIDS(),
-            active: this.active,
-        };
-        return editionJSON;
-    }
-
-    getBookRef() {
-        return this.bookRef;
-    }
-
-    getEditionRef() {
-        return this.editionRef;
-    }
-
-    getChapterUIDS() {
-        return Array.from(
-            new Set(this.chapters.map((chapter) => chapter.uids).flat())
-        );
-    }
-
-    withRef(editionRef: DocumentReference | undefined) {
-        return new Edition(
-            this.bookRef,
-            editionRef,
-            this.uids,
-            this.title,
-            this.authors,
-            this.number,
-            this.summary,
-            this.published,
-            this.images,
-            this.description,
-            this.chapters,
-            this.license,
-            this.acknowledgements,
-            this.tags,
-            this.sources,
-            this.references,
-            this.symbols,
-            this.glossary,
-            this.theme,
-            this.base,
-            this.active
-        );
-    }
-
-    getTitle() {
-        return this.title;
-    }
-
-    withTitle(title: string): Edition {
-        return new Edition(
-            this.bookRef,
-            this.editionRef,
-            this.uids,
-            title,
-            this.authors,
-            this.number,
-            this.summary,
-            this.published,
-            this.images,
-            this.description,
-            this.chapters,
-            this.license,
-            this.acknowledgements,
-            this.tags,
-            this.sources,
-            this.references,
-            this.symbols,
-            this.glossary,
-            this.theme,
-            this.base,
-            this.active
-        );
-    }
-
-    getDescription() {
-        return this.description;
-    }
-    setDescription(description: string): Edition {
-        return new Edition(
-            this.bookRef,
-            this.editionRef,
-            this.uids,
-            this.title,
-            this.authors,
-            this.number,
-            this.summary,
-            this.published,
-            this.images,
-            description,
-            this.chapters,
-            this.license,
-            this.acknowledgements,
-            this.tags,
-            this.sources,
-            this.references,
-            this.symbols,
-            this.glossary,
-            this.theme,
-            this.base,
-            this.active
-        );
-    }
-
-    getAcknowledgements() {
-        return this.acknowledgements;
-    }
-
-    withAcknowledgements(acks: string) {
-        return new Edition(
-            this.bookRef,
-            this.editionRef,
-            this.uids,
-            this.title,
-            this.authors,
-            this.number,
-            this.summary,
-            this.published,
-            this.images,
-            this.description,
-            this.chapters,
-            this.license,
-            acks,
-            this.tags,
-            this.sources,
-            this.references,
-            this.symbols,
-            this.glossary,
-            this.theme,
-            this.base,
-            this.active
-        );
-    }
-
-    withSummary(summary: string) {
-        return new Edition(
-            this.bookRef,
-            this.editionRef,
-            this.uids,
-            this.title,
-            this.authors,
-            this.number,
-            summary,
-            this.published,
-            this.images,
-            this.description,
-            this.chapters,
-            this.license,
-            this.acknowledgements,
-            this.tags,
-            this.sources,
-            this.references,
-            this.symbols,
-            this.glossary,
-            this.theme,
-            this.base,
-            this.active
-        );
-    }
-
-    asPublished(published: boolean) {
-        return new Edition(
-            this.bookRef,
-            this.editionRef,
-            this.uids,
-            this.title,
-            this.authors,
-            this.number,
-            this.summary,
-            published ? Date.now() : null,
-            this.images,
-            this.description,
-            this.chapters,
-            this.license,
-            this.acknowledgements,
-            this.tags,
-            this.sources,
-            this.references,
-            this.symbols,
-            this.glossary,
-            this.theme,
-            this.base,
-            this.active
-        );
-    }
-
-    getLicense() {
-        return this.license;
-    }
-    setLicense(license: string) {
-        return new Edition(
-            this.bookRef,
-            this.editionRef,
-            this.uids,
-            this.title,
-            this.authors,
-            this.number,
-            this.summary,
-            this.published,
-            this.images,
-            this.description,
-            this.chapters,
-            license,
-            this.acknowledgements,
-            this.tags,
-            this.sources,
-            this.references,
-            this.symbols,
-            this.glossary,
-            this.theme,
-            this.base,
-            this.active
-        );
-    }
-
-    getChapters() {
-        return this.chapters.slice();
-    }
-
-    hasChapter(chapterID: string): boolean {
-        return (
-            this.getChapter(chapterID) !== undefined ||
-            ['references', 'glossary', 'index', 'search', 'media'].includes(
-                chapterID
-            )
-        );
-    }
-
-    getChapter(chapterID: string): Chapter | undefined {
-        return this.chapters.find((chapter) => chapter.getID() === chapterID);
-    }
-
-    getChapterByRef(ref: DocumentReference): Chapter | undefined {
-        return this.chapters.find(
-            (chap) => chap.ref !== undefined && chap.ref.id === ref.id
-        );
-    }
-
-    getChapterPosition(chapterID: string): number | undefined {
-        var position = 0;
-        for (; position < this.chapters.length; position++)
-            if (this.chapters[position].getID() === chapterID) return position;
-
-        return undefined;
-    }
-
-    getChapterCount() {
-        return this.chapters.length;
-    }
-
-    withChapters(chapters: Chapter[]) {
-        return new Edition(
-            this.bookRef,
-            this.editionRef,
-            this.uids,
-            this.title,
-            this.authors,
-            this.number,
-            this.summary,
-            this.published,
-            this.images,
-            this.description,
-            chapters,
-            this.license,
-            this.acknowledgements,
-            this.tags,
-            this.sources,
-            this.references,
-            this.symbols,
-            this.glossary,
-            this.theme,
-            this.base,
-            this.active
-        );
-    }
-
-    withChapterText(text: [DocumentReference, string][]) {
-        return this.withChapters(
-            this.chapters.map((chapter) => {
-                if (chapter.ref === undefined) return chapter;
-                const match = text.find(
-                    ([ref, text]) =>
-                        chapter.ref !== undefined &&
-                        chapter.ref.id === ref.id &&
-                        chapter.text !== text &&
-                        text !== undefined
-                );
-                return match ? chapter.withText(match[1]) : chapter;
-            })
-        );
-    }
-
-    withRevisedChapter(previous: Chapter, edited: Chapter) {
-        const index = this.chapters.indexOf(previous);
-        if (index < 0) return this;
-        return this.withChapters([
-            ...this.chapters.slice(0, index),
-            edited,
-            ...this.chapters.slice(index + 1),
-        ]);
-    }
-
-    withoutRefs() {
-        return this.withRef(undefined).withChapters(
-            this.chapters.map((chap) => chap.withoutRef())
-        );
-    }
-
-    withIncrementedEditionNumber() {
-        return new Edition(
-            this.bookRef,
-            this.editionRef,
-            this.uids,
-            this.title,
-            this.authors,
-            this.number + 1,
-            this.summary,
-            this.published,
-            this.images,
-            this.description,
-            this.chapters,
-            this.license,
-            this.acknowledgements,
-            this.tags,
-            this.sources,
-            this.references,
-            this.symbols,
-            this.glossary,
-            this.theme,
-            this.base,
-            this.active
-        );
-    }
-
-    withNewChapter() {
-        // Synthesize a chapter ID placeholder that doesn't overlap with existing chapter names
-        let number = 1;
-        while (this.hasChapter('chapter' + number)) number++;
-
-        // Create a default chapter on this model. Remember the document reference so we can modify it later.
-        const newChapter = new Chapter(
-            undefined,
-            `chapter${number}`,
-            'Untitled Chapter',
-            [],
-            null,
-            true,
-            false,
-            undefined,
-            '',
-            []
-        );
-        return this.withChapters([...this.chapters, newChapter]);
-    }
-
-    withoutChapter(chapterID: string): Edition {
-        let index = this.chapters.findIndex(
-            (chapter) => chapter.getID() === chapterID
-        );
-        if (index < 0) return this;
-
-        return this.withChapters([
-            ...this.chapters.slice(0, index),
-            ...this.chapters.slice(index + 1),
-        ]);
-    }
-
-    withMovedChapter(chapterID: string, increment: number): Edition {
-        // Get the index of the chapter.
-        let index = this.chapters.findIndex(
-            (chapter) => chapter.getID() === chapterID
-        );
-        if (index + increment < 0 || index + increment >= this.chapters.length)
-            return this;
-
-        const newChapters = this.chapters.slice();
-        const temp = newChapters[index + increment];
-        newChapters[index + increment] = newChapters[index];
-        newChapters[index] = temp;
-
-        return new Edition(
-            this.bookRef,
-            this.editionRef,
-            this.uids,
-            this.title,
-            this.authors,
-            this.number,
-            this.summary,
-            this.published,
-            this.images,
-            this.description,
-            newChapters,
-            this.license,
-            this.acknowledgements,
-            this.tags,
-            this.sources,
-            this.references,
-            this.symbols,
-            this.glossary,
-            this.theme,
-            this.base,
-            this.active
-        );
-    }
-
-    getSymbols() {
-        return this.symbols;
-    }
-
-    hasReferences() {
-        return Object.keys(this.references).length > 0;
-    }
-
-    getReferences() {
-        return Object.assign({}, this.references);
-    }
-
-    getReference(citationID: string) {
-        return citationID in this.references
-            ? this.references[citationID]
-            : undefined;
-    }
-
-    withReferences(newReferences: Record<string, FormatNode | Reference>) {
-        return new Edition(
-            this.bookRef,
-            this.editionRef,
-            this.uids,
-            this.title,
-            this.authors,
-            this.number,
-            this.summary,
-            this.published,
-            this.images,
-            this.description,
-            this.chapters,
-            this.license,
-            this.acknowledgements,
-            this.tags,
-            this.sources,
-            newReferences,
-            this.symbols,
-            this.glossary,
-            this.theme,
-            this.base,
-            this.active
-        );
-    }
-
-    withNewReferences(references: Reference[]): Edition {
-        const newReferences = Object.assign({}, this.references);
-        // Generate a unique ID for the reference.
-        for (const newRef of references)
-            newReferences[newRef.citationID] = newRef;
-        return this.withReferences(newReferences);
-    }
-
-    withEditedReference(ref: Reference) {
-        if (!(ref.citationID in this.references)) return this;
-        const newReferences = Object.assign({}, this.references);
-        newReferences[ref.citationID] = ref;
-        return this.withReferences(newReferences);
-    }
-
-    withEditedReferenceID(newCitationID: string, ref: Reference) {
-        if (!(ref.citationID in this.references)) return;
-        const newReferences = Object.assign({}, this.references);
-        delete newReferences[ref.citationID];
-        newReferences[newCitationID] = ref.withCitationID(newCitationID);
-        return this.withReferences(newReferences);
-    }
-
-    withoutReference(citationID: string) {
-        if (!(citationID in this.references)) return this;
-        const newReferences = Object.assign({}, this.references);
-        delete newReferences[citationID];
-        return this.withReferences(newReferences);
-    }
-
-    hasGlossary() {
-        return Object.keys(this.glossary).length > 0;
-    }
-
-    getGlossary() {
-        return Object.assign({}, this.glossary);
-    }
-
-    hasDefinition(id: string) {
-        return id in this.glossary;
-    }
-
-    withGlossary(glossary: Record<string, Definition>) {
-        return new Edition(
-            this.bookRef,
-            this.editionRef,
-            this.uids,
-            this.title,
-            this.authors,
-            this.number,
-            this.summary,
-            this.published,
-            this.images,
-            this.description,
-            this.chapters,
-            this.license,
-            this.acknowledgements,
-            this.tags,
-            this.sources,
-            this.references,
-            this.symbols,
-            glossary,
-            this.theme,
-            this.base,
-            this.active
-        );
-    }
-
-    withDefinition(
-        id: string,
-        phrase: string,
-        definition: string,
-        synonyms: string[]
-    ): Edition {
-        const newGlossary = Object.assign({}, this.glossary);
-        newGlossary[id] = {
-            phrase: phrase,
-            definition: definition,
-            synonyms: synonyms,
-        };
-        return this.withGlossary(newGlossary);
-    }
-
-    withoutDefinition(id: string): Edition {
-        const newGlossary = Object.assign({}, this.glossary);
-        delete newGlossary[id];
-        return this.withGlossary(newGlossary);
-    }
-
-    withEditedDefinition(id: string, definition: Definition): Edition {
-        const newGlossary = Object.assign({}, this.glossary);
-        newGlossary[id] = definition;
-        return this.withGlossary(newGlossary);
-    }
-
-    withEditedDefinitionID(id: string, newID: string) {
-        if (!(id in this.glossary)) return;
-        const newGlossary = Object.assign({}, this.glossary);
-        const definition = newGlossary[id];
-        delete newGlossary[id];
-        newGlossary[newID] = definition;
-        return this.withGlossary(newGlossary);
-    }
-
-    getTags() {
-        return this.tags;
-    }
-
-    getTheme() {
-        return this.theme;
-    }
-
-    withTheme(theme: Theme | null) {
-        return new Edition(
-            this.bookRef,
-            this.editionRef,
-            this.uids,
-            this.title,
-            this.authors,
-            this.number,
-            this.summary,
-            this.published,
-            this.images,
-            this.description,
-            this.chapters,
-            this.license,
-            this.acknowledgements,
-            this.tags,
-            this.sources,
-            this.references,
-            this.symbols,
-            this.glossary,
-            theme,
-            this.base,
-            this.active
-        );
-    }
-
-    withThemeValue(group: string, name: string, value: string) {
-        if (this.theme === null) return this;
-        if (group === 'imports') return this;
-        const newTheme: Record<string, Record<string, string>> = Object.assign(
-            {},
-            this.theme as Record<string, Record<string, string>>
-        );
-        const newGroup: Record<string, string> = Object.assign(
-            {},
-            (this.theme as Record<string, Record<string, string>>)[group]
-        );
-        newGroup[name] = value;
-        newTheme[group] = newGroup;
-        return this.withTheme(newTheme);
-    }
-
-    // Don't let callers get their sneaky hands on this mutable array...
-    getAuthors() {
-        return [...this.authors];
-    }
-
-    withAuthors(authors: string[]) {
-        return new Edition(
-            this.bookRef,
-            this.editionRef,
-            this.uids,
-            this.title,
-            authors,
-            this.number,
-            this.summary,
-            this.published,
-            this.images,
-            this.description,
-            this.chapters,
-            this.license,
-            this.acknowledgements,
-            this.tags,
-            this.sources,
-            this.references,
-            this.symbols,
-            this.glossary,
-            this.theme,
-            this.base,
-            this.active
-        );
-    }
-
-    withAuthor(name: string) {
-        return this.withAuthors([...this.authors, name]);
-    }
-
-    withAuthorName(index: number, name: string) {
-        if (index < 0 || index >= this.authors.length) return this;
-        return this.withAuthors([
-            ...this.authors.slice(0, index),
-            name,
-            ...this.authors.slice(index + 1),
-        ]);
-    }
-
-    withoutAuthor(index: number) {
-        if (index < 0 || index >= this.authors.length) return this;
-        return this.withAuthors([
-            ...this.authors.slice(0, index),
-            ...this.authors.slice(index + 1),
-        ]);
-    }
-
-    withEditors(uids: string[]) {
-        return new Edition(
-            this.bookRef,
-            this.editionRef,
-            uids,
-            this.title,
-            this.authors,
-            this.number,
-            this.summary,
-            this.published,
-            this.images,
-            this.description,
-            this.chapters,
-            this.license,
-            this.acknowledgements,
-            this.tags,
-            this.sources,
-            this.references,
-            this.symbols,
-            this.glossary,
-            this.theme,
-            this.base,
-            this.active
-        );
-    }
-
-    hasImage(id: string) {
-        return this.images[id] !== null;
-    }
-
-    getImage(id: string) {
-        return this.images[id] ?? null;
-    }
-
-    withImage(id: string, embed: string | null) {
-        const newImages = Object.assign({}, this.images);
-        newImages[id] = embed;
-        return new Edition(
-            this.bookRef,
-            this.editionRef,
-            this.uids,
-            this.title,
-            this.authors,
-            this.number,
-            this.summary,
-            this.published,
-            newImages,
-            this.description,
-            this.chapters,
-            this.license,
-            this.acknowledgements,
-            this.tags,
-            this.sources,
-            this.references,
-            this.symbols,
-            this.glossary,
-            this.theme,
-            this.base,
-            this.active
-        );
-    }
-
-    isEditor(uid: string) {
-        return this.uids.includes(uid);
-    }
-
-    isChapterEditor(uid: string) {
-        return this.getChapterUIDS().includes(uid);
-    }
-
-    getLeasee(content: string): string | undefined {
-        return this.active[content];
-    }
-
-    hasLease(uid: string, content: string) {
-        return this.active[content] === uid;
-    }
-
-    isLeased(contentID: string) {
-        return contentID in this.active;
-    }
-
-    withLock(uid: string, content: string, lock: boolean) {
-        const newActive = Object.assign({}, this.active);
-        if (lock) newActive[content] = uid;
-        else delete newActive[content];
-
-        return new Edition(
-            this.bookRef,
-            this.editionRef,
-            this.uids,
-            this.title,
-            this.authors,
-            this.number,
-            this.summary,
-            this.published,
-            this.images,
-            this.description,
-            this.chapters,
-            this.license,
-            this.acknowledgements,
-            this.tags,
-            this.sources,
-            this.references,
-            this.symbols,
-            this.glossary,
-            this.theme,
-            this.base,
-            newActive
-        );
-    }
-
-    getBookReadingTime() {
-        return this.chapters
-            .map((chapter) => chapter.getReadingTime(this))
-            .reduce(
-                (total, time) =>
-                    total === undefined
-                        ? 0
-                        : time === undefined
-                        ? total
-                        : total + time,
-                0
-            );
-    }
-
-    getChapterNumber(chapterID: string) {
-        let chapterNumber = 1;
-        let match = null;
-        this.chapters.forEach((chapter) => {
-            // If we found a match...
-            if (chapter.getID() === chapterID) {
-                match = chapterNumber;
-                // And it's an unnumbered chapter, set to null.
-                if (!chapter.isNumbered()) match = null;
-            }
-            // Otherwise, increment if it's numbered.
-            else if (chapter.isNumbered()) chapterNumber++;
-        });
-        // Remember the number if we found it.
-        if (match !== null) return match;
-        else return undefined;
-    }
-
-    getSource(sourceID: string) {
-        return sourceID.charAt(0) === '#' &&
-            sourceID.substring(1) in this.sources
-            ? this.sources[sourceID.substring(1)]
-            : null;
-    }
-
-    getChapterName(chapterID: string): string | undefined {
-        const chapter = this.getChapter(chapterID);
-        return chapter?.getTitle();
-    }
-
-    getChapterSection(chapterID: string): string | undefined {
-        const chapter = this.getChapter(chapterID);
-        return chapter?.getSection();
-    }
-
-    getFootnoteSymbol(number: number) {
-        let symbols = 'abcdefghijklmnopqrstuvwxyz';
-        // Let's hope there are never more than 26^2 footnotes in a single chapter...
-        return number < symbols.length
-            ? symbols.charAt(number)
-            : symbols.charAt(Math.floor(number / symbols.length) - 1) +
-                  symbols.charAt(number % symbols.length);
-    }
-
-    getBookIndex(): Record<string, Set<string>> {
-        // A map from word to a map of chapters containing the word
-        const bookIndex: Record<string, Set<string>> = {};
-
-        // Construct the index by building a dictionary of chapters in which each word appears.
-        this.chapters.forEach((chapter) => {
-            let index = chapter.getIndex(this);
-            if (index)
-                Object.keys(index).forEach((word) => {
-                    if (word !== '' && word.length > 2) {
-                        if (!(word in bookIndex)) bookIndex[word] = new Set();
-                        bookIndex[word].add(chapter.getID());
-                    }
-                });
-        });
-
-        return bookIndex;
-    }
-
-    // Given the current chapter, find the available chapter after it.
-    getNextChapterID(chapterID: string) {
-        // Handle back matter chapters.
-        switch (chapterID) {
-            case ChapterIDs.ReferencesID:
-                return this.hasGlossary()
-                    ? ChapterIDs.GlossaryID
-                    : ChapterIDs.IndexID;
-            case ChapterIDs.GlossaryID:
-                return ChapterIDs.IndexID;
-            case ChapterIDs.IndexID:
-                return ChapterIDs.SearchID;
-            case ChapterIDs.SearchID:
-                return ChapterIDs.MediaID;
-            case ChapterIDs.MediaID:
-                return ChapterIDs.TableOfContentsID;
-            case ChapterIDs.TableOfContentsID:
-                return this.chapters.length > 0
-                    ? this.chapters[0].getID()
-                    : null;
-            default:
-                let after = false;
-                for (let i = 0; i < this.chapters.length; i++) {
-                    let chapter = this.chapters[i];
-                    if (chapter.getID() === chapterID) after = true;
-                    // If we're after the given chapter and it's not forthcoming.
-                    else if (after && !chapter.isForthcoming())
-                        return chapter.getID();
-                }
-                // If the given ID was the last chapter, go to the next back matter chapter.
-                if (after)
-                    return this.hasReferences()
-                        ? ChapterIDs.ReferencesID
-                        : this.hasGlossary()
-                        ? ChapterIDs.GlossaryID
-                        : ChapterIDs.IndexID;
-                // Otherwise, it wasn't a valid ID
-                else return null;
-        }
-    }
-
-    // Given a chapter id, find the available chapter before it.
-    getPreviousChapterID(chapterID: string) {
-        switch (chapterID) {
-            // Handle back matter chapters.
-            case ChapterIDs.ReferencesID:
-                return this.chapters.length > 0
-                    ? this.chapters[this.chapters.length - 1].getID()
-                    : null; // Last chapter of the book
-            case ChapterIDs.GlossaryID:
-                return this.hasReferences()
-                    ? ChapterIDs.ReferencesID
-                    : this.chapters.length > 0
-                    ? this.chapters[this.chapters.length - 1].getID()
-                    : ChapterIDs.TableOfContentsID;
-            case ChapterIDs.IndexID:
-                return this.hasGlossary()
-                    ? ChapterIDs.GlossaryID
-                    : this.hasReferences()
-                    ? ChapterIDs.ReferencesID
-                    : this.chapters.length > 0
-                    ? this.chapters[this.chapters.length - 1].getID()
-                    : ChapterIDs.TableOfContentsID;
-            case ChapterIDs.SearchID:
-                return ChapterIDs.IndexID;
-            case ChapterIDs.MediaID:
-                return ChapterIDs.SearchID;
-            default:
-                let before = false;
-                for (let i = this.chapters.length - 1; i >= 0; i--) {
-                    let chapter = this.chapters[i];
-                    if (chapter.getID() === chapterID) before = true;
-                    // If we're before the given chapter and it's not forthcoming.
-                    else if (before && !chapter.isForthcoming())
-                        return chapter.getID();
-                }
-                // If the given ID was the last chapter, go to the next back matter chapter.
-                if (before) return ChapterIDs.TableOfContentsID;
-                // Otherwise, it wasn't a valid ID
-                else return null;
-        }
-    }
-
-    // Get all of the embeds in the book
-    getEmbeds(): EmbedNode[] {
-        let embeds: EmbedNode[] = [];
-
-        // Add the book cover
-        const cover = this.getImage('cover');
-        if (cover) {
-            let coverNode = Parser.parseEmbed(this, cover);
-            if (coverNode instanceof EmbedNode) embeds.push(coverNode);
-        }
-
-        // Add the cover and images from each chapter.
-        this.getChapters().forEach((c) => {
-            const image = c.getImage();
-            let cover =
-                image === null ? undefined : Parser.parseEmbed(this, image);
-            if (cover && cover instanceof EmbedNode) embeds.push(cover);
-
-            // Get the chapter body's embeds
-            let bodyEmbeds = c?.getAST(this)?.getEmbeds();
-            if (bodyEmbeds)
-                bodyEmbeds.forEach((embed: EmbedNode) => embeds.push(embed));
-        });
-
-        // Add the back matter covers
-        let backmatter = ['references', 'glossary', 'index', 'search', 'media'];
-        backmatter.forEach((id) => {
-            const img = this.getImage(id);
-            if (img) {
-                let image = Parser.parseEmbed(this, img);
-                if (image instanceof EmbedNode) embeds.push(image);
-            }
-        });
-
-        return embeds;
-    }
-
-    isLatestEdition(book: Book): boolean {
-        const latestEditionID = book.getLatestEditionID();
-        return (
-            latestEditionID !== undefined &&
-            latestEditionID === this.editionRef?.id
-        );
-    }
-
-    isLatestPublishedEdition(book: Book): boolean {
-        const latestEditionID = book.getLatestPublishedEditionID();
-        return (
-            latestEditionID !== undefined &&
-            latestEditionID === this.editionRef?.id
-        );
-    }
-
-    getEditionNumber() {
-        return this.number;
-    }
-
-    getEditionLabel() {
-        const num = this.number;
-        return `${num}${
-            num === 1 ? 'st' : num === 2 ? 'nd' : num === 3 ? 'rd' : ''
-        }`;
-    }
-
-    getInfo(): EditionInfo | undefined {
-        return this.editionRef === undefined
-            ? undefined
-            : {
-                  ref: this.editionRef,
-                  summary: this.summary,
-                  number: this.number,
-                  published: this.published,
-                  editionuids: this.uids,
-                  chapteruids: Array.from(
-                      new Set(
-                          this.chapters.map((chapter) => chapter.uids).flat()
-                      )
-                  ),
-              };
-    }
-}