@manuscripts/transform 1.0.0

package/dist/es/transformer/tei-grobid-importer.js

@@ -0,0 +1,115 @@
+/*!
+ * © 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 { buildAffiliation, buildBibliographicDate, buildBibliographicName, buildBibliographyItem, buildContributor, buildManuscript, } from './builders';
+import { addModelToMap } from './model-map';
+const iterateSnapshot = function* (snapshot) {
+    for (let i = 0; i < snapshot.snapshotLength; i++) {
+        yield snapshot.snapshotItem(i);
+    }
+};
+const namespaces = new Map([
+    [null, 'http://www.tei-c.org/ns/1.0'],
+]);
+const namespaceResolver = (prefix) => namespaces.get(prefix) || null;
+export const parseFront = (doc, addModel) => {
+    const headerNode = doc.evaluate('/TEI/teiHeader', doc, namespaceResolver, XPathResult.FIRST_ORDERED_NODE_TYPE).singleNodeValue;
+    if (!headerNode) {
+        throw new Error('No header element found!');
+    }
+    const title = doc.evaluate('fileDesc/titleStmt/title', headerNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+    const manuscript = buildManuscript(title);
+    addModel(manuscript);
+    const affiliationsMap = new Map();
+    const authorNodes = doc.evaluate('fileDesc/sourceDesc/biblStruct/analytic/author', headerNode, namespaceResolver, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
+    for (const authorNode of iterateSnapshot(authorNodes)) {
+        const name = buildBibliographicName({});
+        name.given = doc.evaluate('persName/forename', authorNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+        name.family = doc.evaluate('persName/surname', authorNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+        const contributor = buildContributor(name, 'author', 1);
+        contributor.affiliations = [];
+        const affiliationNodes = doc.evaluate('affiliation', authorNode, namespaceResolver, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
+        for (const affiliationNode of iterateSnapshot(affiliationNodes)) {
+            const key = affiliationNode.getAttribute('key');
+            if (key) {
+                const affiliation = affiliationsMap.get(key);
+                if (affiliation) {
+                    contributor.affiliations.push(affiliation._id);
+                }
+                else {
+                    const affiliation = buildAffiliation('', 1);
+                    affiliation.institution = doc.evaluate('orgName[@type="institution"]', affiliationNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+                    affiliation.department = doc.evaluate('orgName[@type="department"]', affiliationNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+                    addModel(affiliation);
+                    affiliationsMap.set(key, affiliation);
+                    contributor.affiliations.push(affiliation._id);
+                }
+            }
+        }
+        addModel(contributor);
+    }
+};
+const chooseBibliographyItemType = (publicationType) => {
+    switch (publicationType) {
+        case 'book':
+        case 'thesis':
+            return publicationType;
+        case 'journal':
+        default:
+            return 'article-journal';
+    }
+};
+export const parseBack = (doc, addModel) => {
+    const backNode = doc.evaluate('/TEI/text/back', doc, namespaceResolver, XPathResult.FIRST_ORDERED_NODE_TYPE).singleNodeValue;
+    if (!backNode) {
+        return;
+    }
+    const referenceNodes = doc.evaluate('div[@type="references"]/listBibl/biblStruct', backNode, namespaceResolver, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
+    for (const referenceNode of iterateSnapshot(referenceNodes)) {
+        const bibliographyItem = buildBibliographyItem({
+            type: chooseBibliographyItemType(null),
+        });
+        bibliographyItem.title = doc.evaluate('analytic/title', referenceNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+        bibliographyItem.source = doc.evaluate('monogr/title', referenceNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+        bibliographyItem.volume = doc.evaluate('monogr/imprint/biblScope[unit="volume"]', referenceNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+        const fpage = doc.evaluate('monogr/imprint/biblScope[unit="page"]/@from', referenceNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+        const lpage = doc.evaluate('monogr/imprint/biblScope[unit="page"]/@to', referenceNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+        if (fpage) {
+            bibliographyItem.page = lpage ? `${fpage}-${lpage}` : fpage;
+        }
+        const date = doc.evaluate('monogr/imprint/date[type="published"]/@when', referenceNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+        if (date) {
+            bibliographyItem.issued = buildBibliographicDate({
+                'date-parts': [date.split(/-/)],
+            });
+        }
+        const authorNodes = doc.evaluate('analytic/author', referenceNode, namespaceResolver, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
+        bibliographyItem.author = [];
+        for (const authorNode of iterateSnapshot(authorNodes)) {
+            const name = buildBibliographicName({});
+            name.given = doc.evaluate('persName/forename', authorNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+            name.family = doc.evaluate('persName/surname', authorNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+            bibliographyItem.author.push(name);
+        }
+        addModel(bibliographyItem);
+    }
+};
+export const parseTEIGROBIDArticle = (doc) => {
+    const modelMap = new Map();
+    const addModel = addModelToMap(modelMap);
+    parseFront(doc, addModel);
+    parseBack(doc, addModel);
+    return [...modelMap.values()];
+};

package/dist/es/transformer/timestamp.js

@@ -0,0 +1,16 @@
+/*!
+ * © 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 timestamp = () => Math.floor(Date.now() / 1000);

package/dist/es/transformer/update-identifiers.js

@@ -0,0 +1,87 @@
+/*!
+ * © 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 { generateID } from './id';
+export const updateIdentifiers = async (data) => {
+    const idMap = new Map();
+    const updateIDs = (model) => {
+        const { _id, objectType } = model;
+        if (!objectType || !_id || !_id.match(/^MP.+:.+/)) {
+            return;
+        }
+        if (idMap.has(_id)) {
+            model._id = idMap.get(_id);
+        }
+        else {
+            model._id = generateID(objectType);
+            idMap.set(_id, model._id);
+        }
+        for (const value of Object.values(model)) {
+            if (Array.isArray(value)) {
+                value.forEach(updateIDs);
+            }
+            else {
+                updateIDs(value);
+            }
+        }
+    };
+    const replaceContent = (content) => {
+        content = content.replace(/MP\w+:[\w-]+/g, (match) => {
+            const value = idMap.get(match);
+            return value !== null && value !== void 0 ? value : match;
+        });
+        content = content.replace(/MP\w+_[\w-]+/g, (match) => {
+            const value = idMap.get(match.replace('_', ':'));
+            return value ? value.replace(':', '_') : match;
+        });
+        return content;
+    };
+    const updateContent = (model) => {
+        for (const [key, value] of Object.entries(model)) {
+            if (typeof value === 'object') {
+                updateContent(value);
+            }
+            else if (typeof value === 'string') {
+                model[key] = replaceContent(value);
+            }
+        }
+    };
+    for (const item of data) {
+        updateIDs(item);
+    }
+    for (const item of data) {
+        updateContent(item);
+    }
+    return { data, idMap };
+};
+export const updateAttachmentPath = (oldPath, idMap) => {
+    const matches = oldPath.match(/^Data\/([^.]+)(.*)/);
+    if (matches) {
+        const [, prefix, suffix] = matches;
+        const id = idMap.get(prefix.replace('_', ':'));
+        if (id) {
+            const newPrefix = id.replace(':', '_');
+            return `Data/${newPrefix}${suffix}`;
+        }
+    }
+};
+export const updateAttachments = async (zip, idMap) => {
+    for (const [oldPath, entry] of Object.entries(zip.files)) {
+        const newPath = updateAttachmentPath(oldPath, idMap);
+        if (newPath) {
+            zip.file(newPath, await entry.async('blob')).remove(oldPath);
+        }
+    }
+};

package/dist/es/types.js

@@ -0,0 +1 @@
+export {};

package/dist/types/errors.d.ts

@@ -0,0 +1,6 @@
+export declare class MissingElement extends Error {
+    constructor(elementID: string);
+}
+export declare class InvalidInput extends Error {
+    constructor(message: string);
+}

package/dist/types/index.d.ts

@@ -0,0 +1,9 @@
+export * from './lib/table-cell-styles';
+export * from './lib/utils';
+export * from './mathjax';
+export * from './schema';
+export * from './transformer';
+export * from './jats';
+export * from './types';
+export * from './errors';
+export { isSectionLabelNode } from './schema/nodes/section_label';

package/dist/types/jats/importer/index.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * © 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.
+ */
+export { parseJATSFront, parseJATSBody, parseJATSReferences, parseJATSArticle, getElementsOrder, } from './parse-jats-article';

