@manuscripts/transform 3.0.66 → 3.0.68-LEAN-4574.2

package/dist/cjs/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSectionLabelNode = exports.migrateFor = exports.getVersion = void 0;
+exports.migrateFor = exports.getVersion = void 0;
 __exportStar(require("./errors"), exports);
 var getVersion_1 = require("./getVersion");
 Object.defineProperty(exports, "getVersion", { enumerable: true, get: function () { return getVersion_1.getVersion; } });
@@ -23,10 +23,9 @@ __exportStar(require("./jats/types"), exports);
 __exportStar(require("./lib/footnotes"), exports);
 __exportStar(require("./lib/utils"), exports);
 __exportStar(require("./lib/section-categories"), exports);
+__exportStar(require("./lib/citeproc"), exports);
 __exportStar(require("./schema"), exports);
 var migrate_1 = require("./schema/migration/migrate");
 Object.defineProperty(exports, "migrateFor", { enumerable: true, get: function () { return migrate_1.migrateFor; } });
-var section_label_1 = require("./schema/nodes/section_label");
-Object.defineProperty(exports, "isSectionLabelNode", { enumerable: true, get: function () { return section_label_1.isSectionLabelNode; } });
 __exportStar(require("./transformer"), exports);
 __exportStar(require("./types"), exports);

package/dist/cjs/jats/exporter/citeproc.js

