@manuscripts/transform 1.0.0

package/dist/es/transformer/encode.js

@@ -0,0 +1,535 @@
+/*!
+ * © 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 { DOMSerializer } from 'prosemirror-model';
+import serializeToXML from 'w3c-xmlserializer';
+import { iterateChildren } from '../lib/utils';
+import { isHighlightMarkerNode, isSectionNode, schema, } from '../schema';
+import { buildAttribution, buildComment } from './builders';
+import { extractHighlightMarkers, isHighlightableModel, } from './highlight-markers';
+import { nodeTypesMap } from './node-types';
+import { buildSectionCategory } from './section-category';
+const serializer = DOMSerializer.fromSchema(schema);
+const contents = (node) => {
+    const output = serializer.serializeNode(node);
+    return serializeToXML(output);
+};
+const footnoteContents = (node) => {
+    const output = serializer.serializeNode(node);
+    output.querySelectorAll('p').forEach((element) => {
+        element.removeAttribute('class');
+        element.removeAttribute('data-object-type');
+    });
+    return serializeToXML(output);
+};
+export const inlineContents = (node) => serializer.serializeNode(node).innerHTML;
+export const inlineText = (node) => {
+    const text = serializer.serializeNode(node).textContent;
+    return text === null ? '' : text;
+};
+const listContents = (node) => {
+    const output = serializer.serializeNode(node);
+    for (const p of output.querySelectorAll('li > p')) {
+        const parent = p.parentNode;
+        while (p.firstChild) {
+            parent.insertBefore(p.firstChild, p);
+        }
+        parent.removeChild(p);
+    }
+    return serializeToXML(output);
+};
+const svgDefs = (svg) => {
+    const template = document.createElement('template');
+    template.innerHTML = svg.trim();
+    const defs = template.content.querySelector('defs');
+    return defs ? serializeToXML(defs) : undefined;
+};
+const tableRowDisplayStyle = (tagName, parent) => {
+    switch (tagName) {
+        case 'thead':
+            return parent.attrs.suppressHeader ? 'none' : 'table-header-group';
+        case 'tfoot':
+            return parent.attrs.suppressFooter ? 'none' : 'table-footer-group';
+        default:
+            return null;
+    }
+};
+const buildTableSection = (tagName, inputRows, parent) => {
+    const section = document.createElement(tagName);
+    for (const sectionRow of inputRows) {
+        const row = section.appendChild(document.createElement('tr'));
+        for (const child of sectionRow.children) {
+            const cellType = tagName === 'thead' ? 'th' : 'td';
+            const cell = row.appendChild(document.createElement(cellType));
+            while (child.firstChild) {
+                cell.appendChild(child.firstChild);
+            }
+            for (const attribute of child.attributes) {
+                cell.setAttribute(attribute.name, attribute.value);
+            }
+        }
+    }
+    const displayStyle = tableRowDisplayStyle(tagName, parent);
+    if (displayStyle) {
+        section.style.display = displayStyle;
+    }
+    return section;
+};
+function buildTableColGroup(cols) {
+    if (cols.length === 0) {
+        return undefined;
+    }
+    const colgroup = document.createElement('colgroup');
+    for (const inputCol of cols) {
+        const col = document.createElement('col');
+        for (const attribute of inputCol.attributes) {
+            col.setAttribute(attribute.name, attribute.value);
+        }
+        colgroup.appendChild(inputCol);
+    }
+    return colgroup;
+}
+const tableContents = (node, parent) => {
+    const input = serializer.serializeNode(node);
+    const output = document.createElement('table');
+    const colgroup = buildTableColGroup(Array.from(input.querySelectorAll('col')));
+    if (colgroup) {
+        output.appendChild(colgroup);
+    }
+    output.setAttribute('id', parent.attrs.id);
+    output.classList.add('MPElement');
+    if (parent.attrs.tableStyle) {
+        output.classList.add(parent.attrs.tableStyle.replace(/:/g, '_'));
+    }
+    if (parent.attrs.paragraphStyle) {
+        output.classList.add(parent.attrs.paragraphStyle.replace(/:/g, '_'));
+    }
+    output.setAttribute('data-contained-object-id', node.attrs.id);
+    const rows = Array.from(input.querySelectorAll('tr'));
+    let headerCount = 0;
+    for (const row of rows) {
+        const th = row.querySelector('th[scope="col"], th[scope="colgroup"]');
+        th && headerCount++;
+    }
+    const thead = rows.splice(0, headerCount || 1);
+    const tfoot = rows.splice(-1, 1);
+    output.appendChild(buildTableSection('thead', thead, parent));
+    output.appendChild(buildTableSection('tbody', rows, parent));
+    output.appendChild(buildTableSection('tfoot', tfoot, parent));
+    return serializeToXML(output);
+};
+const elementContents = (node) => {
+    const input = serializer.serializeNode(node);
+    input.classList.add('MPElement');
+    if (node.attrs.paragraphStyle) {
+        input.classList.add(node.attrs.paragraphStyle.replace(/:/g, '_'));
+    }
+    if (node.attrs.id) {
+        input.setAttribute('id', node.attrs.id);
+    }
+    return serializeToXML(input);
+};
+const childElements = (node) => {
+    const nodes = [];
+    node.forEach((childNode) => {
+        if (!isSectionNode(childNode)) {
+            nodes.push(childNode);
+        }
+    });
+    return nodes;
+};
+const attributeOfNodeType = (node, type, attribute) => {
+    for (const child of iterateChildren(node)) {
+        if (child.type.name === type) {
+            return child.attrs[attribute];
+        }
+    }
+    return '';
+};
+const inlineContentsOfNodeType = (node, nodeType) => {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child.type === nodeType) {
+            return inlineContents(child);
+        }
+    }
+    return '';
+};
+const inlineContentOfChildNodeType = (node, parentNodeType, childNodeType, empty = true) => {
+    const parentNode = childElements(node).find((node) => node.type === parentNodeType && node);
+    const content = parentNode && inlineContentsOfNodeType(parentNode, childNodeType);
+    return content && content.length > 1 ? content : empty ? content : undefined;
+};
+const wrappedContentOfChildrenNodeType = (node, parentNodeType, childNodeType) => {
+    const parentNode = childElements(node).find((node) => node.type === parentNodeType && node);
+    const content = parentNode &&
+        childElements(parentNode)
+            .filter((node) => node.type === childNodeType && node)
+            .map((node) => serializer.serializeNode(node).outerHTML)
+            .join('');
+    return content;
+};
+const containedFigureIDs = (node) => {
+    const figureNodeType = node.type.schema.nodes.figure;
+    const missingFigureNodeType = node.type.schema.nodes.missing_figure;
+    return containedObjectIDs(node, [figureNodeType, missingFigureNodeType]);
+};
+const containedParagraphIDs = (node) => {
+    const paragraphNodeType = node.type.schema.nodes.paragraph;
+    return containedObjectIDs(node, [paragraphNodeType]);
+};
+const containedBibliographyItemIDs = (node) => {
+    const bibliographyItemNodeType = node.type.schema.nodes.bibliography_item;
+    return containedObjectIDs(node, [bibliographyItemNodeType]);
+};
+const containedObjectIDs = (node, nodeTypes) => {
+    const ids = [];
+    for (let i = 0; i < node.childCount; i++) {
+        const childNode = node.child(i);
+        if (nodeTypes.includes(childNode.type)) {
+            ids.push(childNode.attrs.id);
+        }
+    }
+    return ids;
+};
+const attribution = (node) => {
+    if (node.attrs.attribution) {
+        return Object.assign(Object.assign({}, node.attrs.attribution), buildAttribution());
+    }
+    return undefined;
+};
+const fromJson = (json) => {
+    let obj;
+    try {
+        obj = JSON.parse(json);
+    }
+    catch (e) {
+    }
+    return obj;
+};
+function figureElementEncoder(node) {
+    var _a;
+    return {
+        containedObjectIDs: (_a = containedParagraphIDs(node)) === null || _a === void 0 ? void 0 : _a.concat(containedFigureIDs(node)),
+        caption: wrappedContentOfChildrenNodeType(node, node.type.schema.nodes.figcaption, node.type.schema.nodes.caption),
+        title: inlineContentOfChildNodeType(node, node.type.schema.nodes.figcaption, node.type.schema.nodes.caption_title, false),
+        label: node.attrs.label,
+        elementType: 'figure',
+        attribution: attribution(node),
+        alternatives: node.attrs.alternatives,
+        listingID: attributeOfNodeType(node, 'listing', 'id') || undefined,
+        alignment: node.attrs.alignment || undefined,
+        sizeFraction: node.attrs.sizeFraction || undefined,
+        suppressCaption: Boolean(node.attrs.suppressCaption) || undefined,
+        suppressTitle: node.attrs.suppressTitle === undefined ||
+            node.attrs.suppressTitle === true
+            ? undefined
+            : false,
+        figureStyle: node.attrs.figureStyle || undefined,
+        figureLayout: node.attrs.figureLayout || undefined,
+    };
+}
+const encoders = {
+    bibliography_element: (node) => ({
+        elementType: 'div',
+        contents: '',
+        containedObjectIDs: containedBibliographyItemIDs(node),
+        paragraphStyle: node.attrs.paragraphStyle || undefined,
+    }),
+    bibliography_item: (node) => {
+        const { type, containerTitle, doi, volume, issue, supplement, page, title, literal, } = node.attrs;
+        const author = fromJson(node.attrs.author);
+        const issued = fromJson(node.attrs.issued);
+        const ref = {
+            type,
+        };
+        if (author) {
+            ref.author = author;
+        }
+        if (issued) {
+            ref.issued = issued;
+        }
+        if (containerTitle) {
+            ref['container-title'] = containerTitle;
+        }
+        if (doi) {
+            ref.DOI = doi;
+        }
+        if (volume) {
+            ref.volume = volume;
+        }
+        if (issue) {
+            ref.issue = issue;
+        }
+        if (supplement) {
+            ref.supplement = supplement;
+        }
+        if (page) {
+            ref.page = page;
+        }
+        if (title) {
+            ref.title = title;
+        }
+        if (literal) {
+            ref.literal = literal;
+        }
+        return ref;
+    },
+    bibliography_section: (node, parent, path, priority) => ({
+        category: buildSectionCategory(node),
+        priority: priority.value++,
+        title: inlineContentsOfNodeType(node, node.type.schema.nodes.section_title),
+        path: path.concat([node.attrs.id]),
+        elementIDs: childElements(node)
+            .map((childNode) => childNode.attrs.id)
+            .filter((id) => id),
+    }),
+    blockquote_element: (node) => ({
+        contents: contents(node),
+        elementType: 'div',
+        paragraphStyle: node.attrs.paragraphStyle || undefined,
+        placeholderInnerHTML: node.attrs.placeholder || '',
+        quoteType: 'block',
+    }),
+    bullet_list: (node) => ({
+        elementType: 'ul',
+        contents: listContents(node),
+        paragraphStyle: node.attrs.paragraphStyle || undefined,
+    }),
+    listing: (node) => ({
+        contents: inlineText(node),
+        language: node.attrs.language || undefined,
+        languageKey: node.attrs.languageKey || 'null',
+    }),
+    listing_element: (node) => ({
+        containedObjectID: attributeOfNodeType(node, 'listing', 'id'),
+        caption: inlineContentOfChildNodeType(node, node.type.schema.nodes.figcaption, node.type.schema.nodes.caption),
+        title: inlineContentOfChildNodeType(node, node.type.schema.nodes.figcaption, node.type.schema.nodes.caption_title, false),
+        elementType: 'figure',
+        suppressCaption: node.attrs.suppressCaption === true ? undefined : false,
+        suppressTitle: node.attrs.suppressTitle === undefined ||
+            node.attrs.suppressTitle === true
+            ? undefined
+            : false,
+    }),
+    equation: (node) => ({
+        MathMLStringRepresentation: node.attrs.MathMLStringRepresentation || undefined,
+        TeXRepresentation: node.attrs.TeXRepresentation,
+        SVGStringRepresentation: node.attrs.SVGStringRepresentation,
+    }),
+    equation_element: (node) => ({
+        containedObjectID: attributeOfNodeType(node, 'equation', 'id'),
+        caption: inlineContentOfChildNodeType(node, node.type.schema.nodes.figcaption, node.type.schema.nodes.caption),
+        title: inlineContentOfChildNodeType(node, node.type.schema.nodes.figcaption, node.type.schema.nodes.caption_title, false),
+        elementType: 'p',
+        suppressCaption: Boolean(node.attrs.suppressCaption) || undefined,
+        suppressTitle: node.attrs.suppressTitle === undefined ||
+            node.attrs.suppressTitle === true
+            ? undefined
+            : false,
+    }),
+    figure: (node) => ({
+        contentType: node.attrs.contentType || undefined,
+        src: node.attrs.src || undefined,
+        position: node.attrs.position || undefined,
+    }),
+    figure_element: (node) => figureElementEncoder(node),
+    comment: (node) => ({
+        selector: node.attrs.selector,
+        target: node.attrs.target,
+        contents: node.attrs.contents,
+    }),
+    footnote: (node, parent) => ({
+        containingObject: parent.attrs.id,
+        contents: footnoteContents(node),
+        kind: node.attrs.kind || 'footnote',
+    }),
+    footnotes_element: (node) => ({
+        contents: '<div></div>',
+        elementType: 'div',
+        paragraphStyle: node.attrs.paragraphStyle || undefined,
+    }),
+    footnotes_section: (node, parent, path, priority) => ({
+        category: buildSectionCategory(node),
+        priority: priority.value++,
+        title: inlineContentsOfNodeType(node, node.type.schema.nodes.section_title),
+        path: path.concat([node.attrs.id]),
+        elementIDs: childElements(node)
+            .map((childNode) => childNode.attrs.id)
+            .filter((id) => id),
+    }),
+    graphical_abstract_section: (node, parent, path, priority) => ({
+        category: buildSectionCategory(node),
+        priority: priority.value++,
+        title: inlineContentsOfNodeType(node, node.type.schema.nodes.section_title),
+        path: path.concat([node.attrs.id]),
+        elementIDs: childElements(node)
+            .map((childNode) => childNode.attrs.id)
+            .filter((id) => id),
+    }),
+    inline_equation: (node, parent) => ({
+        containingObject: parent.attrs.id,
+        TeXRepresentation: node.attrs.TeXRepresentation,
+        SVGRepresentation: node.attrs.SVGRepresentation,
+        SVGGlyphs: svgDefs(node.attrs.SVGRepresentation),
+    }),
+    keywords_element: (node) => ({
+        contents: elementContents(node),
+        elementType: 'div',
+        paragraphStyle: node.attrs.paragraphStyle || undefined,
+    }),
+    keywords_section: (node, parent, path, priority) => ({
+        category: buildSectionCategory(node),
+        priority: priority.value++,
+        title: inlineContentsOfNodeType(node, node.type.schema.nodes.section_title),
+        path: path.concat([node.attrs.id]),
+        elementIDs: childElements(node)
+            .map((childNode) => childNode.attrs.id)
+            .filter((id) => id),
+    }),
+    missing_figure: (node) => ({
+        position: node.attrs.position || undefined,
+    }),
+    ordered_list: (node) => ({
+        elementType: 'ol',
+        contents: listContents(node),
+        paragraphStyle: node.attrs.paragraphStyle || undefined,
+    }),
+    paragraph: (node) => ({
+        elementType: 'p',
+        contents: contents(node),
+        paragraphStyle: node.attrs.paragraphStyle || undefined,
+        placeholderInnerHTML: node.attrs.placeholder || '',
+    }),
+    placeholder_element: () => ({
+        elementType: 'p',
+    }),
+    pullquote_element: (node) => ({
+        contents: contents(node),
+        elementType: 'div',
+        paragraphStyle: node.attrs.paragraphStyle || undefined,
+        placeholderInnerHTML: node.attrs.placeholder || '',
+        quoteType: 'pull',
+    }),
+    section: (node, parent, path, priority) => ({
+        category: buildSectionCategory(node),
+        priority: priority.value++,
+        title: inlineContentsOfNodeType(node, node.type.schema.nodes.section_title),
+        label: inlineContentsOfNodeType(node, node.type.schema.nodes.section_label) ||
+            undefined,
+        path: path.concat([node.attrs.id]),
+        elementIDs: childElements(node)
+            .map((childNode) => childNode.attrs.id)
+            .filter((id) => id),
+        titleSuppressed: node.attrs.titleSuppressed || undefined,
+        generatedLabel: node.attrs.generatedLabel || undefined,
+        pageBreakStyle: node.attrs.pageBreakStyle || undefined,
+    }),
+    table: (node, parent) => ({
+        contents: tableContents(node, parent),
+        listingAttachment: node.attrs.listingAttachment || undefined,
+    }),
+    table_element: (node) => ({
+        containedObjectID: attributeOfNodeType(node, 'table', 'id'),
+        caption: inlineContentOfChildNodeType(node, node.type.schema.nodes.figcaption, node.type.schema.nodes.caption),
+        title: inlineContentOfChildNodeType(node, node.type.schema.nodes.figcaption, node.type.schema.nodes.caption_title, false),
+        elementType: 'table',
+        listingID: attributeOfNodeType(node, 'listing', 'id') || undefined,
+        paragraphStyle: node.attrs.paragraphStyle || undefined,
+        suppressCaption: Boolean(node.attrs.suppressCaption) || undefined,
+        suppressTitle: node.attrs.suppressTitle === undefined ||
+            node.attrs.suppressTitle === true
+            ? undefined
+            : false,
+        suppressFooter: Boolean(node.attrs.suppressFooter) || undefined,
+        suppressHeader: Boolean(node.attrs.suppressHeader) || undefined,
+        tableStyle: node.attrs.tableStyle || undefined,
+    }),
+    toc_element: (node) => ({
+        contents: elementContents(node),
+        elementType: 'div',
+        paragraphStyle: node.attrs.paragraphStyle || undefined,
+    }),
+    toc_section: (node, parent, path, priority) => ({
+        category: buildSectionCategory(node),
+        priority: priority.value++,
+        title: inlineContentsOfNodeType(node, node.type.schema.nodes.section_title),
+        path: path.concat([node.attrs.id]),
+        elementIDs: childElements(node)
+            .map((childNode) => childNode.attrs.id)
+            .filter((id) => id),
+    }),
+};
+const modelData = (node, parent, path, priority) => {
+    const encoder = encoders[node.type.name];
+    if (!encoder) {
+        throw new Error(`Unhandled model: ${node.type.name}`);
+    }
+    return encoder(node, parent, path, priority);
+};
+export const modelFromNode = (node, parent, path, priority) => {
+    const commentAnnotationsMap = new Map();
+    const objectType = nodeTypesMap.get(node.type);
+    if (!objectType) {
+        throw new Error(`No objectType is defined for ${node.type.name}`);
+    }
+    const { id } = node.attrs;
+    if (!id) {
+        throw new Error(`No id is defined for this ${node.type.name}`);
+    }
+    const data = Object.assign(Object.assign({}, modelData(node, parent, path, priority)), { _id: id, objectType: objectType });
+    const model = data;
+    if (isHighlightableModel(model)) {
+        extractHighlightMarkers(model, commentAnnotationsMap);
+        if (node.attrs.comments) {
+            const commentNodes = node.attrs.comments;
+            commentNodes
+                .filter((commentNode) => !commentNode.attrs.selector)
+                .forEach((c) => {
+                const commentAnnotation = buildComment(model._id, c.attrs.contents, c.attrs.selector);
+                commentAnnotation._id = c.attrs.id;
+                commentAnnotationsMap.set(commentAnnotation._id, commentAnnotation);
+            });
+        }
+    }
+    return { model, commentAnnotationsMap };
+};
+export const encode = (node) => {
+    const models = new Map();
+    const priority = {
+        value: 1,
+    };
+    const placeholders = ['placeholder', 'placeholder_element'];
+    const addModel = (path, parent) => (child) => {
+        if (!child.attrs.id) {
+            return;
+        }
+        if (isHighlightMarkerNode(child)) {
+            return;
+        }
+        if (placeholders.includes(child.type.name)) {
+            return;
+        }
+        const { model, commentAnnotationsMap } = modelFromNode(child, parent, path, priority);
+        if (models.has(model._id)) {
+            throw Error(`Encountered duplicate ids in models map while encoding: ${model._id}`);
+        }
+        models.set(model._id, model);
+        commentAnnotationsMap.forEach((val, key) => models.set(key, val));
+        child.forEach(addModel(path.concat(child.attrs.id), child));
+    };
+    node.forEach(addModel([], node));
+    return models;
+};

package/dist/es/transformer/filename.js

@@ -0,0 +1,23 @@
+/*!
+ * © 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.
+ */
+export const generateAttachmentFilename = (id, contentType) => {
+    const basename = id.replace(':', '_');
+    if (!contentType) {
+        return basename;
+    }
+    const [, mimeSubType] = contentType.split('/');
+    return `${basename}.${mimeSubType}`;
+};