package/dist/types/jats/importer/jats-body-dom-parser.d.ts

@@ -0,0 +1,24 @@
+/*!
+ * © 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 { DOMParser, ParseRule } from 'prosemirror-model';
+import { Marks, Nodes } from '../../schema';
+export type MarkRule = ParseRule & {
+    mark: Marks | null;
+};
+export type NodeRule = ParseRule & {
+    node?: Nodes | null;
+};
+export declare const jatsBodyDOMParser: DOMParser;

package/dist/types/jats/importer/jats-body-transformations.d.ts

@@ -0,0 +1,31 @@
+/*!
+ * © 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 { BibliographyItem } from '@manuscripts/manuscripts-json-schema';
+export declare const jatsBodyTransformations: {
+    ensureSection(body: Element, createElement: (tagName: string) => HTMLElement): void;
+    createAbstract(abstractNode: Element, createElement: (tagName: string) => HTMLElement): HTMLElement;
+    createAcknowledgments(ackNode: Element, createElement: (tagName: string) => HTMLElement): HTMLElement;
+    createBibliography(doc: Document, references: BibliographyItem[], createElement: (tagName: string) => HTMLElement): HTMLElement;
+    createFootnotes(footnoteGroups: Element[], createElement: (tagName: string) => HTMLElement): HTMLElement;
+    createAppendixSection(app: Element, createElement: (tagName: string) => HTMLElement): HTMLElement;
+    createFloatsGroupSection(floatsGroup: Element, createElement: (tagName: string) => HTMLElement): HTMLElement;
+    moveSectionsToBody(doc: Document, body: Element, references: BibliographyItem[] | null, createElement: (tagName: string) => HTMLElement): void;
+    mapFootnotesToSections(doc: Document, body: Element, createElement: (tagName: string) => HTMLElement): void;
+    moveCaptionsToEnd(body: Element): void;
+    moveTableFooterToEnd(body: Element): void;
+    moveFloatsGroupToBody(doc: Document, body: Element, createElement: (tagName: string) => HTMLElement): void;
+    moveBlockNodesFromParagraph(doc: Document, body: Element, createElement: (tagName: string) => HTMLElement): void;
+};

package/dist/types/jats/importer/jats-comments.d.ts

@@ -0,0 +1,26 @@
+/*!
+ * © 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 { BibliographyItem, CommentAnnotation, Model } from '@manuscripts/manuscripts-json-schema';
+import { Build } from '../../transformer';
+type ProcessingInstruction = {
+    id: string;
+    queryText: string;
+};
+export declare const parseProcessingInstruction: (node: Node) => ProcessingInstruction | undefined;
+export declare const markProcessingInstructions: (doc: Document) => Map<string, string>;
+export declare const createComments: (authorQueriesMap: Map<string, string>, manuscriptModels: Array<Model>) => Build<CommentAnnotation>[];
+export declare const createReferenceComments: (referenceQueriesMap: Map<string, string[]>, references: Array<BibliographyItem>) => Build<CommentAnnotation>[];
+export {};

package/dist/types/jats/importer/jats-front-parser.d.ts

@@ -0,0 +1,62 @@
+/*!
+ * © 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 { Bundle, Journal, Keyword, KeywordGroup } from '@manuscripts/manuscripts-json-schema';
+import { Build } from '../../transformer/builders';
+import { ISSN } from './jats-journal-meta-parser';
+export declare const jatsFrontParser: {
+    loadJournalBundles(issns: ISSN[]): Promise<{
+        manuscript_bundle: string | undefined;
+        bundleNodes: Bundle[];
+    }>;
+    parseCounts(counts: Element | null | undefined): {
+        wordCount: number | undefined;
+        figureCount: number | undefined;
+        tableCount: number | undefined;
+        equationCount: number | undefined;
+        referencesCount: number | undefined;
+        genericCounts: {
+            count: number;
+            countType: string;
+        }[] | undefined;
+    } | undefined;
+    parseJournal(journalMeta: Element | null): Partial<Journal>;
+    parseKeywords(keywordGroupNodes?: NodeListOf<Element> | null): {
+        groups: Build<KeywordGroup>[];
+        keywords: Build<Keyword>[];
+    };
+    parseDates(historyNode: Element | null): {
+        acceptanceDate?: number | undefined;
+        correctionDate?: number | undefined;
+        retractionDate?: number | undefined;
+        revisionRequestDate?: number | undefined;
+        revisionReceiveDate?: number | undefined;
+        receiveDate?: number | undefined;
+    } | undefined;
+    parseSupplements(supplementNodes: Element[] | null): Build<import("@manuscripts/manuscripts-json-schema").Supplement>[];
+    parseAffiliationNodes(affiliationNodes: Element[]): {
+        affiliations: Build<import("@manuscripts/manuscripts-json-schema").Affiliation>[];
+        affiliationIDs: Map<string, string>;
+    };
+    parseFootnoteNodes(footnoteNodes: Element[]): {
+        footnotes: Build<import("@manuscripts/manuscripts-json-schema").Footnote>[];
+        footnoteIDs: Map<string, string>;
+    };
+    parseCorrespNodes(correspNodes: Element[]): {
+        correspondingList: Build<import("@manuscripts/manuscripts-json-schema").Corresponding>[];
+        correspondingIDs: Map<string, string>;
+    };
+    parseAuthorNodes(authorNodes: Element[], affiliationIDs: Map<string, string>, footnoteIDs: Map<string, string>, correspondingIDs: Map<string, string>): Build<import("@manuscripts/manuscripts-json-schema").Contributor>[];
+};

package/dist/types/jats/importer/jats-journal-meta-parser.d.ts

@@ -0,0 +1,37 @@
+/*!
+ * © 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.
+ */
+export type ISSN = {
+    ISSN: string;
+    publicationType?: string;
+};
+export type AbbreviatedTitle = {
+    abbreviatedTitle: string;
+    abbrevType?: string;
+};
+export type JournalIdentifier = {
+    journalID: string;
+    journalIDType?: string;
+};
+export declare const parseJournalIdentifiers: (journalMeta: Element) => Array<JournalIdentifier>;
+export declare const parseJournalAbbreviatedTitles: (journalMeta: Element) => Array<AbbreviatedTitle>;
+export declare const parseJournalISSNs: (journalMeta: Element) => Array<ISSN>;
+export declare const parseJournalMeta: (journalMeta: Element) => {
+    abbreviatedTitles: AbbreviatedTitle[];
+    journalIdentifiers: JournalIdentifier[];
+    ISSNs: ISSN[];
+    publisherName: string | undefined;
+    title: string | undefined;
+};