@@ -0,0 +1,164 @@
+"use strict";
+/*!
+ * © 2025 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.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jatsVariableWrapper = exports.initJats = void 0;
+const citeproc_1 = __importDefault(require("citeproc"));
+const normalizeID = (id) => id.replace(/:/g, '_');
+const labelOnly = /^<label>.+<\/label>$/;
+const initJats = () => {
+    if (citeproc_1.default.Output.Formats.jats) {
+        return;
+    }
+    citeproc_1.default.Output.Formats.jats = Object.assign(Object.assign({}, citeproc_1.default.Output.Formats.html), { text_escape: function (text) {
+            return text !== null && text !== void 0 ? text : '';
+        }, bibstart: '<ref-list>', bibend: '</ref-list>', '@font-style/italic': '<italic>%%STRING%%</italic>', '@font-style/oblique': '<italic>%%STRING%%</italic>', '@font-style/normal': false, '@font-variant/small-caps': '<smallcaps>%%STRING%%</smallcaps>', '@font-variant/normal': false, '@font-weight/bold': '<bold>%%STRING%%</bold>', '@font-weight/normal': false, '@font-weight/light': false, '@text-decoration/none': false, '@text-decoration/underline': '<underline>%%STRING%%</underline>', '@vertical-align/sup': '<sup>%%STRING%%</sup>', '@vertical-align/sub': '<sub>%%STRING%%</sub>', '@vertical-align/baseline': false, '@bibliography/entry': function (state, str) {
+            const id = this.system_id;
+            const item = state.registry.registry[id].ref;
+            const type = getPublicationType(item);
+            str = str.trim();
+            if (labelOnly.test(str)) {
+                return `<ref id="${normalizeID(id)}">${str}<mixed-citation publication-type="${type}">${item.literal}</mixed-citation></ref>`;
+            }
+            else if (str.includes('mixed-citation')) {
+                return `<ref id="${normalizeID(id)}">${str.replace('%%TYPE%%', type)}</ref>`;
+            }
+            else {
+                return `<ref id="${normalizeID(id)}"><mixed-citation publication-type="${type}">${str}</mixed-citation></ref>`;
+            }
+        }, '@display/block': false, '@display/left-margin': function (state, str) {
+            return `<label>${str}</label>`;
+        }, '@display/right-inline': function (state, str) {
+            return `<mixed-citation publication-type="%%TYPE%%">${str}</mixed-citation>`;
+        }, '@display/indent': false, '@URL/true': false, '@DOI/true': false });
+    const name = citeproc_1.default.NameOutput.prototype._renderOnePersonalName;
+    citeproc_1.default.NameOutput.prototype._renderOnePersonalName = function (...args) {
+        const area = this.state.tmp.area;
+        const blob = name.call(this, ...args);
+        if (blob && area === 'bibliography') {
+            blob.strings.prefix = '<string-name>';
+            blob.strings.suffix = '</string-name>';
+        }
+        return blob;
+    };
+    const given = citeproc_1.default.NameOutput.prototype._givenName;
+    citeproc_1.default.NameOutput.prototype._givenName = function (...args) {
+        const area = this.state.tmp.area;
+        const info = given.call(this, ...args);
+        if (info.blob && area === 'bibliography') {
+            info.blob.strings.prefix = '<given-names>';
+            info.blob.strings.suffix = '</given-names>';
+        }
+        return info;
+    };
+    const family = citeproc_1.default.NameOutput.prototype._familyName;
+    citeproc_1.default.NameOutput.prototype._familyName = function (...args) {
+        const area = this.state.tmp.area;
+        const blob = family.call(this, ...args);
+        if (blob && area === 'bibliography') {
+            blob.strings.prefix = '<surname>';
+            blob.strings.suffix = '</surname>';
+        }
+        return blob;
+    };
+};
+exports.initJats = initJats;
+const namesWrapper = (type) => (str) => `<person-group person-group-type="${type}">${str}</person-group>`;
+const formatDate = (date) => {
+    let output = date.year;
+    if (date.month) {
+        output += '-' + String(date.month).padStart(2, '0');
+        if (date.day) {
+            output += '-' + String(date.day).padStart(2, '0');
+        }
+    }
+    return output;
+};
+const getPublicationType = (item) => {
+    switch (item.type) {
+        case 'article-journal':
+            return 'journal';
+        case 'webpage':
+            return 'page';
+        case 'dataset':
+            return 'data';
+        default:
+            return item.type;
+    }
+};
+const wrappers = {
+    author: namesWrapper('author'),
+    issued: (str, item) => str.replace(item.issued.year, `<year>${item.issued.year}</year>`),
+    'container-title': (str) => `<source>${str}</source>`,
+    volume: (str) => `<volume>${str}</volume>`,
+    issue: (str) => `<issue>${str}</issue>`,
+    supplement: (str) => `<supplement>${str}</supplement>`,
+    page: (str) => {
+        let fpage = str;
+        let lpage;
+        const parts = str.split('-');
+        if (parts.length === 2) {
+            fpage = parts[0];
+            lpage = parts[1];
+        }
+        str = str.replace(fpage, `<fpage>${fpage}</fpage>`);
+        if (lpage) {
+            str = str.replace(lpage, `<lpage>${lpage}</lpage>`);
+        }
+        return str;
+    },
+    title: (str, item) => {
+        const type = item.type;
+        switch (type) {
+            case 'dataset':
+                return `<data-title>${str}</data-title>`;
+            case 'article-journal':
+            case 'preprint':
+                return `<article-title>${str}</article-title>`;
+            default:
+                return `<part-title>${str}</part-title>`;
+        }
+    },
+    std: (str) => `<pub-id pub-id-type="std-designation">${str}</pub-id>`,
+    'collection-title': (str) => `<series>${str}</series>`,
+    edition: (str) => `<edition>${str}</edition>`,
+    publisher: (str) => `<publisher-name>${str}</publisher-name>`,
+    'publisher-place': (str) => `<publisher-loc>${str}</publisher-loc>`,
+    event: (str) => `<conf-name>${str}</conf-name>`,
+    'event-place': (str) => `<conf-loc>${str}</conf-loc>`,
+    'number-of-pages': (str) => `<size units="pages">${str}</size>`,
+    institution: (str) => `<institution>${str}</institution>`,
+    locator: (str) => `<elocation-id>${str}</elocation-id>`,
+    editor: namesWrapper('editor'),
+    accessed: (str, item) => `<date-in-citation content-type="access-date" iso-8601-date="${formatDate(item.accessed)}">${str}</date-in-citation>`,
+    'event-date': (str, item) => `<conf-date iso-8601-date="${formatDate(item['event-date'])}">${str}</conf-date>`,
+    DOI: (str) => `<pub-id pub-id-type="doi">${str}</pub-id>`,
+    URL: (str) => `<ext-link ext-link-type="uri" xlink:href="${str}">${str}</ext-link>`,
+};
+const jatsVariableWrapper = (params, pre, str, post) => {
+    if (str && params.context === 'bibliography') {
+        const name = params.variableNames[0];
+        const fn = wrappers[name];
+        if (fn) {
+            str = fn(str, params.itemData);
+        }
+    }
+    return `${pre}${str !== null && str !== void 0 ? str : ''}${post}`;
+};
+exports.jatsVariableWrapper = jatsVariableWrapper;

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

@@ -14,30 +14,47 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JATSExporter = exports.buildCitations = exports.createCounter = void 0;
-const json_schema_1 = require("@manuscripts/json-schema");
-const library_1 = require("@manuscripts/library");
-const debug_1 = __importDefault(require("debug"));
+exports.JATSExporter = exports.createCounter = void 0;
+const Citeproc = __importStar(require("citeproc"));
 const prosemirror_model_1 = require("prosemirror-model");
 const prosemirror_utils_1 = require("prosemirror-utils");
 const w3c_xmlserializer_1 = __importDefault(require("w3c-xmlserializer"));
+const citeproc_1 = require("../../lib/citeproc");
+const credit_roles_1 = require("../../lib/credit-roles");
 const footnotes_1 = require("../../lib/footnotes");
 const html_1 = require("../../lib/html");
 const schema_1 = require("../../schema");
 const transformer_1 = require("../../transformer");
+const citeproc_2 = require("./citeproc");
 const jats_versions_1 = require("./jats-versions");
 const labels_1 = require("./labels");
-const publicationTypeToJats = {
-    article: 'journal',
-    'article-journal': 'journal',
-    webpage: 'web',
-    dataset: 'data',
-};
-const warn = (0, debug_1.default)('manuscripts-transform');
 const XLINK_NAMESPACE = 'http://www.w3.org/1999/xlink';
 const normalizeID = (id) => id.replace(/:/g, '_');
 const parser = prosemirror_model_1.DOMParser.fromSchema(schema_1.schema);
@@ -96,28 +113,8 @@ const chooseRefType = (type) => {
     }
 };
 const sortContributors = (a, b) => Number(a.attrs.priority) - Number(b.attrs.priority);
-const buildCitations = (citations) => citations.map((citation) => ({
-    citationID: citation.attrs.id,
-    citationItems: citation.attrs.rids.map((rid) => ({
-        id: rid,
-    })),
-    properties: {
-        noteIndex: 0,
-    },
-}));
-exports.buildCitations = buildCitations;
 class JATSExporter {
     constructor() {
-        this.getLibraryItem = (manuscriptID) => {
-            return (id) => {
-                var _a;
-                const node = (_a = (0, prosemirror_utils_1.findChildrenByAttr)(this.manuscriptNode, (attrs) => attrs.id === id)[0]) === null || _a === void 0 ? void 0 : _a.node;
-                if (!node) {
-                    return undefined;
-                }
-                return Object.assign(Object.assign({}, node.attrs), { _id: node.attrs.id, manuscriptID, objectType: json_schema_1.ObjectTypes.BibliographyItem });
-            };
-        };
         this.nodesMap = new Map();
         this.populateNodesMap = () => {
             this.manuscriptNode.descendants((node) => {
@@ -132,7 +129,7 @@ class JATSExporter {
             var _a;
             this.manuscriptNode = manuscriptNode;
             this.populateNodesMap();
-            this.generateCitationTexts(options.csl, manuscriptNode.attrs.id);
+            this.initCiteprocEngine(options.csl);
             this.createSerializer();
             const versionIds = (0, jats_versions_1.selectVersionIds)((_a = options.version) !== null && _a !== void 0 ? _a : '1.2');
             this.document = document.implementation.createDocument(null, 'article', document.implementation.createDocumentType('article', versionIds.publicId, versionIds.systemId));
@@ -159,6 +156,34 @@ class JATSExporter {
             await this.rewriteIDs();
             return (0, w3c_xmlserializer_1.default)(this.document);
         };
+        this.initCiteprocEngine = (csl) => {
+            const bibitems = new Map();
+            const citations = new Map();
+            this.manuscriptNode.descendants((n) => {
+                if ((0, schema_1.isBibliographyItemNode)(n)) {
+                    bibitems.set(n.attrs.id, n.attrs);
+                }
+                if ((0, schema_1.isCitationNode)(n)) {
+                    citations.set(n.attrs.id, (0, citeproc_1.buildCiteprocCitation)(n.attrs));
+                }
+            });
+            (0, citeproc_2.initJats)();
+            const engine = new Citeproc.Engine({
+                retrieveLocale: () => csl.locale,
+                retrieveItem: (id) => {
+                    const item = bibitems.get(id);
+                    if (!item) {
+                        throw Error(`Missing bibliography item with id ${id}`);
+                    }
+                    return item;
+                },
+                variableWrapper: citeproc_2.jatsVariableWrapper,
+            }, csl.style);
+            engine.setOutputFormat('jats');
+            const output = engine.rebuildProcessorState([...citations.values()]);
+            this.engine = engine;
+            this.renderedCitations = new Map(output.map((i) => [i[0], i[2]]));
+        };
         this.nodeFromJATS = (JATSFragment) => {
             JATSFragment = JATSFragment.trim();
             JATSFragment = JATSFragment.replace(' ', ' ');
@@ -413,139 +438,20 @@ class JATSExporter {
             }
             let refList = this.document.querySelector('ref-list');
             if (!refList) {
-                warn('No bibliography element, creating a ref-list anyway');
                 refList = this.createElement('ref-list');
             }
             back.appendChild(refList);
-            const bibliographyItems = this.getChildrenOfType(schema_1.schema.nodes.bibliography_item);
-            const [meta] = this.citationProvider.makeBibliography();
-            for (const [id] of meta.entry_ids) {
-                const bibliographyItem = bibliographyItems.find((n) => n.attrs.id === id);
-                if (!bibliographyItem) {
-                    continue;
+            const parser = new DOMParser();
+            const [_, bibliography] = this.engine.makeBibliography();
+            for (let i = 0; i < bibliography.length; i++) {
+                const item = `<template xmlns:xlink="${XLINK_NAMESPACE}">${bibliography[i]}</template>`;
+                const ref = parser.parseFromString(item, 'text/xml').querySelector('ref');
+                if (ref) {
+                    refList.appendChild(ref);
                 }
-                const ref = this.createElement('ref');
-                ref.setAttribute('id', normalizeID(id));
-                const getPublicationType = (pubType) => publicationTypeToJats[pubType !== null && pubType !== void 0 ? pubType : ''] || pubType || 'journal';
-                if (bibliographyItem.attrs.literal) {
-                    this.appendElement(ref, 'mixed-citation', bibliographyItem.attrs.literal, {
-                        'publication-type': getPublicationType(bibliographyItem.attrs.type),
-                    });
-                }
-                else {
-                    const citation = this.appendElement(ref, 'element-citation', undefined, {
-                        'publication-type': getPublicationType(bibliographyItem.attrs.type),
-                    });
-                    const attributeHandlers = {
-                        author: (v) => this.processRefPersonGroup(citation, 'author', v),
-                        editor: (v) => this.processRefPersonGroup(citation, 'editor', v),
-                        title: (v) => this.setTitleContent(this.appendElement(citation, 'article-title'), v),
-                        comment: (v) => this.appendElement(citation, 'comment', v),
-                        'container-title': (v) => this.setTitleContent(this.appendElement(citation, 'source'), v),
-                        issued: ({ 'date-parts': parts }) => this.processDateParts(citation, parts),
-                        volume: (v) => this.appendElement(citation, 'volume', v),
-                        issue: (v) => this.appendElement(citation, 'issue', v),
-                        supplement: (v) => this.appendElement(citation, 'supplement', v),
-                        page: (v) => this.processPageString(citation, String(v)),
-                        DOI: (v) => this.appendElement(citation, 'pub-id', v, { 'pub-id-type': 'doi' }),
-                        std: (v) => this.appendElement(citation, 'pub-id', v, {
-                            'pub-id-type': 'std-designation',
-                        }),
-                        'collection-title': (v) => this.appendElement(citation, 'series', v),
-                        edition: (v) => this.appendElement(citation, 'edition', v),
-                        'publisher-place': (v) => this.appendElement(citation, 'publisher-loc', v),
-                        publisher: (v) => this.appendElement(citation, 'publisher-name', v),
-                        event: (v) => this.appendElement(citation, 'conf-name', v),
-                        'event-place': (v) => this.appendElement(citation, 'conf-loc', v),
-                        'number-of-pages': (v) => this.appendElement(citation, 'size', v, { units: 'pages' }),
-                        institution: (v) => this.appendElement(citation, 'institution', v),
-                        locator: (v) => this.appendElement(citation, 'elocation-id', v),
-                        URL: (v) => this.appendElement(citation, 'ext-link', v, {
-                            'ext-link-type': 'uri',
-                        }),
-                        'event-date': (v) => this.processDate(citation, 'conf-date', v),
-                        accessed: (v) => this.processDate(citation, 'date-in-citation', v),
-                    };
-                    Object.entries(attributeHandlers).forEach(([key, handler]) => {
-                        const value = bibliographyItem.attrs[key];
-                        if (value) {
-                            handler(value);
-                        }
-                    });
-                }
-                refList.appendChild(ref);
             }
             return back;
         };
-        this.processDateParts = (parent, dateParts) => {
-            const [[year, month, day]] = dateParts;
-            if (year) {
-                this.appendElement(parent, 'year', String(year));
-            }
-            if (month) {
-                this.appendElement(parent, 'month', String(month));
-            }
-            if (day) {
-                this.appendElement(parent, 'day', String(day));
-            }
-        };
-        this.processPageString = (parent, page) => {
-            const numPattern = /^\d+$/;
-            const rangePattern = /^(\d+)-(\d+)$/;
-            if (numPattern.test(page)) {
-                this.appendElement(parent, 'fpage', page);
-            }
-            else if (rangePattern.test(page)) {
-                const [fpage, lpage] = page.split('-');
-                this.appendElement(parent, 'fpage', fpage);
-                this.appendElement(parent, 'lpage', lpage);
-            }
-            else {
-                this.appendElement(parent, 'page-range', page);
-            }
-        };
-        this.processDate = (parent, tag, date) => {
-            const buildISODate = (date) => {
-                const dateParts = date['date-parts'];
-                if (dateParts && dateParts.length) {
-                    const [[year, month, day]] = dateParts;
-                    if (year && month && day) {
-                        return new Date(Date.UTC(Number(year), Number(month) - 1, Number(day)));
-                    }
-                }
-            };
-            const isoDate = buildISODate(date);
-            if (!isoDate) {
-                return;
-            }
-            return this.appendElement(parent, tag, isoDate.toDateString(), {
-                'iso-8601-date': isoDate.toISOString(),
-            });
-        };
-        this.processRefPersonGroup = (citation, type, people) => {
-            if (!(people === null || people === void 0 ? void 0 : people.length)) {
-                return;
-            }
-            const group = this.appendElement(citation, 'person-group', undefined, {
-                'person-group-type': type,
-            });
-            people.forEach((person) => {
-                if (person.literal) {
-                    this.appendElement(group, 'collab', person.literal);
-                    return;
-                }
-                const name = this.createElement('string-name');
-                if (person.family) {
-                    this.appendElement(name, 'surname', person.family);
-                }
-                if (person.given) {
-                    this.appendElement(name, 'given-names', person.given);
-                }
-                if (name.childNodes.length) {
-                    group.appendChild(name);
-                }
-            });
-        };
         this.createElement = (tag, content, attrs) => {
             const el = this.document.createElement(tag);
             if (content) {
@@ -667,35 +573,30 @@ class JATSExporter {
                     const xref = this.createElement('xref');
                     xref.setAttribute('ref-type', 'bibr');
                     xref.setAttribute('rid', normalizeID(rids.join(' ')));
-                    const citationTextContent = this.citationTexts.get(node.attrs.id);
-                    if (!citationTextContent) {
-                        throw new Error(`No citation text found for ${node.attrs.id}`);
+                    const fragment = this.renderedCitations.get(node.attrs.id);
+                    if (fragment) {
+                        xref.innerHTML = fragment;
                     }
-                    xref.textContent = (0, html_1.textFromHTML)(citationTextContent);
                     return xref;
                 },
                 cross_reference: (node) => {
-                    var _a, _b, _c;
+                    var _a, _b, _c, _d;
                     const cross = node;
                     const rids = cross.attrs.rids;
                     if (!rids.length) {
                         return (_a = cross.attrs.label) !== null && _a !== void 0 ? _a : '';
                     }
                     const rid = rids[0];
-                    const text = cross.attrs.label || ((_b = this.labelTargets.get(rid)) === null || _b === void 0 ? void 0 : _b.label);
-                    const target = (_c = (0, prosemirror_utils_1.findChildrenByAttr)(this.manuscriptNode, (attrs) => attrs.id === rid)[0]) === null || _c === void 0 ? void 0 : _c.node;
+                    const text = (_b = cross.attrs.label) !== null && _b !== void 0 ? _b : (_c = this.labelTargets.get(rid)) === null || _c === void 0 ? void 0 : _c.label;
+                    const target = (_d = (0, prosemirror_utils_1.findChildrenByAttr)(this.manuscriptNode, (attrs) => attrs.id === rid)[0]) === null || _d === void 0 ? void 0 : _d.node;
                     if (!target) {
-                        warn('');
-                        return text || '';
+                        return text !== null && text !== void 0 ? text : '';
                     }
                     const xref = this.createElement('xref');
                     const type = chooseRefType(target.type);
                     if (type) {
                         xref.setAttribute('ref-type', type);
                     }
-                    else {
-                        warn(`Unset ref-type for schema type ${target.type.name}`);
-                    }
                     xref.setAttribute('rid', normalizeID(rids.join(' ')));
                     xref.textContent = text !== null && text !== void 0 ? text : '';
                     return xref;
@@ -1085,7 +986,6 @@ class JATSExporter {
                         this.validateContributor(contributor);
                     }
                     catch (error) {
-                        warn(error.message);
                         return;
                     }
                     const contrib = this.createElement('contrib');
@@ -1135,6 +1035,20 @@ class JATSExporter {
                             contrib.appendChild(xref);
                         });
                     }
+                    if (contributor.attrs.CRediTRoles) {
+                        contributor.attrs.CRediTRoles.forEach((cr) => {
+                            const role = this.createElement('role');
+                            const creditUrl = credit_roles_1.CRediTRoleUrls.get(cr.vocabTerm);
+                            if (creditUrl) {
+                                role.setAttribute('vocab-identifier', 'http://credit.niso.org/');
+                                role.setAttribute('vocab', 'CRediT');
+                                role.setAttribute('vocab-term', cr.vocabTerm);
+                                role.setAttribute('vocab-term-identifier', creditUrl);
+                                role.innerHTML = cr.vocabTerm;
+                            }
+                            contrib.appendChild(role);
+                        });
+                    }
                     contribGroup.appendChild(contrib);
                 });
                 const affiliationRIDs = [];
@@ -1348,10 +1262,6 @@ class JATSExporter {
             if (!container) {
                 return;
             }
-            const isContainerEmpty = container.children.length === 0;
-            if (!isContainerEmpty) {
-                warn('Backmatter section is not empty.');
-            }
             body.removeChild(container);
         };
         this.moveAwards = (front, body) => {
@@ -1497,27 +1407,6 @@ class JATSExporter {
             return name;
         };
     }
-    generateCitations() {
-        const nodes = [];
-        this.manuscriptNode.descendants((node) => {
-            if ((0, schema_1.isCitationNode)(node)) {
-                nodes.push(node);
-            }
-        });
-        return (0, exports.buildCitations)(nodes);
-    }
-    generateCitationTexts(csl, manuscriptID) {
-        this.citationTexts = new Map();
-        this.citationProvider = new library_1.CitationProvider({
-            getLibraryItem: this.getLibraryItem(manuscriptID),
-            locale: csl.locale,
-            citationStyle: csl.style,
-        });
-        const citations = this.generateCitations();
-        this.citationProvider.rebuildState(citations).forEach(([id, , output]) => {
-            this.citationTexts.set(id, output);
-        });
-    }
     getFirstChildOfType(type, node) {
         return this.getChildrenOfType(type, node)[0];
     }