@manuscripts/transform 3.0.67 → 3.0.68-LEAN-4574.2

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

@@ -13,26 +13,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ObjectTypes, } from '@manuscripts/json-schema';
-import { CitationProvider } from '@manuscripts/library';
-import debug from 'debug';
+import * as Citeproc from 'citeproc';
 import { DOMParser as ProsemirrorDOMParser, DOMSerializer, } from 'prosemirror-model';
 import { findChildrenByAttr, findChildrenByType } from 'prosemirror-utils';
 import serializeToXML from 'w3c-xmlserializer';
+import { buildCiteprocCitation } from '../../lib/citeproc';
 import { CRediTRoleUrls } from '../../lib/credit-roles';
 import { generateFootnoteLabels } from '../../lib/footnotes';
-import { nodeFromHTML, textFromHTML } from '../../lib/html';
-import { isCitationNode, isNodeOfType, schema, } from '../../schema';
+import { nodeFromHTML } from '../../lib/html';
+import { isBibliographyItemNode, isCitationNode, isNodeOfType, schema, } from '../../schema';
 import { isExecutableNodeType, isNodeType } from '../../transformer';
+import { initJats, jatsVariableWrapper } from './citeproc';
 import { selectVersionIds } from './jats-versions';
 import { buildTargets } from './labels';
-const publicationTypeToJats = {
-    article: 'journal',
-    'article-journal': 'journal',
-    webpage: 'web',
-    dataset: 'data',
-};
-const warn = debug('manuscripts-transform');
 const XLINK_NAMESPACE = 'http://www.w3.org/1999/xlink';
 const normalizeID = (id) => id.replace(/:/g, '_');
 const parser = ProsemirrorDOMParser.fromSchema(schema);
@@ -90,27 +83,8 @@ const chooseRefType = (type) => {
     }
 };
 const sortContributors = (a, b) => Number(a.attrs.priority) - Number(b.attrs.priority);