package/dist/types/jats/importer/jats-parser-utils.d.ts

@@ -0,0 +1,23 @@
+/*!
+ * © 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 { Model } from '@manuscripts/manuscripts-json-schema';
+import { ManuscriptNode } from '../../schema';
+export declare function flatten<T>(arrays: T[][]): T[];
+export declare const fixBodyPMNode: (output: ManuscriptNode, models: Model[], referenceIdsMap?: Map<string, string>) => {
+    warnings: string[];
+    replacements: Map<string, string>;
+};
+export declare const htmlFromJatsNode: (element: Element | undefined | null, createElement: (tagName: string) => HTMLElement) => string | undefined;

package/dist/types/jats/importer/jats-reference-parser.d.ts

@@ -0,0 +1,23 @@
+/*!
+ * © 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.
+ */
+export declare const jatsReferenceParser: {
+    parseReferences(referenceNodes: Element[], createElement: (tagName: string) => HTMLElement): {
+        references: import("../../transformer/builders").Build<import("@manuscripts/manuscripts-json-schema").BibliographyItem>[];
+        referenceIDs: Map<string, string>;
+        referenceQueries: Map<string, string[]>;
+    };
+    parseCrossReferences(crossReferenceNodes: Element[], referenceIDs: Map<string, string>): (import("../../transformer/builders").Build<import("@manuscripts/manuscripts-json-schema").AuxiliaryObjectReference> | import("../../transformer/builders").Build<import("@manuscripts/manuscripts-json-schema").Citation>)[];
+};

