@manuscripts/transform 2.10.0-LEAN-3577 → 3.0.0

package/dist/es/jats/importer/jats-transformations.js

@@ -0,0 +1,370 @@
+/*!
+ * © 2020 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 { defaultTitle } from '../../lib/deafults';
+import { abstractsType, backmatterType, bodyType, } from '../../lib/section-group-type';
+import { chooseSectionCategoryByType, chooseSecType } from '../../transformer';
+import { htmlFromJatsNode } from './jats-parser-utils';
+const removeNodeFromParent = (node) => node.parentNode && node.parentNode.removeChild(node);
+const capitalizeFirstLetter = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+const createSectionGroup = (type, createElement) => {
+    const sec = createElement('sec');
+    sec.setAttribute('sec-type', type._id);
+    const title = createElement('title');
+    title.textContent = type.title;
+    sec.appendChild(title);
+    return sec;
+};
+export const ensureSection = (body, createElement) => {
+    let section;
+    const element = body.firstElementChild;
+    if (element && element.tagName === 'sec') {
+        section = element;
+    }
+    else {
+        section = createElement('sec');
+        body.insertBefore(section, body.firstChild);
+    }
+    body.childNodes.forEach((child) => {
+        if (child.nodeType === Node.ELEMENT_NODE) {
+            const element = child;
+            if (element.tagName !== 'sec') {
+                section.appendChild(element);
+            }
+            else {
+                section = element;
+            }
+        }
+    });
+};
+export const moveTitle = (front, createElement) => {
+    var _a, _b;
+    let title = front.querySelector('article-meta > title-group > article-title');
+    if (title) {
+        title.innerHTML = (_a = htmlFromJatsNode(title, createElement)) !== null && _a !== void 0 ? _a : defaultTitle;
+    }
+    else {
+        title = createElement('article-title');
+        title.innerHTML = defaultTitle;
+    }
+    (_b = front.parentNode) === null || _b === void 0 ? void 0 : _b.insertBefore(title, front);
+};
+export const moveAuthorNotes = (front, createElement) => {
+    var _a;
+    const authorNotes = front.querySelector('article-meta > author-notes');
+    if (authorNotes) {
+        const sectionTitle = createElement('title');
+        authorNotes.prepend(sectionTitle);
+        (_a = front.parentNode) === null || _a === void 0 ? void 0 : _a.insertBefore(authorNotes, front);
+    }
+};
+export const moveContributors = (front, createElement) => {
+    var _a;
+    const contribs = front.querySelectorAll('contrib-group > contrib[contrib-type="author"]');
+    if (contribs.length) {
+        const contributors = createElement('contributors');
+        contribs.forEach((c) => contributors.appendChild(c));
+        (_a = front.parentNode) === null || _a === void 0 ? void 0 : _a.insertBefore(contributors, front);
+    }
+};
+export const moveAffiliations = (front, createElement) => {
+    var _a;
+    const affs = front.querySelectorAll('article-meta > contrib-group > aff');
+    if (affs.length) {
+        const affiliations = createElement('affiliations');
+        affs.forEach((a) => affiliations.appendChild(a));
+        (_a = front.parentNode) === null || _a === void 0 ? void 0 : _a.insertBefore(affiliations, front);
+    }
+};
+export const moveAbstracts = (doc, group, createElement) => {
+    const abstracts = doc.querySelectorAll('front > article-meta > abstract');
+    abstracts.forEach((abstract) => {
+        const sec = createAbstractSection(abstract, createElement);
+        removeNodeFromParent(abstract);
+        group.appendChild(sec);
+    });
+};
+export const createBoxedElementSection = (body, createElement) => {
+    const boxedTexts = body.querySelectorAll('boxed-text');
+    for (const boxedText of boxedTexts) {
+        const boxElementSec = createElement('sec');
+        boxElementSec.setAttribute('sec-type', 'box-element');
+        const title = createElement('title');
+        title.textContent = 'BoxElement';
+        boxElementSec.append(title);
+        for (const element of [...boxedText.children]) {
+            if ((element === null || element === void 0 ? void 0 : element.tagName) === 'label' || (element === null || element === void 0 ? void 0 : element.tagName) === 'caption') {
+                boxElementSec.append(element);
+            }
+        }
+        const containerSection = createElement('sec');
+        containerSection.append(...boxedText.children);
+        boxElementSec.append(containerSection);
+        boxedText.replaceWith(boxElementSec);
+    }
+};
+export const createBody = (doc, body, createElement) => {
+    const group = createSectionGroup(bodyType, createElement);
+    const sections = doc.querySelectorAll('body > sec:not([sec-type="backmatter"]), body > sec:not([sec-type])');
+    sections.forEach((section) => {
+        removeNodeFromParent(section);
+        group.appendChild(section);
+    });
+    moveFloatsGroupToBody(doc, group, createElement);
+    body.append(group);
+};
+export const createAbstracts = (doc, body, createElement) => {
+    const group = createSectionGroup(abstractsType, createElement);
+    moveAbstracts(doc, group, createElement);
+    body.insertBefore(group, body.lastElementChild);
+};
+export const createBackmatter = (doc, body, createElement) => {
+    const group = createSectionGroup(backmatterType, createElement);
+    moveBackSections(doc, group);
+    moveAppendices(doc, group, createElement);
+    moveSpecialFootnotes(doc, group, createElement);
+    moveFootnotes(doc, group, createElement);
+    moveAcknowledgments(doc, group, createElement);
+    body.append(group);
+};
+const moveFootnotes = (doc, group, createElement) => {
+    var _a;
+    const fns = [
+        ...doc.querySelectorAll('fn:not(table-wrap-foot fn, author-notes fn)'),
+    ];
+    let section = doc.querySelector('sec[sec-type="endnotes"]');
+    const fnGroup = (section === null || section === void 0 ? void 0 : section.querySelector('fn-group')) || createElement('fn-group');
+    fns.forEach((fn) => {
+        if (!fn.getAttribute('fn-type')) {
+            fnGroup.appendChild(fn);
+        }
+    });
+    if (!section && fnGroup.innerHTML) {
+        section = createFootnotesSection([fnGroup], createElement);
+    }
+    if (section) {
+        group.insertBefore(section, ((_a = group.firstChild) === null || _a === void 0 ? void 0 : _a.nextSibling) || group.firstChild);
+    }
+};
+const moveSpecialFootnotes = (doc, group, createElement) => {
+    var _a;
+    const fns = [...doc.querySelectorAll('fn[fn-type]')];
+    for (const fn of fns) {
+        const type = fn.getAttribute('fn-type') || '';
+        const category = chooseSectionCategoryByType(type);
+        if (category) {
+            const section = createElement('sec');
+            const fnTitle = fn.querySelector('p[content-type="fn-title"]');
+            if (fnTitle) {
+                const title = createElement('title');
+                const titleText = (_a = fnTitle.textContent) === null || _a === void 0 ? void 0 : _a.trim();
+                if (titleText) {
+                    title.textContent = titleText;
+                }
+                removeNodeFromParent(fnTitle);
+                section.append(title);
+            }
+            section.append(...fn.children);
+            removeNodeFromParent(fn);
+            section.setAttribute('sec-type', chooseSecType(category));
+            group.append(section);
+        }
+    }
+};
+export const moveCaptionsToEnd = (body) => {
+    const captions = body.querySelectorAll('caption');
+    for (const caption of captions) {
+        if (caption.parentNode &&
+            caption.parentNode.nodeName !== 'table-wrap' &&
+            caption.parentNode.nodeName !== 'boxed-text') {
+            caption.parentNode.appendChild(caption);
+        }
+    }
+};
+const createAbstractSection = (abstract, createElement) => {
+    const abstractType = abstract.getAttribute('abstract-type');
+    const section = createElement('sec');
+    const sectionType = abstractType ? `abstract-${abstractType}` : 'abstract';
+    section.setAttribute('sec-type', sectionType);
+    if (!abstract.querySelector(':scope > title')) {
+        const title = createElement('title');
+        title.textContent = abstractType
+            ? `${capitalizeFirstLetter(abstractType)} Abstract`
+            : 'Abstract';
+        section.appendChild(title);
+    }
+    while (abstract.firstChild) {
+        section.appendChild(abstract.firstChild);
+    }
+    return section;
+};
+const createAcknowledgmentsSection = (ack, createElement) => {
+    const section = createElement('sec');
+    section.setAttribute('sec-type', 'acknowledgments');
+    if (!ack.querySelector('title')) {
+        const title = createElement('title');
+        title.textContent = 'Acknowledgements';
+        section.appendChild(title);
+    }
+    while (ack.firstChild) {
+        section.appendChild(ack.firstChild);
+    }
+    return section;
+};
+const createFootnotesSection = (fnGroups, createElement) => {
+    const section = createElement('sec');
+    section.setAttribute('sec-type', 'endnotes');
+    const titleNode = fnGroups
+        .map((g) => g.querySelector('title'))
+        .filter((t) => t !== null)[0];
+    if (titleNode) {
+        section.appendChild(titleNode);
+    }
+    else {
+        const title = createElement('title');
+        title.textContent = 'Footnotes';
+        section.appendChild(title);
+    }
+    for (const fnGroup of fnGroups) {
+        section.appendChild(fnGroup);
+    }
+    return section;
+};
+const createAppendicesSection = (app, createElement) => {
+    const section = createElement('sec');
+    section.setAttribute('sec-type', 'appendices');
+    section.append(...app.children);
+    return section;
+};
+const createFloatsGroupSection = (floatsGroup, createElement) => {
+    const section = createElement('sec');
+    section.setAttribute('sec-type', 'floating-element');
+    const title = createElement('title');
+    title.textContent = 'Floating Group';
+    section.appendChild(title);
+    section.append(...floatsGroup.children);
+    return section;
+};
+const moveBackSections = (doc, group) => {
+    for (const section of doc.querySelectorAll('back > sec')) {
+        removeNodeFromParent(section);
+        group.appendChild(section);
+    }
+};
+const moveAcknowledgments = (doc, group, createElement) => {
+    const ack = doc.querySelector('back > ack');
+    if (ack) {
+        const section = createAcknowledgmentsSection(ack, createElement);
+        removeNodeFromParent(ack);
+        group.appendChild(section);
+    }
+};
+const moveAppendices = (doc, group, createElement) => {
+    const apps = doc.querySelectorAll('back > app-group > app');
+    for (const app of apps) {
+        const section = createAppendicesSection(app, createElement);
+        removeNodeFromParent(app);
+        group.appendChild(section);
+    }
+};
+const moveFloatsGroupToBody = (doc, body, createElement) => {
+    const floatsGroup = doc.querySelector('floats-group');
+    if (floatsGroup) {
+        const sec = createFloatsGroupSection(floatsGroup, createElement);
+        removeNodeFromParent(floatsGroup);
+        body.appendChild(sec);
+    }
+};
+export const createKeywordsSection = (document, body, createElement) => {
+    const kwdGroups = [...document.querySelectorAll('kwd-group')];
+    if (kwdGroups.length > 0) {
+        const section = createElement('sec');
+        section.setAttribute('sec-type', 'keywords');
+        const title = createElement('title');
+        title.textContent = 'Keywords';
+        section.append(title);
+        const kwdGroupList = createElement('kwd-group-list');
+        kwdGroupList.append(kwdGroups[0]);
+        section.append(kwdGroupList);
+        body.prepend(section);
+    }
+};
+export const createSupplementaryMaterialsSection = (document, body, createElement) => {
+    const suppls = [
+        ...document.querySelectorAll('article-meta > supplementary-material'),
+    ];
+    if (suppls.length) {
+        const section = createElement('sec');
+        section.setAttribute('sec-type', 'supplementary-material');
+        const title = createElement('title');
+        title.textContent = 'Supplementary Material';
+        section.append(title);
+        section.append(...suppls);
+        body.prepend(section);
+    }
+};
+export const moveReferencesToBackmatter = (body, back, createElement) => {
+    const backmatter = body.querySelector('sec[sec-type="backmatter"]');
+    const refList = back.querySelector('ref-list');
+    if (!backmatter || !refList) {
+        return;
+    }
+    removeNodeFromParent(refList);
+    const section = createElement('sec');
+    section.setAttribute('sec-type', 'bibliography');
+    const title = createElement('title');
+    title.textContent = 'References';
+    section.appendChild(title);
+    section.appendChild(refList);
+    backmatter.appendChild(section);
+};
+export const orderTableFootnote = (doc, body) => {
+    const rids = new Set([...body.querySelectorAll('tbody > xref[ref-type="fn"]')].map((xref) => xref.getAttribute('rid')));
+    const fnGroups = doc.querySelectorAll('table-wrap-foot > fn-group');
+    fnGroups.forEach((fnGroup) => {
+        const fns = [...fnGroup.querySelectorAll('fn')].sort((fn) => rids.has(fn.getAttribute('id')) ? -1 : 0);
+        fnGroup.replaceChildren(...fns);
+    });
+};
+export const fixTables = (doc, body, createElement) => {
+    const tableWraps = body.querySelectorAll('table-wrap');
+    tableWraps.forEach((tableWrap) => {
+        const table = tableWrap.querySelector('table');
+        if (!table) {
+            return;
+        }
+        const colgroup = table.querySelector('colgroup');
+        const cols = table.querySelectorAll('col');
+        if (!colgroup && table.firstChild && cols.length > 0) {
+            const colgroup = createElement('colgroup');
+            for (const col of cols) {
+                colgroup.appendChild(col);
+            }
+            tableWrap.insertBefore(colgroup, table.nextSibling);
+        }
+        const tableFootWrap = tableWrap.querySelector('table-wrap-foot');
+        if (tableFootWrap) {
+            const paragraphs = tableFootWrap.querySelectorAll(':scope > p');
+            if (paragraphs.length) {
+                const generalTableFootnote = createElement('general-table-footnote');
+                for (const paragraph of paragraphs) {
+                    removeNodeFromParent(paragraph);
+                    generalTableFootnote.append(paragraph);
+                }
+                tableFootWrap.prepend(generalTableFootnote);
+            }
+        }
+    });
+};

package/dist/es/jats/importer/parse-jats-article.js

@@ -13,111 +13,56 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { InvalidInput } from '../../errors';
-import { buildBibliographyElement, buildSection, encode, } from '../../transformer';
-import { buildManuscript } from '../../transformer/builders';
-import { generateID } from '../../transformer/id';
-import { findManuscript } from '../../transformer/project-bundle';
-import { jatsBodyDOMParser } from './jats-body-dom-parser';
-import { jatsBodyTransformations } from './jats-body-transformations';
-import { createComments, createReferenceComments, markComments, } from './jats-comments';
-import { jatsFrontParser } from './jats-front-parser';
+import { markComments } from './jats-comments';
+import { jatsDOMParser } from './jats-dom-parser';
+import { parseJournal } from './jats-journal-meta-parser';
 import { updateDocumentIDs } from './jats-parser-utils';
-import { jatsReferenceParser } from './jats-reference-parser';
-export const parseJATSFront = (doc, front) => {
+import { createAbstracts, createBackmatter, createBody, createBoxedElementSection, createKeywordsSection, createSupplementaryMaterialsSection, ensureSection, fixTables, moveAffiliations, moveAuthorNotes, moveCaptionsToEnd, moveContributors, moveReferencesToBackmatter, moveTitle, orderTableFootnote, } from './jats-transformations';
+const processJATS = (doc) => {
     const createElement = createElementFn(doc);
-    const journal = jatsFrontParser.parseJournal(front.querySelector('journal-meta'));
-    const titles = jatsFrontParser.parseTitles(front.querySelector('article-meta > title-group'), createElement);
-    const DOI = jatsFrontParser.parseDOI(front);
-    const { affiliations, affiliationIDs } = jatsFrontParser.parseAffiliations([
-        ...front.querySelectorAll('article-meta > contrib-group > aff'),
-    ]);
-    const { footnotes, footnoteIDs, authorNotes, authorNotesParagraphs, correspondingIDs, correspondingList, } = jatsFrontParser.parseAuthorNotes(front.querySelector('article-meta > author-notes'));
-    const authors = jatsFrontParser.parseContributors([
-        ...front.querySelectorAll('article-meta > contrib-group > contrib[contrib-type="author"]'),
-    ], affiliationIDs, footnoteIDs, correspondingIDs);
-    const history = jatsFrontParser.parseDates(front.querySelector('article-meta > history'));
-    const counts = jatsFrontParser.parseCounts(front.querySelector('article-meta counts'));
-    const manuscript = Object.assign(Object.assign(Object.assign(Object.assign({}, buildManuscript()), counts), history), { DOI });
-    return generateIDs([
-        manuscript,
-        titles,
-        journal,
-        ...authorNotesParagraphs,
-        ...authorNotes,
-        ...footnotes,
-        ...authors,
-        ...affiliations,
-        ...correspondingList,
-    ]);
-};
-export const parseJATSBody = (doc, body, references) => {
-    const createElement = createElementFn(doc);
-    jatsBodyTransformations.ensureSection(body, createElement);
-    jatsBodyTransformations.moveCaptionsToEnd(body);
-    jatsBodyTransformations.fixTables(body, createElement);
-    jatsBodyTransformations.createBody(doc, body, createElement);
-    jatsBodyTransformations.createAbstracts(doc, body, createElement);
-    jatsBodyTransformations.createBackmatter(doc, body, createElement);
-    jatsBodyTransformations.createSuppleMaterials(doc, body, createElement);
-    jatsBodyTransformations.createKeywords(doc, body, createElement);
-    jatsBodyTransformations.orderTableFootnote(doc, body);
-    const node = jatsBodyDOMParser.parse(body).firstChild;
-    if (!node) {
-        throw new Error('No content was parsed from the JATS article body');
-    }
-    const replacements = new Map(references === null || references === void 0 ? void 0 : references.IDs);
-    updateDocumentIDs(node, replacements);
-    return encode(node).values();
-};
-const createBibliographyModels = (references) => {
-    const models = [];
-    const bibliographyItems = references.getBibliographyItems();
-    const bibliographyElement = buildBibliographyElement(bibliographyItems);
-    const bibliographySection = Object.assign(Object.assign({}, buildSection(99)), { category: 'MPSectionCategory:bibliography', elementIDs: [bibliographyElement._id], title: 'References' });
-    const comments = createReferenceComments(references);
-    models.push(bibliographySection);
-    models.push(bibliographyElement);
-    models.push(...bibliographyItems);
-    models.push(...comments);
-    return models;
-};
-const createElementFn = (doc) => (tagName) => doc.createElement(tagName);
-const generateIDs = (models) => models.map((m) => m._id ? m : Object.assign(Object.assign({}, m), { _id: generateID(m.objectType) }));
-export const parseJATSArticle = (doc) => {
-    const article = doc.querySelector('article');
+    markComments(doc);
     const front = doc.querySelector('front');
-    const body = doc.querySelector('body');
-    const back = doc.querySelector('back');
     if (!front) {
-        throw new InvalidInput('Invalid JATS format! Missing front element');
+        return;
     }
-    if (!article) {
-        throw new InvalidInput('Invalid JATS format! Missing article element');
-    }
-    const marks = markComments(doc);
-    const createElement = createElementFn(doc);
-    const models = [];
-    let references;
-    if (back) {
-        references = jatsReferenceParser.parseReferences([...back.querySelectorAll('ref-list > ref')], createElement);
-    }
-    models.push(...parseJATSFront(doc, front));
-    if (body) {
-        models.push(...parseJATSBody(doc, body, references));
+    moveTitle(front, createElement);
+    moveContributors(front, createElement);
+    moveAffiliations(front, createElement);
+    moveAuthorNotes(front, createElement);
+    const body = doc.querySelector('body');
+    if (!body) {
+        return;
     }
-    const modelMap = new Map(models.map((model) => [model._id, model]));
-    const manuscript = findManuscript(modelMap);
-    if (manuscript) {
-        const type = article.getAttribute('article-type');
-        manuscript.articleType = type || 'other';
+    ensureSection(body, createElement);
+    moveCaptionsToEnd(body);
+    createBoxedElementSection(body, createElement);
+    createBody(doc, body, createElement);
+    createAbstracts(doc, body, createElement);
+    createBackmatter(doc, body, createElement);
+    createSupplementaryMaterialsSection(doc, body, createElement);
+    createKeywordsSection(doc, body, createElement);
+    fixTables(doc, body, createElement);
+    orderTableFootnote(doc, body);
+    const back = doc.querySelector('back');
+    if (!back) {
+        return;
     }
-    if (references && references.items.size) {
-        models.push(...createBibliographyModels(references));
+    moveReferencesToBackmatter(body, back, createElement);
+};
+const createElementFn = (doc) => (tagName) => doc.createElement(tagName);
+export const parseJATSArticle = (doc, template) => {
+    const journal = parseJournal(doc);
+    processJATS(doc);
+    const node = jatsDOMParser.parse(doc).firstChild;
+    if (!node) {
+        throw new Error('No content was parsed from the JATS article body');
     }
-    if (marks.length) {
-        const comments = createComments(models, marks);
-        models.push(...comments);
+    updateDocumentIDs(node);
+    if (template) {
+        node.attrs.prototype = template;
     }
-    return models;
+    return {
+        node,
+        journal,
+    };
 };

package/dist/es/jats/index.js

@@ -13,6 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export { parseJATSFront, parseJATSBody, parseJATSArticle } from './importer';
-export * from './jats-exporter';
-export * from './jats-versions';
+export * from './exporter/jats-exporter';
+export * from './exporter/jats-versions';
+export * from './exporter/labels';
+export * from './importer/create-article-node';
+export { parseJATSArticle } from './importer/parse-jats-article';

package/dist/{types/transformer/timestamp.d.ts → es/lib/deafults.js}

@@ -1,5 +1,5 @@
 /*!
- * © 2019 Atypon Systems LLC
+ * © 2024 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.
@@ -13,4 +13,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export declare const timestamp: () => number;
+export const defaultTitle = 'Untitled Manuscript';

package/dist/es/lib/utils.js

@@ -74,3 +74,4 @@ export const getTrimmedTextContent = (node, querySelector) => {
     }
     return (_b = (_a = node.querySelector(querySelector)) === null || _a === void 0 ? void 0 : _a.textContent) === null || _b === void 0 ? void 0 : _b.trim();
 };
+export const timestamp = () => Math.floor(Date.now() / 1000);

package/dist/es/schema/index.js

@@ -20,12 +20,15 @@ import { affiliation } from './nodes/affiliation';
 import { affiliations } from './nodes/affiliations';
 import { attribution } from './nodes/attribution';
 import { authorNotes } from './nodes/author_notes';
+import { award } from './nodes/award';
+import { awards } from './nodes/awards';
 import { backmatter } from './nodes/backmatter';
 import { bibliographyElement } from './nodes/bibliography_element';
 import { bibliographyItem } from './nodes/bibliography_item';
 import { bibliographySection } from './nodes/bibliography_section';
 import { blockquoteElement } from './nodes/blockquote_element';
 import { body } from './nodes/body';
+import { box_element } from './nodes/box_element';
 import { caption } from './nodes/caption';
 import { captionTitle } from './nodes/caption_title';
 import { citation } from './nodes/citation';
@@ -103,7 +106,9 @@ export * from './nodes/footnotes_section';
 export * from './nodes/graphical_abstract_section';
 export * from './nodes/hard_break';
 export * from './nodes/highlight_marker';
+export * from './nodes/inline_equation';
 export * from './nodes/inline_footnote';
+export * from './nodes/keyword_group';
 export * from './nodes/keyword';
 export * from './nodes/keywords_element';
 export * from './nodes/keywords';
@@ -133,6 +138,8 @@ export * from './nodes/affiliations';
 export * from './nodes/contributors';
 export * from './nodes/supplement';
 export * from './nodes/supplements';
+export * from './nodes/corresp';
+export * from './nodes/author_notes';
 export const schema = new Schema({
     marks: {
         bold,
@@ -216,5 +223,8 @@ export const schema = new Schema({
         supplement,
         author_notes: authorNotes,
         corresp,
+        box_element,
+        awards,
+        award,
     },
 });

package/dist/es/schema/migration/migrate.js

@@ -23,16 +23,10 @@ export function migrateFor(oldDoc, baseVersion) {
         console.log('Migrating doc with script to version ' + script.toVersion);
         migratedDoc = migrate(migratedDoc, script.migrateNode);
     }
-    return testDoc(migratedDoc, oldDoc, baseVersion);
+    return testDoc(migratedDoc, baseVersion);
 }
-function ensureVersionAscOrder() {
-    return migrationScripts.sort((a, b) => semver.eq(a.toVersion, b.toVersion)
-        ? 0
-        : semver.gt(a.toVersion, b.toVersion)
-            ? 1
-            : -1);
-}
-function testDoc(doc, oldDoc, fromVersion) {
+const ensureVersionAscOrder = () => migrationScripts.sort((a, b) => semver.compare(a.toVersion, b.toVersion));
+function testDoc(doc, fromVersion) {
     try {
         const resultDoc = schema.nodeFromJSON(doc);
         resultDoc.check();

package/dist/es/schema/migration/migration-script.js

@@ -1,5 +1,5 @@
 /*!
- * © 2019 Atypon Systems LLC
+ * © 2024 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.

package/dist/es/schema/migration/migration-scripts/1.2.5.js

@@ -1,5 +1,5 @@
 /*!
- * © 2019 Atypon Systems LLC
+ * © 2024 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.
@@ -16,7 +16,7 @@
 class Migration125 {
     constructor() {
         this.fromVersion = '1.2.3';
-        this.toVersion = '1.2.4';
+        this.toVersion = '1.2.5';
     }
     migrateNode(node, doc) {
         if (node.type === 'paragraph') {

package/dist/es/schema/migration/migration-scripts/2.3.22.js

@@ -0,0 +1,26 @@
+class Migration2322 {
+    constructor() {
+        this.fromVersion = '2.3.21';
+        this.toVersion = '2.3.22';
+    }
+    migrateNode(node) {
+        if (node.type === 'table_element' && Array.isArray(node.content)) {
+            let figcaptionNode = null;
+            const remainingContent = [];
+            for (const child of node.content) {
+                if (child.type === 'figcaption') {
+                    figcaptionNode = child;
+                }
+                else {
+                    remainingContent.push(child);
+                }
+            }
+            const newContent = figcaptionNode
+                ? [figcaptionNode, ...remainingContent]
+                : remainingContent;
+            return Object.assign(Object.assign({}, node), { content: newContent });
+        }
+        return node;
+    }
+}
+export default Migration2322;