@manuscripts/transform 1.0.0

package/dist/es/jats/jats-exporter.js

@@ -0,0 +1,1561 @@
+/*!
+ * © 2019 Atypon Systems LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ObjectTypes, } from '@manuscripts/manuscripts-json-schema';
+import debug from 'debug';
+import { DOMParser, DOMSerializer } from 'prosemirror-model';
+import serializeToXML from 'w3c-xmlserializer';
+import { nodeFromHTML, textFromHTML } from '../lib/html';
+import { normalizeStyleName } from '../lib/styled-content';
+import { iterateChildren } from '../lib/utils';
+import { schema, } from '../schema';
+import { generateAttachmentFilename } from '../transformer/filename';
+import { buildTargets } from '../transformer/labels';
+import { isExecutableNodeType, isNodeType } from '../transformer/node-types';
+import { hasObjectType } from '../transformer/object-types';
+import { findLatestManuscriptSubmission, findManuscript, findManuscriptById, } from '../transformer/project-bundle';
+import { chooseSecType } from '../transformer/section-category';
+import { selectVersionIds } from './jats-versions';
+const warn = debug('manuscripts-transform');
+const XLINK_NAMESPACE = 'http://www.w3.org/1999/xlink';
+const normalizeID = (id) => id.replace(/:/g, '_');
+const parser = DOMParser.fromSchema(schema);
+const findChildNodeOfType = (node, nodeType) => {
+    for (const child of iterateChildren(node)) {
+        if (child.type === nodeType) {
+            return child;
+        }
+    }
+};
+const isContributor = hasObjectType(ObjectTypes.Contributor);
+const CREDIT_VOCAB_IDENTIFIER = 'https://dictionary.casrai.org/Contributor_Roles';
+const chooseRoleVocabAttributes = (role) => {
+    if (role.uri && role.uri.startsWith(CREDIT_VOCAB_IDENTIFIER)) {
+        return {
+            vocab: 'credit',
+            'vocab-identifier': CREDIT_VOCAB_IDENTIFIER,
+            'vocab-term': role.name,
+            'vocab-term-identifier': role.uri,
+        };
+    }
+    return {
+        vocab: 'uncontrolled',
+    };
+};
+const insertAbstractNode = (articleMeta, abstractNode) => {
+    const siblings = [
+        'kwd-group',
+        'funding-group',
+        'support-group',
+        'conference',
+        'counts',
+        'custom-meta-group',
+    ];
+    for (const sibling of siblings) {
+        const siblingNode = articleMeta.querySelector(`:scope > ${sibling}`);
+        if (siblingNode) {
+            articleMeta.insertBefore(abstractNode, siblingNode);
+            return;
+        }
+    }
+    articleMeta.appendChild(abstractNode);
+};
+export const createCounter = () => {
+    const counts = new Map();
+    return {
+        increment: (field) => {
+            const value = counts.get(field);
+            const newValue = value === undefined ? 1 : value + 1;
+            counts.set(field, newValue);
+            return newValue;
+        },
+    };
+};
+const createDefaultIdGenerator = () => {
+    const counter = createCounter();
+    return async (element) => {
+        const value = String(counter.increment(element.nodeName));
+        return `${element.nodeName}-${value}`;
+    };
+};
+const chooseRefType = (objectType) => {
+    switch (objectType) {
+        case ObjectTypes.Figure:
+        case ObjectTypes.FigureElement:
+            return 'fig';
+        case ObjectTypes.Footnote:
+            return 'fn';
+        case ObjectTypes.Table:
+        case ObjectTypes.TableElement:
+            return 'table';
+        case ObjectTypes.Section:
+            return 'sec';
+        case ObjectTypes.Equation:
+        case ObjectTypes.EquationElement:
+            return 'disp-formula';
+    }
+};
+const sortContributors = (a, b) => Number(a.priority) - Number(b.priority);
+export class JATSExporter {
+    constructor() {
+        this.serializeToJATS = async (fragment, modelMap, manuscriptID, options = {}) => {
+            const { version = '1.2', doi, id, frontMatterOnly = false, links, idGenerator, mediaPathGenerator, } = options;
+            this.modelMap = modelMap;
+            this.models = Array.from(this.modelMap.values());
+            this.createSerializer();
+            const versionIds = selectVersionIds(version);
+            this.document = document.implementation.createDocument(null, 'article', document.implementation.createDocumentType('article', versionIds.publicId, versionIds.systemId));
+            const article = this.document.documentElement;
+            article.setAttributeNS('http://www.w3.org/2000/xmlns/', 'xmlns:xlink', XLINK_NAMESPACE);
+            const front = this.buildFront(doi, id, links);
+            article.appendChild(front);
+            const manuscript = findManuscriptById(this.modelMap, manuscriptID);
+            article.setAttribute('article-type', manuscript.articleType || 'other');
+            if (!frontMatterOnly) {
+                this.labelTargets = buildTargets(fragment, manuscript);
+                const body = this.buildBody(fragment);
+                article.appendChild(body);
+                const back = this.buildBack(body);
+                article.appendChild(back);
+                this.moveAbstracts(front, body);
+                this.moveFloatsGroup(body, article);
+            }
+            await this.rewriteIDs(idGenerator);
+            if (mediaPathGenerator) {
+                await this.rewriteMediaPaths(mediaPathGenerator);
+            }
+            this.rewriteCrossReferenceTypes();
+            return serializeToXML(this.document);
+        };
+        this.nodeFromJATS = (JATSFragment) => {
+            JATSFragment = JATSFragment.trim();
+            if (!JATSFragment.length) {
+                return null;
+            }
+            const template = this.document.createElement('template');
+            template.innerHTML = JATSFragment;
+            return template.firstChild;
+        };
+        this.rewriteCrossReferenceTypes = () => {
+            var _a;
+            const figRefs = this.document.querySelectorAll('xref[ref-type=fig][rid]');
+            if (!figRefs.length) {
+                return;
+            }
+            for (const xref of figRefs) {
+                const rid = xref.getAttribute('rid');
+                if (rid) {
+                    const nodeName = (_a = this.document.getElementById(rid)) === null || _a === void 0 ? void 0 : _a.nodeName;
+                    if (nodeName) {
+                        switch (nodeName) {
+                            case 'table-wrap-group':
+                            case 'table-wrap':
+                            case 'table':
+                                xref.setAttribute('ref-type', 'table');
+                                break;
+                        }
+                    }
+                }
+            }
+        };
+        this.rewriteMediaPaths = async (mediaPathGenerator) => {
+            for (const fig of this.document.querySelectorAll('fig')) {
+                const parentID = fig.getAttribute('id');
+                for (const graphic of fig.querySelectorAll('graphic')) {
+                    const newHref = await mediaPathGenerator(graphic, parentID);
+                    graphic.setAttributeNS(XLINK_NAMESPACE, 'href', newHref);
+                }
+            }
+            for (const suppMaterial of this.document.querySelectorAll('supplementary-material')) {
+                const newHref = await mediaPathGenerator(suppMaterial, suppMaterial.id);
+                suppMaterial.setAttributeNS(XLINK_NAMESPACE, 'href', newHref);
+            }
+        };
+        this.rewriteIDs = async (idGenerator = createDefaultIdGenerator()) => {
+            const idMap = new Map();
+            for (const element of this.document.querySelectorAll('[id]')) {
+                const previousID = element.getAttribute('id');
+                const newID = await idGenerator(element);
+                if (newID) {
+                    element.setAttribute('id', newID);
+                }
+                else {
+                    element.removeAttribute('id');
+                }
+                if (previousID) {
+                    idMap.set(previousID, newID);
+                }
+            }
+            for (const node of this.document.querySelectorAll('[rid]')) {
+                const rids = node.getAttribute('rid');
+                if (rids) {
+                    const newRIDs = rids
+                        .split(/\s+/)
+                        .filter(Boolean)
+                        .map((previousRID) => idMap.get(previousRID))
+                        .filter(Boolean);
+                    if (newRIDs.length) {
+                        node.setAttribute('rid', newRIDs.join(' '));
+                    }
+                }
+            }
+        };
+        this.setTitleContent = (element, title) => {
+            const htmlTitleNode = nodeFromHTML(`<h1>${title}</h1>`);
+            if (htmlTitleNode) {
+                const titleNode = parser.parse(htmlTitleNode, {
+                    topNode: schema.nodes.section_title.create(),
+                });
+                const jatsTitleNode = this.serializeNode(titleNode);
+                while (jatsTitleNode.firstChild) {
+                    element.appendChild(jatsTitleNode.firstChild);
+                }
+            }
+        };
+        this.buildFront = (doi, id, links) => {
+            var _a, _b, _c, _d;
+            const manuscript = findManuscript(this.modelMap);
+            const submission = findLatestManuscriptSubmission(this.modelMap, manuscript);
+            const front = this.document.createElement('front');
+            const journalMeta = this.document.createElement('journal-meta');
+            front.appendChild(journalMeta);
+            const articleMeta = this.document.createElement('article-meta');
+            front.appendChild(articleMeta);
+            const journal = [...this.modelMap.values()].find((model) => model.objectType === ObjectTypes.Journal);
+            if (journal) {
+                if (journal.journalIdentifiers) {
+                    for (const item of journal.journalIdentifiers) {
+                        const element = this.document.createElement('journal-id');
+                        if (item.journalIDType) {
+                            element.setAttribute('journal-id-type', item.journalIDType);
+                        }
+                        element.textContent = item.journalID;
+                        journalMeta.appendChild(element);
+                    }
+                }
+                if (journal.title || journal.abbreviatedTitles) {
+                    const parentElement = this.document.createElement('journal-title-group');
+                    journalMeta.appendChild(parentElement);
+                    if (journal.title) {
+                        const element = this.document.createElement('journal-title');
+                        element.textContent = journal.title;
+                        parentElement.appendChild(element);
+                    }
+                    if (journal.abbreviatedTitles) {
+                        for (const item of journal.abbreviatedTitles) {
+                            const element = this.document.createElement('abbrev-journal-title');
+                            if (item.abbrevType) {
+                                element.setAttribute('abbrev-type', item.abbrevType);
+                            }
+                            element.textContent = item.abbreviatedTitle;
+                            parentElement.appendChild(element);
+                        }
+                    }
+                }
+                if (journal.ISSNs) {
+                    for (const item of journal.ISSNs) {
+                        const element = this.document.createElement('issn');
+                        if (item.publicationType) {
+                            element.setAttribute('pub-type', item.publicationType);
+                        }
+                        element.textContent = item.ISSN;
+                        journalMeta.appendChild(element);
+                    }
+                }
+                if (journal.publisherName) {
+                    const publisher = this.document.createElement('publisher');
+                    const publisherName = this.document.createElement('publisher-name');
+                    publisherName.textContent = journal.publisherName;
+                    publisher.appendChild(publisherName);
+                    journalMeta.appendChild(publisher);
+                }
+            }
+            else {
+                if (submission) {
+                    if (submission.journalCode) {
+                        const journalID = this.document.createElement('journal-id');
+                        journalID.setAttribute('journal-id-type', 'publisher-id');
+                        journalID.textContent = submission.journalCode;
+                        journalMeta.appendChild(journalID);
+                    }
+                    if (submission.journalTitle) {
+                        const journalTitleGroup = this.document.createElement('journal-title-group');
+                        journalMeta.appendChild(journalTitleGroup);
+                        const journalTitle = this.document.createElement('journal-title');
+                        journalTitle.textContent = submission.journalTitle;
+                        journalTitleGroup.appendChild(journalTitle);
+                    }
+                    if (submission.issn) {
+                        const issn = this.document.createElement('issn');
+                        issn.setAttribute('pub-type', 'epub');
+                        issn.textContent = submission.issn;
+                        journalMeta.appendChild(issn);
+                    }
+                }
+            }
+            if (id) {
+                const articleID = this.document.createElement('article-id');
+                articleID.setAttribute('pub-id-type', 'publisher-id');
+                articleID.textContent = id;
+                articleMeta.appendChild(articleID);
+            }
+            if (doi) {
+                const articleID = this.document.createElement('article-id');
+                articleID.setAttribute('pub-id-type', 'doi');
+                articleID.textContent = doi;
+                articleMeta.appendChild(articleID);
+            }
+            const titleGroup = this.document.createElement('title-group');
+            articleMeta.appendChild(titleGroup);
+            this.buildContributors(articleMeta);
+            if (links && links.self) {
+                for (const [key, value] of Object.entries(links.self)) {
+                    const link = this.document.createElement('self-uri');
+                    link.setAttribute('content-type', key);
+                    link.setAttributeNS(XLINK_NAMESPACE, 'href', value);
+                    articleMeta.appendChild(link);
+                }
+            }
+            if (manuscript.title) {
+                const element = this.document.createElement('article-title');
+                this.setTitleContent(element, manuscript.title);
+                titleGroup.appendChild(element);
+            }
+            if (manuscript.subtitle) {
+                const element = this.document.createElement('subtitle');
+                this.setTitleContent(element, manuscript.subtitle);
+                titleGroup.appendChild(element);
+            }
+            if (manuscript.runningTitle) {
+                const element = this.document.createElement('alt-title');
+                element.setAttribute('alt-title-type', 'right-running');
+                this.setTitleContent(element, manuscript.runningTitle);
+                titleGroup.appendChild(element);
+            }
+            const supplements = [...this.modelMap.values()].filter((model) => model.objectType === ObjectTypes.Supplement);
+            if (supplements && supplements.length > 0) {
+                for (const supplement of supplements) {
+                    const supplementaryMaterial = this.document.createElement('supplementary-material');
+                    supplementaryMaterial.setAttribute('id', normalizeID(supplement._id));
+                    supplementaryMaterial.setAttributeNS(XLINK_NAMESPACE, 'href', (_a = supplement.href) !== null && _a !== void 0 ? _a : '');
+                    const mimeType = (_b = supplement.MIME) === null || _b === void 0 ? void 0 : _b.split('/')[0];
+                    const mimeSubType = (_c = supplement.MIME) === null || _c === void 0 ? void 0 : _c.split('/')[1];
+                    supplementaryMaterial.setAttribute('mimetype', mimeType !== null && mimeType !== void 0 ? mimeType : '');
+                    supplementaryMaterial.setAttribute('mime-subtype', mimeSubType !== null && mimeSubType !== void 0 ? mimeSubType : '');
+                    const caption = this.document.createElement('caption');
+                    const title = this.document.createElement('title');
+                    title.textContent = (_d = supplement.title) !== null && _d !== void 0 ? _d : '';
+                    caption.append(title);
+                    supplementaryMaterial.append(caption);
+                    articleMeta.append(supplementaryMaterial);
+                }
+            }
+            const history = articleMeta.querySelector('history') ||
+                this.document.createElement('history');
+            if (manuscript.acceptanceDate) {
+                const date = this.buildDateElement(manuscript.acceptanceDate, 'accepted');
+                history.appendChild(date);
+            }
+            if (manuscript.correctionDate) {
+                const date = this.buildDateElement(manuscript.correctionDate, 'corrected');
+                history.appendChild(date);
+            }
+            if (manuscript.retractionDate) {
+                const date = this.buildDateElement(manuscript.retractionDate, 'retracted');
+                history.appendChild(date);
+            }
+            if (manuscript.receiveDate) {
+                const date = this.buildDateElement(manuscript.receiveDate, 'received');
+                history.appendChild(date);
+            }
+            if (manuscript.revisionReceiveDate) {
+                const date = this.buildDateElement(manuscript.revisionReceiveDate, 'rev-recd');
+                history.appendChild(date);
+            }
+            if (manuscript.revisionRequestDate) {
+                const date = this.buildDateElement(manuscript.revisionRequestDate, 'rev-request');
+                history.appendChild(date);
+            }
+            if (history.childElementCount) {
+                articleMeta.appendChild(history);
+            }
+            if (manuscript.keywordIDs) {
+                this.buildKeywords(articleMeta, manuscript.keywordIDs);
+            }
+            let countingElements = [];
+            if (manuscript.genericCounts) {
+                const elements = manuscript.genericCounts.map((el) => {
+                    const countingElement = this.buildCountingElement('count', el.count);
+                    if (countingElement) {
+                        countingElement.setAttribute('count-type', el.countType);
+                    }
+                    return countingElement;
+                });
+                countingElements.push(...elements);
+            }
+            countingElements.push(this.buildCountingElement('fig-count', manuscript.figureCount));
+            countingElements.push(this.buildCountingElement('table-count', manuscript.tableCount));
+            countingElements.push(this.buildCountingElement('equation-count', manuscript.equationCount));
+            countingElements.push(this.buildCountingElement('ref-count', manuscript.referencesCount));
+            countingElements.push(this.buildCountingElement('word-count', manuscript.wordCount));
+            countingElements = countingElements.filter((el) => el);
+            if (countingElements.length > 0) {
+                const counts = this.document.createElement('counts');
+                counts.append(...countingElements);
+                articleMeta.append(counts);
+            }
+            if (!journalMeta.hasChildNodes()) {
+                journalMeta.remove();
+            }
+            return front;
+        };
+        this.buildDateElement = (timestamp, type) => {
+            const dateElement = this.document.createElement('date');
+            dateElement.setAttribute('date-type', type);
+            const date = new Date(timestamp * 1000);
+            const lookup = {
+                year: date.getUTCFullYear().toString(),
+                month: date.getUTCMonth().toString(),
+                day: date.getUTCDate().toString(),
+            };
+            for (const [key, value] of Object.entries(lookup).reverse()) {
+                const el = this.document.createElement(key);
+                el.textContent = value;
+                dateElement.appendChild(el);
+            }
+            return dateElement;
+        };
+        this.buildCountingElement = (tagName, count) => {
+            if (count) {
+                const wordCount = this.document.createElement(tagName);
+                wordCount.setAttribute('count', String(count));
+                return wordCount;
+            }
+        };
+        this.buildBody = (fragment) => {
+            const content = this.serializeFragment(fragment);
+            const body = this.document.createElement('body');
+            body.appendChild(content);
+            this.fixBody(body, fragment);
+            return body;
+        };
+        this.buildBack = (body) => {
+            const back = this.document.createElement('back');
+            this.moveSectionsToBack(back, body);
+            const footnotesElements = this.document.querySelectorAll('sec > fn-group');
+            for (const footnotesElement of footnotesElements) {
+                const previousParent = footnotesElement.parentElement;
+                back.appendChild(footnotesElement);
+                if (previousParent) {
+                    const title = previousParent.querySelector('title');
+                    if (title) {
+                        footnotesElement.insertBefore(title, footnotesElement.firstElementChild);
+                    }
+                    if (!previousParent.childElementCount) {
+                        previousParent.remove();
+                    }
+                }
+            }
+            let refList = this.document.querySelector('ref-list');
+            if (!refList) {
+                warn('No bibliography element, creating a ref-list anyway');
+                refList = this.document.createElement('ref-list');
+            }
+            back.appendChild(refList);
+            const bibliographyItems = this.models.filter(hasObjectType(ObjectTypes.BibliographyItem));
+            for (const bibliographyItem of bibliographyItems) {
+                const ref = this.document.createElement('ref');
+                ref.setAttribute('id', normalizeID(bibliographyItem._id));
+                const updateCitationPubType = (citationEl, pubType) => {
+                    if (pubType) {
+                        switch (pubType) {
+                            case 'article':
+                            case 'article-journal':
+                                citationEl.setAttribute('publication-type', 'journal');
+                                break;
+                            default:
+                                citationEl.setAttribute('publication-type', pubType);
+                                break;
+                        }
+                    }
+                    else {
+                        citationEl.setAttribute('publication-type', 'journal');
+                    }
+                };
+                if (bibliographyItem.literal) {
+                    const mixedCitation = this.document.createElement('mixed-citation');
+                    updateCitationPubType(mixedCitation, bibliographyItem.type);
+                    mixedCitation.textContent = bibliographyItem.literal;
+                    ref.appendChild(mixedCitation);
+                    refList.appendChild(ref);
+                }
+                else {
+                    const citation = this.document.createElement('element-citation');
+                    updateCitationPubType(citation, bibliographyItem.type);
+                    if (bibliographyItem.author) {
+                        const personGroupNode = this.document.createElement('person-group');
+                        personGroupNode.setAttribute('person-group-type', 'author');
+                        citation.appendChild(personGroupNode);
+                        bibliographyItem.author.forEach((author) => {
+                            const name = this.document.createElement('string-name');
+                            if (author.family) {
+                                const node = this.document.createElement('surname');
+                                node.textContent = author.family;
+                                name.appendChild(node);
+                            }
+                            if (author.given) {
+                                const node = this.document.createElement('given-names');
+                                node.textContent = author.given;
+                                name.appendChild(node);
+                            }
+                            if (name.hasChildNodes()) {
+                                personGroupNode.appendChild(name);
+                            }
+                            if (author.literal) {
+                                const collab = this.document.createElement('collab');
+                                collab.textContent = author.literal;
+                                personGroupNode.appendChild(collab);
+                            }
+                        });
+                    }
+                    if (bibliographyItem.issued) {
+                        const dateParts = bibliographyItem.issued['date-parts'];
+                        if (dateParts && dateParts.length) {
+                            const [[year, month, day]] = dateParts;
+                            if (year) {
+                                const node = this.document.createElement('year');
+                                node.textContent = String(year);
+                                citation.appendChild(node);
+                            }
+                            if (month) {
+                                const node = this.document.createElement('month');
+                                node.textContent = String(month);
+                                citation.appendChild(node);
+                            }
+                            if (day) {
+                                const node = this.document.createElement('day');
+                                node.textContent = String(day);
+                                citation.appendChild(node);
+                            }
+                        }
+                    }
+                    if (bibliographyItem.title) {
+                        const node = this.document.createElement('article-title');
+                        this.setTitleContent(node, bibliographyItem.title);
+                        citation.appendChild(node);
+                    }
+                    if (bibliographyItem['container-title']) {
+                        const node = this.document.createElement('source');
+                        node.textContent = bibliographyItem['container-title'];
+                        citation.appendChild(node);
+                    }
+                    if (bibliographyItem.volume) {
+                        const node = this.document.createElement('volume');
+                        node.textContent = String(bibliographyItem.volume);
+                        citation.appendChild(node);
+                    }
+                    if (bibliographyItem.issue) {
+                        const node = this.document.createElement('issue');
+                        node.textContent = String(bibliographyItem.issue);
+                        citation.appendChild(node);
+                    }
+                    if (bibliographyItem.supplement) {
+                        const node = this.document.createElement('supplement');
+                        node.textContent = bibliographyItem.supplement;
+                        citation.appendChild(node);
+                    }
+                    if (bibliographyItem.page) {
+                        const pageString = String(bibliographyItem.page);
+                        if (/^\d+$/.test(pageString)) {
+                            const node = this.document.createElement('fpage');
+                            node.textContent = pageString;
+                            citation.appendChild(node);
+                        }
+                        else if (/^\d+-\d+$/.test(pageString)) {
+                            const [fpage, lpage] = pageString.split('-');
+                            const fpageNode = this.document.createElement('fpage');
+                            fpageNode.textContent = fpage;
+                            citation.appendChild(fpageNode);
+                            const lpageNode = this.document.createElement('lpage');
+                            lpageNode.textContent = lpage;
+                            citation.appendChild(lpageNode);
+                        }
+                        else {
+                            const node = this.document.createElement('page-range');
+                            node.textContent = pageString;
+                            citation.appendChild(node);
+                        }
+                    }
+                    if (bibliographyItem.DOI) {
+                        const node = this.document.createElement('pub-id');
+                        node.setAttribute('pub-id-type', 'doi');
+                        node.textContent = String(bibliographyItem.DOI);
+                        citation.appendChild(node);
+                    }
+                    ref.appendChild(citation);
+                    refList.appendChild(ref);
+                }
+            }
+            return back;
+        };
+        this.createSerializer = () => {
+            const getModel = (id) => id ? this.modelMap.get(id) : undefined;
+            const nodes = {
+                attribution: () => ['attrib', 0],
+                bibliography_element: () => '',
+                bibliography_item: () => '',
+                bibliography_section: (node) => [
+                    'ref-list',
+                    { id: normalizeID(node.attrs.id) },
+                    0,
+                ],
+                blockquote_element: () => ['disp-quote', { 'content-type': 'quote' }, 0],
+                bullet_list: () => ['list', { 'list-type': 'bullet' }, 0],
+                caption: () => ['p', 0],
+                caption_title: (node) => {
+                    if (!node.textContent) {
+                        return '';
+                    }
+                    return ['title', 0];
+                },
+                citation: (node) => {
+                    if (!node.attrs.rid) {
+                        warn(`${node.attrs.id} has no rid`);
+                        return node.attrs.label;
+                    }
+                    const citation = getModel(node.attrs.rid);
+                    if (!citation) {
+                        warn(`Missing citation ${node.attrs.rid}`);
+                        return '';
+                    }
+                    const rids = citation.embeddedCitationItems.filter((item) => {
+                        if (!this.modelMap.has(item.bibliographyItem)) {
+                            warn(`Missing ${item.bibliographyItem} referenced by ${citation._id}`);
+                            return false;
+                        }
+                        return true;
+                    });
+                    if (!rids.length) {
+                        warn(`${citation._id} has no confirmed rids`);
+                        return '';
+                    }
+                    const xref = this.document.createElement('xref');
+                    xref.setAttribute('ref-type', 'bibr');
+                    xref.setAttribute('rid', rids.map((item) => normalizeID(item.bibliographyItem)).join(' '));
+                    if (node.attrs.contents) {
+                        const text = textFromHTML(node.attrs.contents);
+                        if (text !== null && text.length) {
+                            xref.textContent = text;
+                        }
+                    }
+                    return xref;
+                },
+                cross_reference: (node) => {
+                    var _a;
+                    if (!node.attrs.rid) {
+                        warn(`${node.attrs.id} has no rid`);
+                        return node.attrs.label;
+                    }
+                    const auxiliaryObjectReference = getModel(node.attrs.rid);
+                    if (!auxiliaryObjectReference) {
+                        warn(`Missing model ${node.attrs.rid}`);
+                        return node.attrs.label;
+                    }
+                    const xref = this.document.createElement('xref');
+                    const referencedObject = getModel(auxiliaryObjectReference.referencedObject ||
+                        ((auxiliaryObjectReference === null || auxiliaryObjectReference === void 0 ? void 0 : auxiliaryObjectReference.referencedObjects) &&
+                            auxiliaryObjectReference.referencedObjects[0]));
+                    if (referencedObject) {
+                        const refType = chooseRefType(referencedObject.objectType);
+                        if (refType) {
+                            xref.setAttribute('ref-type', refType);
+                        }
+                        else {
+                            warn(`Unset ref-type for objectType ${referencedObject.objectType}`);
+                        }
+                    }
+                    const getReferencedObjectId = (referencedObject) => {
+                        return normalizeID(referencedObject);
+                    };
+                    if (auxiliaryObjectReference.referencedObjects) {
+                        const rid = (_a = auxiliaryObjectReference.referencedObjects) === null || _a === void 0 ? void 0 : _a.map((referencedObject) => getReferencedObjectId(referencedObject)).join(' ');
+                        xref.setAttribute('rid', rid);
+                    }
+                    if (auxiliaryObjectReference.referencedObject) {
+                        const rid = getReferencedObjectId(auxiliaryObjectReference.referencedObject);
+                        xref.setAttribute('rid', rid);
+                    }
+                    xref.textContent = node.attrs.label;
+                    return xref;
+                },
+                doc: () => '',
+                equation: (node) => {
+                    const formula = this.document.createElement('disp-formula');
+                    formula.setAttribute('id', normalizeID(node.attrs.id));
+                    if (node.attrs.TeXRepresentation) {
+                        const math = this.document.createElement('tex-math');
+                        math.textContent = node.attrs.TeXRepresentation;
+                        formula.appendChild(math);
+                    }
+                    else if (node.attrs.MathMLStringRepresentation) {
+                        const math = this.nodeFromJATS(node.attrs.MathMLStringRepresentation);
+                        if (math) {
+                            formula.appendChild(math);
+                        }
+                    }
+                    return formula;
+                },
+                equation_element: (node) => createFigureElement(node, 'fig', node.type.schema.nodes.equation, 'equation'),
+                figcaption: (node) => {
+                    if (!node.textContent) {
+                        return '';
+                    }
+                    return ['caption', 0];
+                },
+                figure: (node) => {
+                    const graphic = this.document.createElement('graphic');
+                    const filename = generateAttachmentFilename(node.attrs.id, node.attrs.contentType);
+                    graphic.setAttributeNS(XLINK_NAMESPACE, 'xlink:href', `graphic/${filename}`);
+                    if (node.attrs.contentType) {
+                        const [mimeType, mimeSubType] = node.attrs.contentType.split('/');
+                        if (mimeType) {
+                            graphic.setAttribute('mimetype', mimeType);
+                            if (mimeSubType) {
+                                graphic.setAttribute('mime-subtype', mimeSubType);
+                            }
+                        }
+                    }
+                    return graphic;
+                },
+                figure_element: (node) => createFigureElement(node, 'fig', node.type.schema.nodes.figure, 'figure'),
+                footnote: (node) => {
+                    const attrs = {};
+                    if (node.attrs.id) {
+                        attrs.id = normalizeID(node.attrs.id);
+                    }
+                    if (node.attrs.category) {
+                        attrs['fn-type'] = node.attrs.category;
+                    }
+                    return ['fn', attrs, 0];
+                },
+                footnotes_element: (node) => {
+                    const kind = node.attrs.kind;
+                    let tag = 'fn-group';
+                    if (kind && kind.includes('table')) {
+                        tag = 'table-wrap-foot';
+                    }
+                    return [tag, { id: normalizeID(node.attrs.id) }, 0];
+                },
+                footnotes_section: (node) => {
+                    const attrs = {
+                        id: normalizeID(node.attrs.id),
+                        'sec-type': 'endnotes',
+                    };
+                    return ['sec', attrs, 0];
+                },
+                hard_break: () => ['break'],
+                highlight_marker: () => '',
+                inline_equation: (node) => {
+                    const formula = this.document.createElement('inline-formula');
+                    formula.setAttribute('id', normalizeID(node.attrs.id));
+                    if (node.attrs.TeXRepresentation) {
+                        const math = this.document.createElement('tex-math');
+                        math.textContent = node.attrs.TeXRepresentation;
+                        formula.appendChild(math);
+                    }
+                    else if (node.attrs.MathMLRepresentation) {
+                        const math = this.nodeFromJATS(node.attrs.MathMLRepresentation);
+                        if (math) {
+                            formula.appendChild(math);
+                        }
+                    }
+                    else if (node.attrs.SVGRepresentation) {
+                        const math = this.nodeFromJATS(node.attrs.SVGRepresentation);
+                        if (math) {
+                            formula.appendChild(math);
+                        }
+                    }
+                    return formula;
+                },
+                inline_footnote: (node) => {
+                    const xref = this.document.createElement('xref');
+                    xref.setAttribute('ref-type', 'fn');
+                    xref.setAttribute('rid', normalizeID(node.attrs.rid));
+                    xref.textContent = node.attrs.contents;
+                    return xref;
+                },
+                keywords_element: () => '',
+                keywords_section: () => '',
+                link: (node) => {
+                    const text = node.textContent;
+                    if (!text) {
+                        return '';
+                    }
+                    if (!node.attrs.href) {
+                        return text;
+                    }
+                    const linkNode = this.document.createElement('ext-link');
+                    linkNode.setAttribute('ext-link-type', 'uri');
+                    linkNode.setAttributeNS(XLINK_NAMESPACE, 'href', node.attrs.href);
+                    linkNode.textContent = text;
+                    if (node.attrs.title) {
+                        linkNode.setAttributeNS(XLINK_NAMESPACE, 'xlink:title', node.attrs.title);
+                    }
+                    return linkNode;
+                },
+                list_item: () => ['list-item', 0],
+                listing: (node) => {
+                    const code = this.document.createElement('code');
+                    code.setAttribute('id', normalizeID(node.attrs.id));
+                    code.setAttribute('language', node.attrs.languageKey);
+                    code.textContent = node.attrs.contents;
+                    return code;
+                },
+                listing_element: (node) => createFigureElement(node, 'fig', node.type.schema.nodes.listing, 'listing'),
+                manuscript: (node) => ['article', { id: normalizeID(node.attrs.id) }, 0],
+                missing_figure: () => {
+                    const graphic = this.document.createElement('graphic');
+                    graphic.setAttribute('specific-use', 'MISSING');
+                    graphic.setAttributeNS(XLINK_NAMESPACE, 'xlink:href', '');
+                    return graphic;
+                },
+                ordered_list: () => ['list', { 'list-type': 'order' }, 0],
+                paragraph: (node) => {
+                    if (!node.childCount) {
+                        return '';
+                    }
+                    const attrs = {};
+                    if (node.attrs.id) {
+                        attrs.id = normalizeID(node.attrs.id);
+                    }
+                    if (node.attrs.contentType) {
+                        attrs['content-type'] = node.attrs.contentType;
+                    }
+                    return ['p', attrs, 0];
+                },
+                placeholder: () => {
+                    return this.document.createElement('boxed-text');
+                },
+                placeholder_element: () => {
+                    return this.document.createElement('boxed-text');
+                },
+                pullquote_element: () => [
+                    'disp-quote',
+                    { 'content-type': 'pullquote' },
+                    0,
+                ],
+                graphical_abstract_section: (node) => {
+                    const attrs = {
+                        id: normalizeID(node.attrs.id),
+                    };
+                    attrs['sec-type'] = 'abstract-graphical';
+                    return ['sec', attrs, 0];
+                },
+                section: (node) => {
+                    const attrs = {
+                        id: normalizeID(node.attrs.id),
+                    };
+                    if (node.attrs.category) {
+                        attrs['sec-type'] = chooseSecType(node.attrs.category);
+                    }
+                    return ['sec', attrs, 0];
+                },
+                section_label: () => ['label', 0],
+                section_title: () => ['title', 0],
+                table: (node) => ['table', { id: normalizeID(node.attrs.id) }, 0],
+                table_element: (node) => {
+                    const element = createFigureElement(node, 'table-wrap', node.type.schema.nodes.table);
+                    element.setAttribute('position', 'anchor');
+                    return element;
+                },
+                table_body: () => ['tbody', 0],
+                table_cell: (node) => [
+                    node.attrs.celltype,
+                    Object.assign(Object.assign({ valign: node.attrs.valign, align: node.attrs.align, scope: node.attrs.scope, style: node.attrs.style }, (node.attrs.rowspan > 1 && { rowspan: node.attrs.rowspan })), (node.attrs.colspan > 1 && { colspan: node.attrs.colspan })),
+                    0,
+                ],
+                table_row: () => ['tr', 0],
+                table_col: (node) => ['col', { width: node.attrs.width }],
+                table_colgroup: () => ['colgroup', 0],
+                text: (node) => node.text,
+                toc_element: () => '',
+                toc_section: () => '',
+                comment: () => '',
+            };
+            const marks = {
+                bold: () => ['bold'],
+                code: () => ['code', { position: 'anchor' }],
+                italic: () => ['italic'],
+                smallcaps: () => ['sc'],
+                strikethrough: () => ['strike'],
+                styled: (mark) => {
+                    const inlineStyle = getModel(mark.attrs.rid);
+                    const attrs = {};
+                    if (inlineStyle && inlineStyle.title) {
+                        attrs.style = normalizeStyleName(inlineStyle.title);
+                    }
+                    return ['styled-content', attrs];
+                },
+                superscript: () => ['sup'],
+                subscript: () => ['sub'],
+                underline: () => ['underline'],
+                tracked_insert: () => ['ins'],
+                tracked_delete: () => ['del'],
+            };
+            this.serializer = new DOMSerializer(nodes, marks);
+            const createFigureElement = (node, nodeName, contentNodeType, figType) => {
+                const element = this.document.createElement(nodeName);
+                element.setAttribute('id', normalizeID(node.attrs.id));
+                if (figType) {
+                    element.setAttribute('fig-type', figType);
+                }
+                if (node.attrs.label) {
+                    const label = this.document.createElement('label');
+                    label.textContent = node.attrs.label;
+                    element.appendChild(label);
+                }
+                else if (this.labelTargets) {
+                    const target = this.labelTargets.get(node.attrs.id);
+                    if (target) {
+                        const label = this.document.createElement('label');
+                        label.textContent = target.label;
+                        element.appendChild(label);
+                    }
+                }
+                const figcaptionNode = findChildNodeOfType(node, node.type.schema.nodes.figcaption);
+                if (figcaptionNode) {
+                    element.appendChild(this.serializeNode(figcaptionNode));
+                }
+                const footnotesNode = findChildNodeOfType(node, node.type.schema.nodes.footnotes_element);
+                if (footnotesNode) {
+                    element.appendChild(this.serializeNode(footnotesNode));
+                }
+                node.forEach((childNode) => {
+                    if (childNode.type === contentNodeType) {
+                        if (childNode.attrs.id) {
+                            element.appendChild(this.serializeNode(childNode));
+                        }
+                    }
+                    else if (childNode.type === node.type.schema.nodes.paragraph) {
+                        element.appendChild(this.serializeNode(childNode));
+                    }
+                    else if (childNode.type === node.type.schema.nodes.missing_figure) {
+                        element.appendChild(this.serializeNode(childNode));
+                    }
+                });
+                if (node.attrs.attribution) {
+                    const attribution = this.document.createElement('attrib');
+                    attribution.textContent = node.attrs.attribution.literal;
+                    element.appendChild(attribution);
+                }
+                if (isExecutableNodeType(node.type)) {
+                    processExecutableNode(node, element);
+                }
+                return element;
+            };
+            const processExecutableNode = (node, element) => {
+                const listingNode = findChildNodeOfType(node, node.type.schema.nodes.listing);
+                if (listingNode) {
+                    const { contents, languageKey } = listingNode.attrs;
+                    if (contents && languageKey) {
+                        const listing = this.document.createElement('fig');
+                        listing.setAttribute('specific-use', 'source');
+                        element.appendChild(listing);
+                        const code = this.document.createElement('code');
+                        code.setAttribute('executable', 'true');
+                        code.setAttribute('language', languageKey);
+                        code.textContent = contents;
+                        listing.appendChild(code);
+                        const caption = this.document.createElement('caption');
+                        listing.appendChild(caption);
+                        const attachments = [];
+                        for (const attachment of attachments) {
+                            const p = this.document.createElement('p');
+                            caption.appendChild(p);
+                            const filename = generateAttachmentFilename(`${listingNode.attrs.id}:${attachment.id}`, attachment.type);
+                            const supp = this.document.createElement('supplementary-material');
+                            supp.setAttributeNS(XLINK_NAMESPACE, 'xlink:href', `suppl/${filename}`);
+                            const [mimeType, mimeSubType] = attachment.type.split('/');
+                            if (mimeType) {
+                                supp.setAttribute('mimetype', mimeType);
+                                if (mimeSubType) {
+                                    supp.setAttribute('mime-subtype', mimeSubType);
+                                }
+                            }
+                            p.appendChild(supp);
+                        }
+                    }
+                }
+            };
+        };
+        this.serializeFragment = (fragment) => this.serializer.serializeFragment(fragment, {
+            document: this.document,
+        });
+        this.serializeNode = (node) => this.serializer.serializeNode(node, {
+            document: this.document,
+        });
+        this.validateContributor = (contributor) => {
+            if (!contributor.bibliographicName) {
+                throw new Error(`${contributor._id} has no bibliographicName`);
+            }
+            const { family, given } = contributor.bibliographicName;
+            if (!family && !given) {
+                throw new Error(`${contributor._id} has neither family nor given name`);
+            }
+        };
+        this.buildContributors = (articleMeta) => {
+            const contributors = this.models.filter(isContributor);
+            const authorContributors = contributors
+                .filter((contributor) => contributor.role === 'author')
+                .sort(sortContributors);
+            const affiliationLabels = new Map();
+            const creatAffiliationLabel = (rid) => {
+                let label = affiliationLabels.get(rid);
+                if (!label) {
+                    label = affiliationLabels.size + 1;
+                    affiliationLabels.set(rid, label);
+                }
+                const sup = this.document.createElement('sup');
+                sup.textContent = String(label);
+                return sup;
+            };
+            const createFootNotesLabels = (content) => {
+                const sup = this.document.createElement('sup');
+                sup.textContent = String(content);
+                return sup;
+            };
+            if (authorContributors.length) {
+                const contribGroup = this.document.createElement('contrib-group');
+                contribGroup.setAttribute('content-type', 'authors');
+                articleMeta.appendChild(contribGroup);
+                authorContributors.forEach((contributor) => {
+                    try {
+                        this.validateContributor(contributor);
+                    }
+                    catch (error) {
+                        warn(error.message);
+                        return;
+                    }
+                    const contrib = this.document.createElement('contrib');
+                    contrib.setAttribute('contrib-type', 'author');
+                    contrib.setAttribute('id', normalizeID(contributor._id));
+                    if (contributor.isCorresponding) {
+                        contrib.setAttribute('corresp', 'yes');
+                    }
+                    if (contributor.ORCIDIdentifier) {
+                        const identifier = this.document.createElement('contrib-id');
+                        identifier.setAttribute('contrib-id-type', 'orcid');
+                        identifier.textContent = contributor.ORCIDIdentifier;
+                        contrib.appendChild(identifier);
+                    }
+                    const name = this.buildContributorName(contributor);
+                    contrib.appendChild(name);
+                    if (contributor.email) {
+                        const email = this.document.createElement('email');
+                        email.textContent = contributor.email;
+                        contrib.appendChild(email);
+                    }
+                    if (contributor.roles) {
+                        contributor.roles.forEach((rid) => {
+                            const contributorRole = this.modelMap.get(rid);
+                            if (contributorRole) {
+                                const role = this.document.createElement('role');
+                                const attributes = chooseRoleVocabAttributes(contributorRole);
+                                for (const [key, value] of Object.entries(attributes)) {
+                                    role.setAttribute(key, value);
+                                }
+                                role.textContent = contributorRole.name;
+                                contrib.appendChild(role);
+                            }
+                        });
+                    }
+                    if (contributor.affiliations) {
+                        contributor.affiliations.forEach((rid) => {
+                            const xref = this.document.createElement('xref');
+                            xref.setAttribute('ref-type', 'aff');
+                            xref.setAttribute('rid', normalizeID(rid));
+                            xref.appendChild(creatAffiliationLabel(rid));
+                            contrib.appendChild(xref);
+                        });
+                    }
+                    if (contributor.footnote) {
+                        contributor.footnote.map((note) => {
+                            const xref = this.document.createElement('xref');
+                            xref.setAttribute('ref-type', 'fn');
+                            xref.setAttribute('rid', normalizeID(note.noteID));
+                            xref.appendChild(createFootNotesLabels(note.noteLabel));
+                            contrib.appendChild(xref);
+                        });
+                    }
+                    if (contributor.corresp) {
+                        contributor.corresp.map((corresp) => {
+                            const xref = this.document.createElement('xref');
+                            xref.setAttribute('ref-type', 'corresp');
+                            xref.setAttribute('rid', normalizeID(corresp.correspID));
+                            xref.appendChild(createFootNotesLabels(corresp.correspLabel));
+                            contrib.appendChild(xref);
+                        });
+                    }
+                    contribGroup.appendChild(contrib);
+                });
+                const otherContributors = contributors
+                    .filter((contributor) => contributor.role !== 'author')
+                    .sort(sortContributors);
+                if (otherContributors.length) {
+                    const contribGroup = this.document.createElement('contrib-group');
+                    articleMeta.appendChild(contribGroup);
+                    otherContributors.forEach((contributor) => {
+                        try {
+                            this.validateContributor(contributor);
+                        }
+                        catch (error) {
+                            warn(error.message);
+                            return;
+                        }
+                        const contrib = this.document.createElement('contrib');
+                        contrib.setAttribute('id', normalizeID(contributor._id));
+                        const name = this.buildContributorName(contributor);
+                        contrib.appendChild(name);
+                        if (contributor.email) {
+                            const email = this.document.createElement('email');
+                            email.textContent = contributor.email;
+                            contrib.appendChild(email);
+                        }
+                        if (contributor.roles) {
+                            contributor.roles.forEach((rid) => {
+                                const contributorRole = this.modelMap.get(rid);
+                                if (contributorRole) {
+                                    const role = this.document.createElement('role');
+                                    const attributes = chooseRoleVocabAttributes(contributorRole);
+                                    for (const [key, value] of Object.entries(attributes)) {
+                                        role.setAttribute(key, value);
+                                    }
+                                    role.textContent = contributorRole.name;
+                                    contrib.appendChild(role);
+                                }
+                            });
+                        }
+                        if (contributor.affiliations) {
+                            contributor.affiliations.forEach((rid) => {
+                                const xref = this.document.createElement('xref');
+                                xref.setAttribute('ref-type', 'aff');
+                                xref.setAttribute('rid', normalizeID(rid));
+                                xref.appendChild(creatAffiliationLabel(rid));
+                                contrib.appendChild(xref);
+                            });
+                        }
+                        if (contributor.footnote) {
+                            contributor.footnote.map((note) => {
+                                const xref = this.document.createElement('xref');
+                                xref.setAttribute('ref-type', 'fn');
+                                xref.setAttribute('rid', normalizeID(note.noteID));
+                                xref.appendChild(createFootNotesLabels(note.noteLabel));
+                                contrib.appendChild(xref);
+                            });
+                        }
+                        contribGroup.appendChild(contrib);
+                    });
+                }
+                const affiliationRIDs = [];
+                const sortedContributors = [...authorContributors, ...otherContributors];
+                for (const contributor of sortedContributors) {
+                    if (contributor.affiliations) {
+                        affiliationRIDs.push(...contributor.affiliations);
+                    }
+                }
+                const affiliations = this.models.filter(hasObjectType(ObjectTypes.Affiliation));
+                if (affiliations) {
+                    const usedAffiliations = affiliations.filter((affiliation) => affiliationRIDs.includes(affiliation._id));
+                    usedAffiliations.sort((a, b) => affiliationRIDs.indexOf(a._id) - affiliationRIDs.indexOf(b._id));
+                    usedAffiliations.forEach((affiliation) => {
+                        var _a, _b;
+                        const aff = this.document.createElement('aff');
+                        aff.setAttribute('id', normalizeID(affiliation._id));
+                        contribGroup.appendChild(aff);
+                        if (affiliation.department) {
+                            const department = this.document.createElement('institution');
+                            department.setAttribute('content-type', 'dept');
+                            department.textContent = affiliation.department;
+                            aff.appendChild(department);
+                        }
+                        if (affiliation.institution) {
+                            const institution = this.document.createElement('institution');
+                            institution.textContent = affiliation.institution;
+                            aff.appendChild(institution);
+                        }
+                        if (affiliation.addressLine1) {
+                            const addressLine = this.document.createElement('addr-line');
+                            addressLine.textContent = affiliation.addressLine1;
+                            aff.appendChild(addressLine);
+                        }
+                        if (affiliation.addressLine2) {
+                            const addressLine = this.document.createElement('addr-line');
+                            addressLine.textContent = affiliation.addressLine2;
+                            aff.appendChild(addressLine);
+                        }
+                        if (affiliation.addressLine3) {
+                            const addressLine = this.document.createElement('addr-line');
+                            addressLine.textContent = affiliation.addressLine3;
+                            aff.appendChild(addressLine);
+                        }
+                        if (affiliation.city) {
+                            const city = this.document.createElement('city');
+                            city.textContent = affiliation.city;
+                            aff.appendChild(city);
+                        }
+                        if (affiliation.country) {
+                            const country = this.document.createElement('country');
+                            country.textContent = affiliation.country;
+                            aff.appendChild(country);
+                        }
+                        if (affiliation.email) {
+                            const email = this.document.createElement('email');
+                            email.setAttributeNS(XLINK_NAMESPACE, 'href', (_a = affiliation.email.href) !== null && _a !== void 0 ? _a : '');
+                            email.textContent = (_b = affiliation.email.text) !== null && _b !== void 0 ? _b : '';
+                            aff.appendChild(email);
+                        }
+                        const labelNumber = affiliationLabels.get(affiliation._id);
+                        if (labelNumber) {
+                            const label = this.document.createElement('label');
+                            label.textContent = String(labelNumber);
+                            aff.appendChild(label);
+                        }
+                    });
+                }
+                const noteIDs = [];
+                for (const contributor of [...authorContributors, ...otherContributors]) {
+                    if (contributor.footnote) {
+                        const ids = contributor.footnote.map((note) => {
+                            return note.noteID;
+                        });
+                        noteIDs.push(...ids);
+                    }
+                    if (contributor.corresp) {
+                        const ids = contributor.corresp.map((corresp) => {
+                            return corresp.correspID;
+                        });
+                        noteIDs.push(...ids);
+                    }
+                }
+                const footnotes = [];
+                footnotes.push(...this.models.filter(hasObjectType(ObjectTypes.Footnote)));
+                const correspodings = [];
+                correspodings.push(...this.models.filter(hasObjectType(ObjectTypes.Corresponding)));
+                if (footnotes || correspodings) {
+                    const authorNotesEl = this.document.createElement('author-notes');
+                    const usedFootnotes = footnotes.filter((footnote) => {
+                        return noteIDs.includes(footnote._id);
+                    });
+                    const usedCorrespodings = correspodings.filter((corresp) => {
+                        return noteIDs.includes(corresp._id);
+                    });
+                    usedFootnotes.forEach((footnote) => {
+                        const authorFootNote = this.document.createElement('fn');
+                        authorFootNote.setAttribute('id', normalizeID(footnote._id));
+                        authorFootNote.innerHTML = footnote.contents;
+                        authorNotesEl.appendChild(authorFootNote);
+                    });
+                    usedCorrespodings.forEach((corresponding) => {
+                        const correspondingEl = this.document.createElement('corresp');
+                        correspondingEl.setAttribute('id', normalizeID(corresponding._id));
+                        if (corresponding.label) {
+                            const labelEl = this.document.createElement('label');
+                            labelEl.textContent = corresponding.label;
+                            correspondingEl.appendChild(labelEl);
+                        }
+                        correspondingEl.append(corresponding.contents);
+                        authorNotesEl.appendChild(correspondingEl);
+                    });
+                    if (authorNotesEl.childNodes.length > 0) {
+                        articleMeta.appendChild(authorNotesEl);
+                    }
+                }
+            }
+        };
+        this.fixBody = (body, fragment) => {
+            fragment.descendants((node) => {
+                if (node.attrs.id) {
+                    if (node.attrs.titleSuppressed) {
+                        const title = body.querySelector(`#${normalizeID(node.attrs.id)} > title`);
+                        if (title && title.parentNode) {
+                            title.parentNode.removeChild(title);
+                        }
+                    }
+                    if (node.attrs.suppressCaption) {
+                        const caption = body.querySelector(`#${normalizeID(node.attrs.id)} > caption`);
+                        if (caption) {
+                            caption.remove();
+                        }
+                        const label = body.querySelector(`#${normalizeID(node.attrs.id)} > label`);
+                        if (label) {
+                            label.remove();
+                        }
+                    }
+                    if (isNodeType(node, 'table_element')) {
+                        const tableElement = body.querySelector(`#${normalizeID(node.attrs.id)}`);
+                        if (tableElement) {
+                            for (const childNode of tableElement.childNodes) {
+                                switch (childNode.nodeName) {
+                                    case 'caption': {
+                                        if (node.attrs.suppressCaption) {
+                                            tableElement.removeChild(childNode);
+                                        }
+                                        else {
+                                            const label = tableElement.querySelector('label');
+                                            tableElement.insertBefore(childNode, label ? label.nextSibling : tableElement.firstChild);
+                                        }
+                                        break;
+                                    }
+                                    case 'table': {
+                                        this.fixTable(childNode, node);
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+        };
+        this.changeTag = (node, tag) => {
+            const clone = this.document.createElement(tag);
+            for (const attr of node.attributes) {
+                clone.setAttributeNS(null, attr.name, attr.value);
+            }
+            while (node.firstChild) {
+                clone.appendChild(node.firstChild);
+            }
+            node.replaceWith(clone);
+            return clone;
+        };
+        this.fixTable = (table, node) => {
+            let tbody;
+            Array.from(table.childNodes).forEach((child) => {
+                if (child instanceof Element && child.tagName.toLowerCase() === 'tbody') {
+                    tbody = child;
+                }
+            });
+            if (!tbody) {
+                return;
+            }
+            const tbodyRows = Array.from(tbody.childNodes);
+            const thead = this.document.createElement('thead');
+            const tfoot = this.document.createElement('tfoot');
+            tbodyRows.forEach((row, i) => {
+                const isRow = row instanceof Element && row.tagName.toLowerCase() === 'tr';
+                if (isRow) {
+                    const headerCell = row.querySelector('th[scope="col"], th[scope="colgroup"]');
+                    if (i === 0 || headerCell) {
+                        tbody === null || tbody === void 0 ? void 0 : tbody.removeChild(row);
+                        if (!node.attrs.suppressHeader) {
+                            const tableCells = row.querySelectorAll('td');
+                            for (const td of tableCells) {
+                                this.changeTag(td, 'th');
+                            }
+                            thead.appendChild(row);
+                        }
+                    }
+                    else if (i === tbodyRows.length - 1) {
+                        tbody === null || tbody === void 0 ? void 0 : tbody.removeChild(row);
+                        if (!node.attrs.suppressFooter) {
+                            tfoot.appendChild(row);
+                        }
+                    }
+                }
+            });
+            if (thead.hasChildNodes()) {
+                table.insertBefore(thead, tbody);
+            }
+            if (tfoot.hasChildNodes()) {
+                table.insertBefore(tfoot, tbody);
+            }
+        };
+        this.moveAbstracts = (front, body) => {
+            const sections = body.querySelectorAll(':scope > sec');
+            const abstractSections = Array.from(sections).filter((section) => {
+                const sectionType = section.getAttribute('sec-type');
+                if (sectionType === 'abstract' ||
+                    sectionType === 'abstract-teaser' ||
+                    sectionType === 'abstract-graphical') {
+                    return true;
+                }
+                const sectionTitle = section.querySelector(':scope > title');
+                if (!sectionTitle) {
+                    return false;
+                }
+                return sectionTitle.textContent === 'Abstract';
+            });
+            if (abstractSections.length) {
+                for (const abstractSection of abstractSections) {
+                    const abstractNode = this.document.createElement('abstract');
+                    for (const node of abstractSection.childNodes) {
+                        if (node.nodeName !== 'title') {
+                            abstractNode.appendChild(node.cloneNode(true));
+                        }
+                    }
+                    const sectionType = abstractSection.getAttribute('sec-type');
+                    if (sectionType && sectionType !== 'abstract') {
+                        const [, abstractType] = sectionType.split('-', 2);
+                        abstractNode.setAttribute('abstract-type', abstractType);
+                    }
+                    abstractSection.remove();
+                    const articleMeta = front.querySelector(':scope > article-meta');
+                    if (articleMeta) {
+                        insertAbstractNode(articleMeta, abstractNode);
+                    }
+                }
+            }
+        };
+        this.moveSectionsToBack = (back, body) => {
+            const availabilitySection = body.querySelector('sec[sec-type="availability"]');
+            if (availabilitySection) {
+                back.insertBefore(availabilitySection, back.firstChild);
+            }
+            const section = body.querySelector('sec[sec-type="acknowledgments"]');
+            if (section) {
+                const ack = this.document.createElement('ack');
+                while (section.firstChild) {
+                    ack.appendChild(section.firstChild);
+                }
+                if (section.parentNode) {
+                    section.parentNode.removeChild(section);
+                }
+                back.insertBefore(ack, back.firstChild);
+            }
+            const appendicesSections = body.querySelectorAll('sec[sec-type="appendices"]');
+            if (appendicesSections) {
+                const appGroup = this.document.createElement('app-group');
+                appendicesSections.forEach((section) => {
+                    if (section.parentNode) {
+                        section.parentNode.removeChild(section);
+                    }
+                    const app = this.document.createElement('app');
+                    app.appendChild(section);
+                    appGroup.appendChild(app);
+                });
+                back.insertBefore(appGroup, back.firstChild);
+            }
+            const footNotes = [];
+            const footnoteCategories = [
+                'con',
+                'conflict',
+                'deceased',
+                'equal',
+                'present-address',
+                'presented-at',
+                'previously-at',
+                'supplementary-material',
+                'supported-by',
+                'financial-disclosure',
+                'ethics-statement',
+                'competing-interests',
+            ];
+            const sections = body.querySelectorAll('sec');
+            for (const currentSection of sections) {
+                const currentSectionType = currentSection.getAttribute('sec-type');
+                if (currentSectionType &&
+                    footnoteCategories.indexOf(currentSectionType) >= 0) {
+                    footNotes.push(this.sectionToFootnote(currentSection, currentSectionType));
+                }
+            }
+            if (footNotes.length > 0) {
+                const fnGroup = this.document.createElement('fn-group');
+                fnGroup.append(...footNotes);
+                back.append(fnGroup);
+            }
+        };
+        this.sectionToFootnote = (section, fnType) => {
+            const footNote = this.document.createElement('fn');
+            footNote.setAttribute('fn-type', fnType);
+            const title = section.querySelector('title');
+            if (title) {
+                const footNoteTitle = this.document.createElement('p');
+                footNoteTitle.setAttribute('content-type', 'fn-title');
+                footNoteTitle.textContent = title.textContent;
+                section.removeChild(title);
+                footNote.append(footNoteTitle);
+            }
+            footNote.append(...section.children);
+            if (section.parentNode) {
+                section.parentNode.removeChild(section);
+            }
+            return footNote;
+        };
+        this.moveFloatsGroup = (body, article) => {
+            const floatsGroup = this.document.createElement('floats-group');
+            const section = body.querySelector('sec[sec-type="floating-element"]');
+            if (section) {
+                floatsGroup.append(...section.children);
+                if (section === null || section === void 0 ? void 0 : section.parentNode) {
+                    section.parentNode.removeChild(section);
+                }
+                article.appendChild(floatsGroup);
+            }
+        };
+        this.buildContributorName = (contributor) => {
+            const name = this.document.createElement('name');
+            if (contributor.bibliographicName.family) {
+                const surname = this.document.createElement('surname');
+                surname.textContent = contributor.bibliographicName.family;
+                name.appendChild(surname);
+            }
+            if (contributor.bibliographicName.given) {
+                const givenNames = this.document.createElement('given-names');
+                givenNames.textContent = contributor.bibliographicName.given;
+                name.appendChild(givenNames);
+            }
+            return name;
+        };
+    }
+    buildKeywords(articleMeta, keywordIDs) {
+        const keywords = keywordIDs
+            .map((id) => this.modelMap.get(id))
+            .filter((model) => model && model.name);
+        const keywordGroups = new Map();
+        keywords.forEach((keyword) => {
+            const containedGroup = keyword.containedGroup || '';
+            const group = keywordGroups.get(containedGroup);
+            if (group) {
+                group.push(keyword);
+            }
+            else {
+                keywordGroups.set(containedGroup, [keyword]);
+            }
+        });
+        for (const [groupID, keywords] of keywordGroups) {
+            const keywordGroup = (this.modelMap.get(groupID) || {});
+            const kwdGroup = this.document.createElement('kwd-group');
+            if (keywordGroup.type) {
+                kwdGroup.setAttribute('kwd-group-type', keywordGroup.type);
+            }
+            if (keywordGroup.label) {
+                const label = this.document.createElement('label');
+                label.textContent = keywordGroup.label;
+                kwdGroup.appendChild(label);
+            }
+            if (keywordGroup.title) {
+                const title = this.document.createElement('title');
+                title.textContent = keywordGroup.title;
+                kwdGroup.appendChild(title);
+            }
+            articleMeta.appendChild(kwdGroup);
+            for (const keyword of keywords) {
+                const kwd = this.document.createElement('kwd');
+                kwd.textContent = keyword.name;
+                kwdGroup.appendChild(kwd);
+            }
+        }
+    }
+}