package/dist/types/jats/importer/parse-jats-article.d.ts

@@ -0,0 +1,30 @@
+/*!
+ * © 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 { BibliographyItem, ElementsOrder, FootnotesOrder, Model } from '@manuscripts/manuscripts-json-schema';
+import { ManuscriptNode } from '../../schema';
+export declare const parseJATSFront: (front: Element) => Promise<{
+    models: Model[];
+    bundles: import("@manuscripts/manuscripts-json-schema").Bundle[];
+}>;
+export declare const parseJATSReferences: (back: Element | null, body: Element | null, createElement: (tagName: string) => HTMLElement) => {
+    references: Model[];
+    crossReferences: Model[];
+    referenceQueriesMap: Map<string, string[]> | undefined;
+    referenceIdsMap: Map<string, string> | undefined;
+};
+export declare const parseJATSBody: (document: Document, body: Element, bibliographyItems: BibliographyItem[] | null, refModels: Model[], referenceIdsMap: Map<string, string> | undefined, footnotesOrder?: FootnotesOrder) => ManuscriptNode;
+export declare const parseJATSArticle: (doc: Document) => Promise<Model[]>;
+export declare const getElementsOrder: (node: ManuscriptNode) => ElementsOrder[];

package/dist/types/jats/index.d.ts

@@ -0,0 +1,18 @@
+/*!
+ * © 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.
+ */
+export { parseJATSFront, parseJATSReferences, parseJATSBody, parseJATSArticle, getElementsOrder, } from './importer';
+export * from './jats-exporter';
+export * from './jats-versions';

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