-export const buildCitations = (citations) => citations.map((citation) => ({
-    citationID: citation.attrs.id,
-    citationItems: citation.attrs.rids.map((rid) => ({
-        id: rid,
-    })),
-    properties: {
-        noteIndex: 0,
-    },
-}));
 export class JATSExporter {
     constructor() {
-        this.getLibraryItem = (manuscriptID) => {
-            return (id) => {
-                var _a;
-                const node = (_a = 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: ObjectTypes.BibliographyItem });
-            };
-        };
         this.nodesMap = new Map();
         this.populateNodesMap = () => {
             this.manuscriptNode.descendants((node) => {
@@ -125,7 +99,7 @@ export class JATSExporter {
             var _a;
             this.manuscriptNode = manuscriptNode;
             this.populateNodesMap();
-            this.generateCitationTexts(options.csl, manuscriptNode.attrs.id);
+            this.initCiteprocEngine(options.csl);
             this.createSerializer();
             const versionIds = 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));
@@ -152,6 +126,34 @@ export class JATSExporter {
             await this.rewriteIDs();
             return serializeToXML(this.document);
         };
+        this.initCiteprocEngine = (csl) => {
+            const bibitems = new Map();
+            const citations = new Map();
+            this.manuscriptNode.descendants((n) => {
+                if (isBibliographyItemNode(n)) {
+                    bibitems.set(n.attrs.id, n.attrs);
+                }
+                if (isCitationNode(n)) {
+                    citations.set(n.attrs.id, buildCiteprocCitation(n.attrs));
+                }
+            });
+            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: 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(' ', ' ');
@@ -406,139 +408,20 @@ export 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.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) {
@@ -660,35 +543,30 @@ export 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 = 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 = 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 = 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;
@@ -1078,7 +956,6 @@ export class JATSExporter {
                         this.validateContributor(contributor);
                     }
                     catch (error) {
-                        warn(error.message);
                         return;
                     }
                     const contrib = this.createElement('contrib');
@@ -1355,10 +1232,6 @@ export 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) => {
@@ -1504,27 +1377,6 @@ export class JATSExporter {
             return name;
         };
     }
-    generateCitations() {
-        const nodes = [];
-        this.manuscriptNode.descendants((node) => {
-            if (isCitationNode(node)) {
-                nodes.push(node);
-            }
-        });
-        return buildCitations(nodes);
-    }
-    generateCitationTexts(csl, manuscriptID) {
-        this.citationTexts = new Map();
-        this.citationProvider = new 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];
     }

package/dist/es/jats/importer/jats-dom-parser.js

@@ -13,10 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { buildBibliographicDate, buildBibliographicName, buildContribution, ObjectTypes, } from '@manuscripts/json-schema';
+import { buildContribution, ObjectTypes } from '@manuscripts/json-schema';
 import { DOMParser, Fragment } from 'prosemirror-model';
 import { dateToTimestamp, getCRediTRoleRole, getHTMLContent, getTrimmedTextContent, } from '../../lib/utils';
-import { publicationTypeToPM, } from '../../schema';
 import { DEFAULT_PROFILE_ID } from './jats-comments';
 export class JATSDOMParser {
     constructor(sectionCategories, schema) {
@@ -128,11 +127,22 @@ export class JATSDOMParser {
         this.getAddressLine = (element, index) => {
             return (getTrimmedTextContent(element, `addr-line:nth-of-type(${index})`) || '');
         };
-        this.choosePublicationType = (element) => {
-            var _a;
-            const citationElement = element.querySelector('element-citation, mixed-citation');
-            const type = citationElement === null || citationElement === void 0 ? void 0 : citationElement.getAttribute('publication-type');
-            return type ? (_a = publicationTypeToPM[type]) !== null && _a !== void 0 ? _a : type : 'article-journal';
+        this.getRefType = (element) => {
+            const citation = element.querySelector('element-citation, mixed-citation');
+            const type = citation === null || citation === void 0 ? void 0 : citation.getAttribute('publication-type');
+            if (!type) {
+                return 'article-journal';
+            }
+            switch (type) {
+                case 'journal':
+                    return 'article-journal';
+                case 'web':
+                    return 'webpage';
+                case 'data':
+                    return 'dataset';
+                default:
+                    return type;
+            }
         };
         this.getFigContent = (node) => {
             const element = node;
@@ -151,18 +161,6 @@ export class JATSDOMParser {
             }
             return Fragment.from(content);
         };
-        this.parseRefLiteral = (element) => {
-            var _a;
-            const mixedCitation = element.querySelector('mixed-citation');
-            const hasDirectTextNodeWithLetters = Array.from((_a = mixedCitation === null || mixedCitation === void 0 ? void 0 : mixedCitation.childNodes) !== null && _a !== void 0 ? _a : []).some((node) => {
-                var _a;
-                return node.nodeType === Node.TEXT_NODE &&
-                    ((_a = node.textContent) === null || _a === void 0 ? void 0 : _a.match(/[A-Za-z]+/g));
-            });
-            if (hasDirectTextNodeWithLetters) {
-                return getTrimmedTextContent(mixedCitation);
-            }
-        };
         this.parseRefPages = (element) => {
             const fpage = getTrimmedTextContent(element, 'fpage');
             const lpage = getTrimmedTextContent(element, 'lpage');
@@ -171,10 +169,9 @@ export class JATSDOMParser {
             }
         };
         this.parseRef = (element) => {
-            var _a, _b;
             return {
                 id: element.id,
-                type: this.choosePublicationType(element),
+                type: this.getRefType(element),
                 comment: getTrimmedTextContent(element, 'comment'),
                 volume: getTrimmedTextContent(element, 'volume'),
                 issue: getTrimmedTextContent(element, 'issue'),
@@ -192,23 +189,13 @@ export class JATSDOMParser {
                 institution: getTrimmedTextContent(element, 'institution'),
                 locator: getTrimmedTextContent(element, 'elocation-id'),
                 'container-title': getHTMLContent(element, 'source'),
-                title: (_b = (_a = getHTMLContent(element, 'article-title')) !== null && _a !== void 0 ? _a : getHTMLContent(element, 'data-title')) !== null && _b !== void 0 ? _b : getHTMLContent(element, 'part-title'),
-                author: this.getNameContent(element, 'person-group[person-group-type="author"] > *'),
-                editor: this.getNameContent(element, 'person-group[person-group-type="editor"] > *'),
-                literal: this.parseRefLiteral(element),
+                title: getHTMLContent(element, 'article-title, data-title, part-title'),
+                author: this.getNameContent(element, 'author'),
+                editor: this.getNameContent(element, 'editor'),
+                literal: getTrimmedTextContent(element, 'mixed-citation'),
                 accessed: this.getDateContent(element, 'date-in-citation'),
                 'event-date': this.getDateContent(element, 'conf-date'),
-                issued: getTrimmedTextContent(element.querySelector('element-citation, mixed-citation'), ':scope > year')
-                    ? buildBibliographicDate({
-                        'date-parts': [
-                            [
-                                getTrimmedTextContent(element.querySelector('element-citation, mixed-citation'), ':scope > year') || '',
-                                getTrimmedTextContent(element.querySelector('element-citation, mixed-citation'), ':scope > month') || '',
-                                getTrimmedTextContent(element.querySelector('element-citation, mixed-citation'), ':scope > day') || '',
-                            ],
-                        ],
-                    })
-                    : undefined,
+                issued: this.getIssuedDateContent(element),
                 page: this.parseRefPages(element),
             };
         };
@@ -1060,30 +1047,22 @@ export class JATSDOMParser {
             }
         }
     }
-    getNameContent(element, query) {
-        const buildName = (node) => {
-            const name = buildBibliographicName({});
-            const given = getTrimmedTextContent(node, 'given-names');
-            const family = getTrimmedTextContent(node, 'surname');
-            if (given) {
-                name.given = given;
-            }
-            if (family) {
-                name.family = family;
-            }
-            if (node.nodeName === 'collab') {
-                name.literal = getTrimmedTextContent(node);
-            }
-            return name;
-        };
-        const personNodes = element.querySelectorAll(query);
-        if (personNodes.length) {
-            return Array.from(personNodes).map(buildName);
+    getNameContent(element, type) {
+        const query = `person-group[person-group-type="${type}"] > *`;
+        const groups = [...element.querySelectorAll(query)];
+        if (!groups.length) {
+            return;
         }
+        return groups.map((node) => ({
+            given: getTrimmedTextContent(node, 'given-names'),
+            family: getTrimmedTextContent(node, 'surname'),
+            literal: node.nodeName === 'collab' ? getTrimmedTextContent(node) : undefined,
+        }));
     }
     getDateContent(element, query) {
-        const buildDate = (element) => {
-            const isoDate = element.getAttribute('iso-8601-date');
+        const date = element.querySelector(query);
+        if (date) {
+            const isoDate = date.getAttribute('iso-8601-date');
             if (!isoDate) {
                 return;
             }
@@ -1093,13 +1072,20 @@ export class JATSDOMParser {
                 parsedDate.getMonth() + 1,
                 parsedDate.getDate(),
             ];
-            return buildBibliographicDate({
+            return {
                 'date-parts': [parts],
-            });
-        };
-        const dateElement = element.querySelector(query);
-        if (dateElement) {
-            return buildDate(dateElement);
+            };
+        }
+    }
+    getIssuedDateContent(element) {
+        const year = getTrimmedTextContent(element, ':scope > * > year');
+        if (!year) {
+            return;
         }
+        const month = getTrimmedTextContent(element, ':scope > * > month');
+        const day = getTrimmedTextContent(element, ':scope > * > day');
+        return {
+            'date-parts': [[year, month !== null && month !== void 0 ? month : '', day !== null && day !== void 0 ? day : '']],
+        };
     }
 }

package/dist/es/lib/citeproc.js

@@ -0,0 +1,9 @@
+export const buildCiteprocCitation = (citation) => ({
+    citationID: citation.id,
+    citationItems: citation.rids.map((rid) => ({
+        id: rid,
+    })),
+    properties: {
+        noteIndex: 0,
+    },
+});

package/dist/es/schema/index.js

@@ -142,6 +142,7 @@ export * from './nodes/placeholder_element';
 export * from './nodes/pullquote_element';
 export * from './nodes/section';
 export * from './nodes/section_title';
+export * from './nodes/section_label';
 export * from './nodes/supplement';
 export * from './nodes/supplements';
 export * from './nodes/table';

package/dist/es/schema/nodes/bibliography_element.js

@@ -38,3 +38,4 @@ export const bibliographyElement = {
         return dom;
     },
 };
+export const isBibliographyElementNode = (node) => node.type === node.type.schema.nodes.bibliography_element;

package/dist/es/schema/nodes/bibliography_item.js

@@ -13,12 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export const publicationTypeToPM = {
-    journal: 'article-journal',
-    web: 'webpage',
-    data: 'dataset',
-    preprint: 'article-journal',
-};
 export const bibliographyItem = {
     content: 'inline{0}',
     attrs: {
@@ -55,3 +49,4 @@ export const bibliographyItem = {
     selectable: false,
     group: 'block',
 };
+export const isBibliographyItemNode = (node) => node.type === node.type.schema.nodes.bibliography_item;

package/dist/es/schema/nodes/comment.js

@@ -24,3 +24,4 @@ export const comment = {
         originalText: { default: '' },
     },
 };
+export const isCommentNode = (node) => node.type === node.type.schema.nodes.comment;

package/dist/es/schema/nodes/list.js

@@ -1,50 +1,11 @@
 import { ObjectTypes } from '@manuscripts/json-schema';
-export const getJatsListType = (cssStyle) => {
-    switch (cssStyle) {
-        case 'disc':
-            return 'bullet';
-        case 'decimal':
-            return 'order';
-        case 'lower-alpha':
-            return 'alpha-lower';
-        case 'upper-alpha':
-            return 'alpha-upper';
-        case 'lower-roman':
-            return 'roman-lower';
-        case 'upper-roman':
-            return 'roman-upper';
-        case 'simple':
-            return 'none';
-        default:
-            return 'none';
-    }
-};
-export const getListType = (style) => {
-    switch (style) {
-        case 'bullet':
-            return { type: 'ul', style: 'disc' };
-        case 'order':
-            return { type: 'ul', style: 'decimal' };
-        case 'alpha-lower':
-            return { type: 'ul', style: 'lower-alpha' };
-        case 'alpha-upper':
-            return { type: 'ul', style: 'upper-alpha' };
-        case 'roman-lower':
-            return { type: 'ul', style: 'lower-roman' };
-        case 'roman-upper':
-            return { type: 'ul', style: 'upper-roman' };
-        case 'simple':
-        default:
-            return { type: 'ul', style: 'none' };
-    }
-};
 export const list = {
     content: 'list_item+',
     group: 'block list element',
     attrs: {
         id: { default: '' },
-        dataTracked: { default: null },
         listStyleType: { default: null },
+        dataTracked: { default: null },
     },
     parseDOM: [
         {
@@ -70,9 +31,8 @@ export const list = {
     ],
     toDOM: (node) => {
         const list = node;
-        const { type } = getListType(list.attrs.listStyleType);
         return [
-            type,
+            'ul',
             {
                 id: list.attrs.id,
                 'list-type': list.attrs.listStyleType,

package/dist/es/version.js

@@ -1 +1 @@
-export const VERSION = "3.0.67";
+export const VERSION = "3.0.68-LEAN-4574.2";

package/dist/types/index.d.ts

@@ -5,8 +5,8 @@ export * from './jats/types';
 export * from './lib/footnotes';
 export * from './lib/utils';
 export * from './lib/section-categories';
+export * from './lib/citeproc';
 export * from './schema';
 export { migrateFor } from './schema/migration/migrate';
-export { isSectionLabelNode } from './schema/nodes/section_label';
 export * from './transformer';
 export * from './types';

package/dist/types/jats/exporter/citeproc.d.ts

@@ -0,0 +1,18 @@
+/*!
+ * © 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.
+ */
+import Citeproc from 'citeproc';
+export declare const initJats: () => void;
+export declare const jatsVariableWrapper: Citeproc.VariableWrapper;