@fiduswriter/document 0.1.0-alpha.3 → 0.1.0-alpha.4

package/dist/exporter/latex/convert.js

@@ -0,0 +1,865 @@
+import { BIBLIOGRAPHY_HEADERS, CATS } from "../../schema/i18n.js";
+import { escapeLatexText } from "./escape_latex.js";
+export class LatexExporterConvert {
+    constructor(exporter, imageDB, bibDB, settings) {
+        this.exporter = exporter;
+        this.settings = settings;
+        this.imageDB = imageDB;
+        this.bibDB = bibDB;
+        this.imageIds = [];
+        this.usedBibDB = {};
+        // While walking the tree, we take note of the kinds of features That
+        // are present in the file, so that we can assemble an preamble and
+        // epilogue based on our findings.
+        this.features = {};
+        this.internalLinks = [];
+        this.categoryCounter = {}; // counters for each type of figure (figure/table/photo)
+        this.authorsTex = "";
+    }
+    init(docContent) {
+        this.preWalkJson(docContent);
+        const rawTransformation = this.walkJson(docContent);
+        const body = this.postProcess(rawTransformation);
+        const copyright = this.assembleCopyright();
+        const preamble = this.assemblePreamble();
+        const epilogue = this.assembleEpilogue();
+        const latex = copyright +
+            this.docDeclaration +
+            preamble +
+            this.authorsTex +
+            "\n\\begin{document}\n" +
+            body +
+            epilogue +
+            "\n\\end{document}\n";
+        const returnObject = {
+            latex,
+            imageIds: this.imageIds,
+            usedBibDB: this.usedBibDB
+        };
+        return returnObject;
+    }
+    get docDeclaration() {
+        return "\\documentclass{article}\n";
+    }
+    // Check for things needed before creating raw transform
+    preWalkJson(node) {
+        switch (node.type) {
+            // Collect all internal links so that we only set the anchors for those
+            // that are being linked to.
+            case "text":
+                if (node.marks) {
+                    const hyperlink = node.marks.find(mark => mark.type === "link");
+                    if (hyperlink) {
+                        const href = hyperlink.attrs.href;
+                        if (href[0] === "#" &&
+                            !this.internalLinks.includes(href)) {
+                            this.internalLinks.push(href.slice(1));
+                        }
+                    }
+                }
+                break;
+        }
+        if (node.content) {
+            node.content.forEach(child => this.preWalkJson(child));
+        }
+    }
+    walkJson(node, options = {}) {
+        let start = "", content = "", end = "", placeFootnotesAfterBlock = false;
+        switch (node.type) {
+            case "doc":
+                break;
+            case "title":
+                start += "\n\\title{";
+                end = "}" + end;
+                break;
+            case "heading_part":
+                if (node.attrs.metadata === "subtitle" && node.content) {
+                    start += "\n\\subtitle{";
+                    end = "}" + end;
+                    this.features.subtitle = true;
+                    options = Object.assign({}, options);
+                    options.ignoreHeading = true;
+                }
+                else if (!options.madeTitle) {
+                    start += "\n\n\\maketitle\n";
+                    options.madeTitle = true;
+                }
+                break;
+            case "contributor":
+                // Ignore - we deal with contributors_part instead.
+                break;
+            case "contributors_part":
+                if (node.content) {
+                    const contributorLabels = {
+                        authors: gettext("Authors"),
+                        editors: gettext("Editors"),
+                        translators: gettext("Translators"),
+                        reviewers: gettext("Reviewers"),
+                        contributors: gettext("Contributors")
+                    };
+                    const roleLabel = contributorLabels[node.attrs.metadata];
+                    if (node.attrs.metadata === "authors") {
+                        const authorsPerAffil = node.content
+                            .map(node => {
+                            const author = node.attrs, nameParts = [];
+                            let affiliation = false;
+                            if (author.firstname) {
+                                nameParts.push(author.firstname);
+                            }
+                            if (author.lastname) {
+                                nameParts.push(author.lastname);
+                            }
+                            if (nameParts.length && author.institution) {
+                                affiliation = author.institution;
+                            }
+                            else if (author.institution) {
+                                // We have an institution but no names. Use institution as name.
+                                nameParts.push(author.institution);
+                            }
+                            return {
+                                name: nameParts.join(" "),
+                                affiliation,
+                                email: author.email,
+                                id_type: author.id_type,
+                                id_value: author.id_value
+                            };
+                        })
+                            .reduce((affils, author) => {
+                            const affil = author.affiliation;
+                            affils[affil] = affils[affil] || [];
+                            affils[affil].push(author);
+                            return affils;
+                        }, {});
+                        Object.values(authorsPerAffil).forEach(affil => {
+                            affil.forEach(author => {
+                                let thanks = "";
+                                if (author.email) {
+                                    thanks += `\\thanks{${escapeLatexText(author.email)}}`;
+                                }
+                                if (author.id_type && author.id_value) {
+                                    thanks += `\\thanks{${escapeLatexText(author.id_type)}: ${escapeLatexText(author.id_value)}}`;
+                                }
+                                this.authorsTex += `\n\\author{${escapeLatexText(author.name)}${thanks}}`;
+                            });
+                            this.authorsTex += `\n\\affil{${affil[0].affiliation
+                                ? escapeLatexText(affil[0].affiliation)
+                                : ""}}`;
+                        });
+                        this.authorsTex += "\n\n";
+                        this.features.authors = true;
+                    }
+                    else {
+                        if (!options.madeTitle) {
+                            start += "\n\n\\maketitle\n";
+                            options.madeTitle = true;
+                        }
+                        const contributorNames = node.content
+                            .map(contributorNode => {
+                            const attrs = contributorNode.attrs;
+                            const nameParts = [];
+                            if (attrs.firstname) {
+                                nameParts.push(attrs.firstname);
+                            }
+                            if (attrs.lastname) {
+                                nameParts.push(attrs.lastname);
+                            }
+                            if (!nameParts.length && attrs.institution) {
+                                // We have an institution but no names. Use institution as name.
+                                nameParts.push(attrs.institution);
+                            }
+                            let name = nameParts.join(" ");
+                            if (attrs.id_type && attrs.id_value) {
+                                name += ` (${escapeLatexText(attrs.id_type)}: ${escapeLatexText(attrs.id_value)})`;
+                            }
+                            return name;
+                        })
+                            .filter(name => name.length)
+                            .join(", ");
+                        if (contributorNames.length) {
+                            content += `\n\\noindent\\textbf{${roleLabel}:} ${contributorNames}\n\n`;
+                        }
+                    }
+                }
+                break;
+            case "tags_part":
+                if (node.content) {
+                    if (node.attrs.metadata === "keywords") {
+                        start += "\n\\keywords{";
+                        end = "}" + end;
+                        this.features.keywords = true;
+                    }
+                    else if (!options.madeTitle) {
+                        start += "\n\n\\maketitle\n";
+                        options.madeTitle = true;
+                    }
+                    content += node.content
+                        .map(keyword => escapeLatexText(keyword.attrs.tag))
+                        .join("\\sep ");
+                }
+                break;
+            case "tag":
+                // Ignore - we already took all the tags_part from the keywords node.
+                break;
+            case "richtext_part":
+                if (!options.madeTitle) {
+                    start += "\n\n\\maketitle\n";
+                    options.madeTitle = true;
+                }
+                if (node.content && node.attrs.metadata === "abstract") {
+                    start += "\n\\begin{abstract}\n";
+                    end = "\n\\end{abstract}\n" + end;
+                }
+                break;
+            case "table_of_contents":
+                start += "\n\n\\tableofcontents\n";
+                break;
+            case "separator_part":
+            case "table_part":
+                // part separators as in page breaks should usually already be handled
+                // by LaTeX and table parts will simply show the table inside of them.
+                break;
+            case "paragraph":
+                start += "\n\n";
+                end = "\n" + end;
+                break;
+            case "heading1":
+            case "heading2":
+            case "heading3":
+            case "heading4":
+            case "heading5":
+            case "heading6": {
+                if (options.ignoreHeading) {
+                    break;
+                }
+                const level = Number.parseInt(node.type.slice(-1));
+                switch (level) {
+                    case 1:
+                        start += "\n\n\\section{";
+                        break;
+                    case 2:
+                        start += "\n\n\\subsection{";
+                        break;
+                    case 3:
+                    case 4:
+                    case 5:
+                    case 6:
+                        // TODO: Add support for levels 4/5/6
+                        start += "\n\n\\subsubsection{";
+                        break;
+                }
+                end = `}\\label{${node.attrs.id}}\n\n` + end;
+                // Check if this heading is being linked to. If this is the case,
+                // place a protected hypertarget here that does not add an extra
+                // entry into the PDF TOC.
+                if (this.internalLinks.includes(node.attrs.id)) {
+                    // Add a link target
+                    end =
+                        end +
+                            `\\texorpdfstring{\\protect\\hypertarget{${node.attrs.id}}{}}{}`;
+                }
+                options = Object.assign({}, options);
+                options.noLineBreak = true;
+                if (!options.onlyFootnoteMarkers) {
+                    placeFootnotesAfterBlock = true;
+                    options.onlyFootnoteMarkers = true;
+                    options.unplacedFootnotes = [];
+                }
+                break;
+            }
+            case "code_block": {
+                // Support language and category attributes
+                if (node.attrs.category && node.attrs.id) {
+                    const language = this.doc.attrs.language || "en-US";
+                    const { CATS } = require("../../schema/i18n");
+                    const categoryLabel = CATS[node.attrs.category]?.[language] ||
+                        node.attrs.category;
+                    // Count code blocks to get the number
+                    const categories = {};
+                    this.doc.descendants(n => {
+                        if (n.type === "code_block" &&
+                            n.attrs.category &&
+                            n.attrs.id) {
+                            if (!categories[n.attrs.category]) {
+                                categories[n.attrs.category] = 0;
+                            }
+                            categories[n.attrs.category]++;
+                            if (n.attrs.id === node.attrs.id) {
+                                return false;
+                            }
+                        }
+                    });
+                    const number = categories[node.attrs.category] || 1;
+                    const caption = node.attrs.title
+                        ? `${categoryLabel} ${number}: ${this.convertText(node.attrs.title)}`
+                        : `${categoryLabel} ${number}`;
+                    start += `\n\\begin{listing}\n\\caption{${caption}}\\label{${node.attrs.id}}\n\\begin{code}\n\n`;
+                    end = `\n\n\\end{code}\n\\end{listing}\n` + end;
+                    this.features.listing = true;
+                }
+                else if (node.attrs.language) {
+                    start += `\n\\begin{code}[${this.convertText(node.attrs.language)}]\n\n`;
+                    end = `\n\n\\end{code}\n` + end;
+                }
+                else {
+                    start += "\n\\begin{code}\n\n";
+                    end = "\n\n\\end{code}\n" + end;
+                }
+                this.features.code = true;
+                break;
+            }
+            case "blockquote":
+                start += "\n\\begin{quote}\n\n";
+                end = "\n\n\\end{quote}\n" + end;
+                break;
+            case "ordered_list":
+                if (node.attrs.order !== 1) {
+                    start += `\n\\begin{enumerate}[start=${node.attrs.order}]`;
+                    this.features.orderedListStart = true;
+                }
+                else {
+                    start += "\n\\begin{enumerate}";
+                }
+                end = "\n\\end{enumerate}" + end;
+                if (!options.onlyFootnoteMarkers) {
+                    placeFootnotesAfterBlock = true;
+                    options = Object.assign({}, options);
+                    options.onlyFootnoteMarkers = true;
+                    options.unplacedFootnotes = [];
+                }
+                break;
+            case "bullet_list":
+                start += "\n\\begin{itemize}";
+                end = "\n\\end{itemize}" + end;
+                if (!options.onlyFootnoteMarkers) {
+                    placeFootnotesAfterBlock = true;
+                    options = Object.assign({}, options);
+                    options.onlyFootnoteMarkers = true;
+                    options.unplacedFootnotes = [];
+                }
+                break;
+            case "list_item":
+                start += "\n\\item ";
+                end = "\n" + end;
+                break;
+            case "footnote":
+                if (options.onlyFootnoteMarkers) {
+                    // We are inside a headline or a list and can only place a
+                    // footnote marker here. The footnote will have to be put
+                    // beyond the block node instead.
+                    start += "\\protect\\footnotemark{}";
+                    options.unplacedFootnotes.push(node.attrs.footnote);
+                }
+                else {
+                    if (!node.attrs.footnote.find(par => par.type === "figure")) {
+                        // LaTeX doesn't allow figures in footnotes, so well move
+                        // this footnote into the regular text.
+                        start += "\\footnote{";
+                        end = "}" + end;
+                    }
+                    let fnContent = "";
+                    node.attrs.footnote.forEach(footPar => {
+                        fnContent += this.walkJson(footPar, options);
+                    });
+                    content += fnContent.replace(/^\s+|\s+$/g, "");
+                }
+                break;
+            case "text": {
+                let strong, em, underline, hyperlink, anchor, sup, sub, code;
+                // Check for hyperlink, bold/strong, italic/em and underline
+                if (node.marks) {
+                    strong = node.marks.find(mark => mark.type === "strong");
+                    em = node.marks.find(mark => mark.type === "em");
+                    underline = node.marks.find(mark => mark.type === "underline");
+                    hyperlink = node.marks.find(mark => mark.type === "link");
+                    anchor = node.marks.find(mark => mark.type === "anchor");
+                    sup = node.marks.find(mark => mark.type === "sup");
+                    sub = node.marks.find(mark => mark.type === "sub");
+                    code = node.marks.find(mark => mark.type === "code");
+                }
+                if (em) {
+                    start += "\\emph{";
+                    end = "}" + end;
+                }
+                if (strong) {
+                    start += "\\textbf{";
+                    end = "}" + end;
+                }
+                if (underline) {
+                    start += "\\underline{";
+                    end = "}" + end;
+                }
+                if (sup) {
+                    start += "\\textsuperscript{";
+                    end = "}" + end;
+                }
+                if (sub) {
+                    start += "\\textsubscript{";
+                    end = "}" + end;
+                }
+                if (code) {
+                    start += "\\texttt{";
+                    end = "}" + end;
+                }
+                if (hyperlink) {
+                    const href = hyperlink.attrs.href;
+                    if (href[0] === "#") {
+                        // Internal link
+                        start += `\\hyperlink{${href.slice(1)}}{`;
+                    }
+                    else {
+                        // External link
+                        start += `\\href{${href}}{`;
+                    }
+                    end = "}" + end;
+                    this.features.hyperlinks = true;
+                }
+                if (anchor && this.internalLinks.includes(anchor.attrs.id)) {
+                    // Add a link target
+                    start += `\\hypertarget{${anchor.attrs.id}}{`;
+                    end = "}" + end;
+                }
+                content += escapeLatexText(node.text);
+                break;
+            }
+            case "cross_reference": {
+                content += `\\hyperref[${node.attrs.id}]{${node.attrs.title || "MISSING TARGET"}}`;
+                this.features.hyperlinks = true;
+                break;
+            }
+            case "citation": {
+                const references = node.attrs.references;
+                const format = node.attrs.format;
+                let citationCommand = "\\" + format;
+                if (references.length > 1 &&
+                    references.every(ref => !ref.locator && !ref.prefix)) {
+                    // multi source citation without page numbers or text before.
+                    const citationEntryKeys = [];
+                    const allCitationItemsPresent = references
+                        .map(ref => ref.id)
+                        .every(citationEntry => {
+                        const bibDBEntry = this.bibDB.db[citationEntry];
+                        if (bibDBEntry) {
+                            if (!bibDBEntry) {
+                                // Not present in bibliography database, skip it.
+                                // TODO: Throw an error?
+                                return false;
+                            }
+                            if (!this.usedBibDB[citationEntry]) {
+                                const citationKey = this.createUniqueCitationKey(bibDBEntry.entry_key);
+                                this.usedBibDB[citationEntry] =
+                                    Object.assign({}, bibDBEntry);
+                                this.usedBibDB[citationEntry].entry_key =
+                                    citationKey;
+                            }
+                            citationEntryKeys.push(this.usedBibDB[citationEntry].entry_key);
+                        }
+                        return true;
+                    });
+                    if (allCitationItemsPresent) {
+                        citationCommand += `{${citationEntryKeys.join(",")}}`;
+                    }
+                    else {
+                        citationCommand = false;
+                    }
+                }
+                else {
+                    if (references.length > 1) {
+                        citationCommand += "s"; // Switching from \autocite to \autocites
+                    }
+                    const allCitationItemsPresent = references.every(ref => {
+                        const bibDBEntry = this.bibDB.db[ref.id];
+                        if (!bibDBEntry) {
+                            // Not present in bibliography database, skip it.
+                            // TODO: Throw an error?
+                            return false;
+                        }
+                        if (ref.prefix) {
+                            citationCommand += `[${ref.prefix}]`;
+                            if (!ref.locator) {
+                                citationCommand += "[]";
+                            }
+                        }
+                        if (ref.locator) {
+                            citationCommand += `[${ref.locator}]`;
+                        }
+                        citationCommand += "{";
+                        if (!this.usedBibDB[ref.id]) {
+                            const citationKey = this.createUniqueCitationKey(bibDBEntry.entry_key);
+                            this.usedBibDB[ref.id] = Object.assign({}, bibDBEntry);
+                            this.usedBibDB[ref.id].entry_key = citationKey;
+                        }
+                        citationCommand += this.usedBibDB[ref.id].entry_key;
+                        citationCommand += "}";
+                        return true;
+                    });
+                    if (!allCitationItemsPresent) {
+                        citationCommand = false;
+                    }
+                }
+                if (citationCommand) {
+                    content += citationCommand;
+                    this.features.citations = true;
+                }
+                break;
+            }
+            case "figure": {
+                const category = node.attrs.category;
+                const captionContent = node.attrs.caption
+                    ? node.content.find(node => node.type === "figure_caption")
+                        ?.content || []
+                    : [];
+                let caption;
+                if (category !== "none") {
+                    if (!this.categoryCounter[category]) {
+                        this.categoryCounter[category] = 1;
+                    }
+                    const catCount = this.categoryCounter[category]++;
+                    const catLabel = `${CATS[category][this.settings.language]} ${catCount}`;
+                    if (captionContent.length) {
+                        caption = `${catLabel}: ${captionContent.map(node => this.walkJson(node)).join("")}`;
+                    }
+                    else {
+                        caption = catLabel;
+                    }
+                }
+                else {
+                    caption = captionContent
+                        .map(node => this.walkJson(node))
+                        .join("");
+                }
+                let innerFigure = "";
+                let copyright;
+                const image = node.content.find(node => node.type === "image")?.attrs
+                    .image || false;
+                if (image) {
+                    this.imageIds.push(image);
+                    const imageDBEntry = this.imageDB.db[image], filePathName = imageDBEntry.image, filename = filePathName.split("/").pop();
+                    copyright = imageDBEntry.copyright;
+                    if (filename.split(".").pop() === "svg") {
+                        innerFigure += `\\includesvg[width=${Number.parseInt(node.attrs.width) / 100}\\textwidth]{${filename}}\n`;
+                        this.features.SVGs = true;
+                    }
+                    else {
+                        innerFigure += `\\scaledgraphics{${filename}}{${Number.parseInt(node.attrs.width) / 100}}\n`;
+                        this.features.images = true;
+                    }
+                }
+                else {
+                    const equation = node.content.find(node => node.type === "figure_equation")?.attrs.equation || "";
+                    innerFigure += `\\begin{displaymath}\n${equation}\n\\end{displaymath}\n`;
+                }
+                if (category === "table") {
+                    const aligned = node.attrs.width === "100" ? "left" : node.attrs.aligned;
+                    if (aligned === "center") {
+                        start += "\n\n\\begin{center}";
+                        end = "\n\n\\end{center}\n" + end;
+                    }
+                    else if (aligned === "right") {
+                        start += "\n\n{\\raggedleft"; // This is not a typo - raggedleft = aligned: right
+                        end = "\n\n}\n" + end;
+                    } // aligned === 'left' is default
+                    start += "\n\\begin{table}\n";
+                    content += caption.length ? `\\caption*{${caption}}` : "";
+                    content += `\\label{${node.attrs.id}}\n${innerFigure}`;
+                    end = "\\end{table}\n" + end;
+                }
+                else {
+                    // TODO: handle photo figure types in a special way
+                    if (node.attrs.width === "100" ||
+                        node.attrs.aligned === "center") {
+                        start += "\n\\begin{figure}\n";
+                        end = "\\end{figure}\n" + end;
+                    }
+                    else {
+                        const aligned = node.attrs.aligned[0];
+                        start += `\n\\begin{wrapfigure}{${aligned}}{${Number.parseInt(node.attrs.width) / 100}\\textwidth}\n`;
+                        end = "\\end{wrapfigure}\n" + end;
+                        this.features.wrapfig = true;
+                    }
+                    content += `${innerFigure}${caption.length ? `\\caption*{${caption}}` : ""}\\label{${node.attrs.id}}\n`;
+                }
+                if (copyright?.holder) {
+                    content += `% © ${copyright.year ? copyright.year : new Date().getFullYear()} ${copyright.holder}\n`;
+                }
+                if (copyright?.licenses.length) {
+                    copyright.licenses.forEach(license => {
+                        content += `% ${license.title}: ${license.url}${license.start ? ` (${license.start})\n` : ""}\n`;
+                    });
+                }
+                if (this.internalLinks.includes(node.attrs.id)) {
+                    // Add a link target
+                    end =
+                        `\\texorpdfstring{\\protect\\hypertarget{${node.attrs.id}}{}}{}\n` +
+                            end;
+                }
+                this.features.captions = true;
+                break;
+            }
+            case "figure_caption":
+                // We are already dealing with this in the figure. Prevent content from being added a second time.
+                return "";
+            case "figure_equation":
+                // We are already dealing with this in the figure.
+                break;
+            case "image":
+                // We are already dealing with this in the figure.
+                break;
+            case "table":
+                if (node.content?.length) {
+                    const category = node.attrs.category;
+                    const captionContent = node.attrs.caption
+                        ? node.content[0].content || []
+                        : [];
+                    let caption;
+                    if (category !== "none") {
+                        if (!this.categoryCounter[category]) {
+                            this.categoryCounter[category] = 1;
+                        }
+                        const catCount = this.categoryCounter[category]++;
+                        const catLabel = `${CATS[category][this.settings.language]} ${catCount}`;
+                        if (captionContent.length) {
+                            caption = `${catLabel}: ${captionContent.map(node => this.walkJson(node)).join("")}`;
+                        }
+                        else {
+                            caption = catLabel;
+                        }
+                    }
+                    else {
+                        caption = captionContent
+                            .map(node => this.walkJson(node))
+                            .join("");
+                    }
+                    let columns = 1;
+                    if (node.content.length > 1 &&
+                        node.content[1].content?.length) {
+                        columns = node.content[1].content[0].content.reduce((columns, node) => columns + node.attrs.colspan, 0);
+                    }
+                    const aligned = node.attrs.width === "100" ? "left" : node.attrs.aligned;
+                    if (aligned === "center") {
+                        start += "\n\n\\begin{center}";
+                        end = "\n\n\\end{center}\n" + end;
+                    }
+                    else if (aligned === "right") {
+                        start += "\n\n{\\raggedleft"; // This is not a typo - raggedleft = aligned: right
+                        end = "\n\n}\n";
+                    } // aligned === 'left' is default
+                    if (caption.length) {
+                        start += "\n\\begin{table}\n";
+                        start += `\\caption*{${caption}}\\label{${node.attrs.id}}`;
+                        end = "\\end{table}\n" + end;
+                        this.features.captions = true;
+                    }
+                    start += `\n\n\\begin{tabu} to ${node.attrs.width === "100"
+                        ? ""
+                        : Number.parseInt(node.attrs.width) / 100}\\textwidth { |${"X|".repeat(columns)} }\n\\hline\n\n`;
+                    end = "\\hline\n\n\\end{tabu}" + end;
+                    this.features.tables = true;
+                }
+                break;
+            case "table_body":
+                // Pass through to table.
+                break;
+            case "table_caption":
+                // We already deal with this in 'table'.
+                return "";
+            case "table_row":
+                end += " \\\\\n";
+                break;
+            case "table_cell":
+            case "table_header":
+                if (node.attrs.colspan > 1) {
+                    start += `\\multicolumn{${node.attrs.colspan}}{c}{`;
+                    end += "}";
+                }
+                // TODO: these multirow outputs don't work very well with longer text.
+                // If there is another alternative, please change!
+                if (node.attrs.rowspan > 1) {
+                    start += `\\multirow{${node.attrs.rowspan}}{*}{`;
+                    end += "}";
+                    this.features.rowspan = true;
+                }
+                end += " & ";
+                break;
+            case "equation":
+                content += `$${node.attrs.equation}$`;
+                break;
+            case "hard_break":
+                if (!options.noLineBreak) {
+                    content += "\n\n";
+                }
+                break;
+            default:
+                break;
+        }
+        if (node.content) {
+            node.content.forEach(child => {
+                content += this.walkJson(child, options);
+            });
+        }
+        if (placeFootnotesAfterBlock && options.unplacedFootnotes?.length) {
+            // There are footnotes that needed to be placed behind the node.
+            // This happens in the case of headlines and lists.
+            end += `\\addtocounter{footnote}{-${options.unplacedFootnotes.length}}`;
+            options.unplacedFootnotes.forEach(footnote => {
+                end += "\\stepcounter{footnote}\n";
+                end += "\\footnotetext{";
+                let fnContent = "";
+                footnote.forEach(footPar => {
+                    fnContent += this.walkJson(footPar, options);
+                });
+                end += fnContent.replace(/^\s+|\s+$/g, "");
+                end += "}";
+            });
+            options.unplacedFootnotes = [];
+        }
+        if (["table_cell", "table_header"].includes(node.type) &&
+            node.attrs.rowspan > 1) {
+            // \multirow doesn't allow multiple paragraphs.
+            content = content.trim().replace(/\n\n/g, " \\\\ ");
+        }
+        return start + content + end;
+    }
+    // The database doesn't ensure that citation keys are unique.
+    // So here we need to make sure that the same key is not used twice in one
+    // document.
+    createUniqueCitationKey(suggestedKey) {
+        const usedKeys = Object.keys(this.usedBibDB).map(key => {
+            return this.usedBibDB[key].entry_key;
+        });
+        if (usedKeys.includes(suggestedKey)) {
+            suggestedKey += "X";
+            return this.createUniqueCitationKey(suggestedKey);
+        }
+        else {
+            return suggestedKey;
+        }
+    }
+    postProcess(latex) {
+        return (latex
+            // join blocks of the same type that follow oneanother.
+            .replace(/\\end{code}\n\n\\begin{code}\n\n/g, "")
+            .replace(/\\end{quote}\n\n\\begin{quote}\n\n/g, "")
+            // Remove the last divider in any any table row.
+            .replace(/& {2}\\\\/g, "\\\\")
+            // Remove new lines between table cells.
+            .replace(/\n & \n\n/g, " & ")
+            // Remove new lines within itemization
+            .replace(/\\item \n\n/g, "\\item "));
+    }
+    assembleEpilogue() {
+        let epilogue = "";
+        if (this.features.citations) {
+            const bibliographyHeader = this.settings.bibliography_header[this.settings.language] ||
+                BIBLIOGRAPHY_HEADERS[this.settings.language];
+            epilogue += `\n\n\\printbibliography[title={${escapeLatexText(bibliographyHeader)}}]`;
+        }
+        return epilogue;
+    }
+    assembleCopyright() {
+        let note = "";
+        if (this.settings.copyright) {
+            if (this.settings.copyright.holder) {
+                note += `% © ${this.settings.copyright.year ? this.settings.copyright.year : new Date().getFullYear()} ${this.settings.copyright.holder}\n`;
+            }
+            if (this.settings.copyright.licenses.length) {
+                this.settings.copyright.licenses.forEach(license => {
+                    note += `% ${license.url}${license.start ? ` (${license.start})` : ""}\n`;
+                });
+            }
+        }
+        if (note.length) {
+            note += "\n\n";
+        }
+        return note;
+    }
+    assemblePreamble() {
+        let preamble = "";
+        if (this.features.subtitle) {
+            preamble += `
+                \n\\usepackage{titling}
+                \n\\newcommand{\\subtitle}[1]{%
+                    \n\t\\posttitle{%
+                        \n\t\t\\par\\end{center}
+                        \n\t\t\\begin{center}\\large#1\\end{center}
+                        \n\t\t\\vskip 0.5em}%
+                }
+            `;
+        }
+        if (this.features.authors) {
+            preamble += `
+                \n\\usepackage{authblk}
+                \n\\makeatletter
+                \n\\let\\@fnsymbol\\@alph
+                \n\\makeatother
+            `;
+        }
+        if (this.features.keywords) {
+            preamble += `
+                \n\\def\\keywords{\\vspace{.5em}
+                \n{\\textit{Keywords}:\\,\\relax%
+                \n}}
+                \n\\def\\endkeywords{\\par}
+                \n\\newcommand{\\sep}{, }
+            `;
+        }
+        if (this.features.hyperlinks) {
+            preamble += "\n\\usepackage{hyperref}";
+        }
+        if (this.features.captions) {
+            preamble += "\n\\usepackage{caption}";
+        }
+        if (this.features.wrapfig) {
+            preamble += "\n\\usepackage{wrapfig}";
+        }
+        if (this.features.citations) {
+            preamble += `
+                \n\\usepackage[backend=biber,hyperref=false,citestyle=authoryear,bibstyle=authoryear]{biblatex}
+                \n\\bibliography{bibliography}
+            `;
+        }
+        if (this.features.SVGs) {
+            preamble += "\n\\usepackage{svg}";
+        }
+        if (this.features.images) {
+            preamble += "\n\\usepackage{graphicx}";
+            // The following scales graphics down to text width, but not scaling them up if they are smaller
+            preamble += `
+                \n\\usepackage{calc}
+                \n\\newlength{\\imgwidth}
+                \n\\newcommand\\scaledgraphics[2]{%
+                \n\\settowidth{\\imgwidth}{\\includegraphics{#1}}%
+                \n\\setlength{\\imgwidth}{\\minof{\\imgwidth}{#2\\textwidth}}%
+                \n\\includegraphics[width=\\imgwidth,height=\\textheight,keepaspectratio]{#1}%
+                \n}
+            `;
+        }
+        if (this.features.tables) {
+            preamble += "\n\\usepackage{tabu}";
+        }
+        if (this.features.orderedListStart) {
+            preamble += "\n\\usepackage{enumitem}";
+        }
+        if (this.features.rowspan) {
+            preamble += "\n\\usepackage{multirow}";
+        }
+        if (this.features.code) {
+            // See https://tex.stackexchange.com/questions/445424/making-a-multiline-code-environment
+            preamble += `
+            \n\\usepackage{xcolor}
+            \\definecolor{mygray}{gray}{0.9}
+            \\usepackage{fvextra}
+            \\usepackage{tcolorbox}
+            \\newenvironment{code}%
+            {\\VerbatimEnvironment
+            \\begin{tcolorbox}[colback=mygray, boxsep=0pt, arc=0pt, boxrule=0pt]
+            \\begin{Verbatim}[fontsize=\\scriptsize, commandchars=\\\\\\{\\},
+            breaklines, breakafter=*, breaksymbolsep=0.5em,
+            breakaftersymbolpre={\\,\\tiny\\ensuremath{\\rfloor}}]}%
+            {\\end{Verbatim}%
+             \\end{tcolorbox}}
+            `;
+        }
+        return preamble;
+    }
+}
+//# sourceMappingURL=convert.js.map