@@ -0,0 +1,72 @@
+/*!
+ * © 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 { Model } from '@manuscripts/manuscripts-json-schema';
+import { DOMSerializer } from 'prosemirror-model';
+import { ManuscriptFragment, ManuscriptNode } from '../schema';
+import { Target } from '../transformer/labels';
+import { IDGenerator, MediaPathGenerator } from '../types';
+import { Version } from './jats-versions';
+interface Links {
+    self?: {
+        [key: string]: string;
+    };
+}
+export declare const createCounter: () => {
+    increment: (field: string) => number;
+};
+export interface JATSExporterOptions {
+    version?: Version;
+    doi?: string;
+    id?: string;
+    frontMatterOnly?: boolean;
+    links?: Links;
+    citationType?: 'element' | 'mixed';
+    idGenerator?: IDGenerator;
+    mediaPathGenerator?: MediaPathGenerator;
+}
+export declare class JATSExporter {
+    protected document: Document;
+    protected modelMap: Map<string, Model>;
+    protected models: Model[];
+    protected serializer: DOMSerializer;
+    protected labelTargets?: Map<string, Target>;
+    serializeToJATS: (fragment: ManuscriptFragment, modelMap: Map<string, Model>, manuscriptID: string, options?: JATSExporterOptions) => Promise<string>;
+    private nodeFromJATS;
+    protected rewriteCrossReferenceTypes: () => void;
+    protected rewriteMediaPaths: (mediaPathGenerator: MediaPathGenerator) => Promise<void>;
+    protected rewriteIDs: (idGenerator?: IDGenerator) => Promise<void>;
+    protected setTitleContent: (element: HTMLElement, title: string) => void;
+    protected buildFront: (doi?: string, id?: string, links?: Links) => HTMLElement;
+    protected buildDateElement: (timestamp: number, type: string) => HTMLElement;
+    protected buildCountingElement: (tagName: string, count: number | undefined) => HTMLElement | undefined;
+    protected buildBody: (fragment: ManuscriptFragment) => HTMLBodyElement;
+    protected buildBack: (body: HTMLElement) => HTMLElement;
+    protected createSerializer: () => void;
+    protected serializeFragment: (fragment: ManuscriptFragment) => HTMLElement | DocumentFragment;
+    protected serializeNode: (node: ManuscriptNode) => Node;
+    private validateContributor;
+    private buildContributors;
+    private buildKeywords;
+    private fixBody;
+    private changeTag;
+    private fixTable;
+    private moveAbstracts;
+    private moveSectionsToBack;
+    sectionToFootnote: (section: Element, fnType: string) => HTMLElement;
+    private moveFloatsGroup;
+    private buildContributorName;
+}
+export {};

package/dist/types/jats/jats-versions.d.ts

@@ -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.
+ */
+interface VersionIds {
+    publicId: string;
+    systemId: string;
+}
+export type Version = '1.1' | '1.2d1' | '1.2';
+export declare const supportedVersions: () => Version[];
+export declare const selectVersionIds: (version: Version) => VersionIds;
+export {};

package/dist/types/lib/attributes.d.ts

@@ -0,0 +1,20 @@
+/*!
+ * © 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.
+ */
+interface StyledNodeAttrs {
+    paragraphStyle?: string;
+}
+export declare const buildElementClass: (attrs: StyledNodeAttrs) => string;
+export {};