package/dist/es/transformer/footnote-category.js

@@ -0,0 +1,16 @@
+/*!
+ * © 2021 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.
+ */
+export const buildFootnoteCategory = (category) => (category && `MPFootnoteCategory:${category}`) || undefined;

package/dist/es/transformer/footnotes-order.js

@@ -0,0 +1,53 @@
+/*!
+ * © 2022 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 { buildFootnotesOrder } from './builders';
+export const createOrderedFootnotesIDs = (doc) => {
+    const footnotesRefs = [...doc.querySelectorAll('xref[ref-type="fn"][rid]')];
+    const footnotes = [...doc.querySelectorAll('fn:not([fn-type])')];
+    const authorNotesIDs = [...doc.querySelectorAll('author-notes > fn')].map((an) => an.getAttribute('id'));
+    const orderedFootnotesIDs = [];
+    footnotesRefs.forEach((ref) => {
+        const refID = ref.getAttribute('rid');
+        if (refID) {
+            orderedFootnotesIDs.push(refID);
+        }
+    });
+    footnotes.forEach((footnote) => {
+        const id = footnote.getAttribute('id');
+        if (id &&
+            !authorNotesIDs.includes(id) &&
+            !orderedFootnotesIDs.includes(id)) {
+            orderedFootnotesIDs.push(id);
+        }
+    });
+    return orderedFootnotesIDs;
+};
+export const handleFootnotesOrder = (orderedFootnotesIDs, replacements, footnotesOrder) => {
+    const footnotesList = [];
+    let index = 0;
+    orderedFootnotesIDs.forEach((refID) => {
+        const fnID = replacements.get(refID);
+        if (fnID) {
+            footnotesList.push({
+                index,
+                id: fnID,
+            });
+            index++;
+        }
+    });
+    footnotesOrder.footnotesList = footnotesList;
+};
+export const createEmptyFootnotesOrder = () => buildFootnotesOrder([]);