@manuscripts/transform 2.3.38-LEAN-3911.0 → 2.6.0

package/dist/es/{jats/exporter → transformer}/labels.js

@@ -13,19 +13,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { schema, } from '../../schema';
-import { nodeNames } from '../../transformer/node-names';
+import { schema } from '../schema';
+import { nodeNames } from './node-names';
 const labelledNodeTypes = [
     schema.nodes.figure_element,
     schema.nodes.table_element,
     schema.nodes.equation_element,
     schema.nodes.listing_element,
+    schema.nodes.box_element,
 ];
 const excludedTypes = [schema.nodes.graphical_abstract_section];
 const chooseLabel = (nodeType) => {
     return nodeNames.get(nodeType);
 };
-export const buildTargets = (node) => {
+export const buildTargets = (fragment) => {
     const counters = {};
     for (const nodeType of labelledNodeTypes) {
         counters[nodeType.name] = {
@@ -39,7 +40,7 @@ export const buildTargets = (node) => {
         return `${counter.label} ${counter.index}`;
     };
     const targets = new Map();
-    node.descendants((node, pos, parent) => {
+    fragment.descendants((node, pos, parent) => {
         var _a;
         if (node.type.name in counters) {
             if (parent && excludedTypes.includes(parent.type)) {

package/dist/es/transformer/manuscript-dependencies.js

@@ -0,0 +1,17 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { generateID } from './id';
+export const fromPrototype = (model) => {
+    const { _id } = model, data = __rest(model, ["_id"]);
+    const output = Object.assign(Object.assign({}, data), { prototype: _id, _id: generateID(model.objectType) });
+    return output;
+};

package/dist/es/transformer/model-map.js

@@ -0,0 +1,22 @@
+/*!
+ * © 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 addModelToMap = (modelMap) => (data) => {
+    if (!data._id) {
+        data._id = generateID(data.objectType);
+    }
+    modelMap.set(data._id, data);
+};

package/dist/es/{lib/deafults.js → transformer/models.js}

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

package/dist/es/transformer/node-names.js

@@ -36,4 +36,5 @@ export const nodeNames = new Map([
     [schema.nodes.pullquote_element, 'Pull Quote'],
     [schema.nodes.keywords, 'Section'],
     [schema.nodes.toc_section, 'Section'],
+    [schema.nodes.box_element, 'Box'],
 ]);

package/dist/es/transformer/object-types.js

@@ -0,0 +1,52 @@
+/*!
+ * © 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 { manuscriptIDTypes, ObjectTypes, } from '@manuscripts/json-schema';
+export var ExtraObjectTypes;
+(function (ExtraObjectTypes) {
+    ExtraObjectTypes["PlaceholderElement"] = "MPPlaceholderElement";
+    ExtraObjectTypes["GeneralTableFootnote"] = "MPGeneralTableFootnote";
+})(ExtraObjectTypes || (ExtraObjectTypes = {}));
+export const elementObjects = [
+    ObjectTypes.BibliographyElement,
+    ObjectTypes.EquationElement,
+    ObjectTypes.FigureElement,
+    ObjectTypes.FootnotesElement,
+    ObjectTypes.ListElement,
+    ObjectTypes.ListingElement,
+    ObjectTypes.ParagraphElement,
+    ObjectTypes.TableElement,
+    ObjectTypes.TOCElement,
+];
+export const manuscriptObjects = [
+    ObjectTypes.Affiliation,
+    ObjectTypes.Citation,
+    ObjectTypes.CommentAnnotation,
+    ObjectTypes.Contributor,
+    ObjectTypes.Footnote,
+    ObjectTypes.Section,
+].concat(elementObjects);
+export const isManuscriptModel = (model) => {
+    if (!model.objectType) {
+        throw new Error('Model must have objectType');
+    }
+    return manuscriptIDTypes.has(model.objectType);
+};
+export const hasObjectType = (objectType) => (model) => model.objectType === objectType;
+export const isFigure = hasObjectType(ObjectTypes.Figure);
+export const isManuscript = hasObjectType(ObjectTypes.Manuscript);
+export const isTable = hasObjectType(ObjectTypes.Table);
+export const isCommentAnnotation = hasObjectType(ObjectTypes.CommentAnnotation);
+export const isKeyword = hasObjectType(ObjectTypes.Keyword);

package/dist/es/transformer/project-bundle.js

@@ -0,0 +1,85 @@
+/*!
+ * © 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 { ObjectTypes, } from '@manuscripts/json-schema';
+import { Decoder } from './decode';
+import { hasObjectType } from './object-types';
+export const parseProjectBundle = (projectBundle, manuscriptID) => {
+    const manuscriptData = manuscriptID
+        ? projectBundle.data.filter((doc) => !doc.manuscriptID || doc.manuscriptID === manuscriptID)
+        : projectBundle.data;
+    const modelMap = new Map();
+    for (const component of manuscriptData) {
+        modelMap.set(component._id, component);
+    }
+    const decoder = new Decoder(modelMap);
+    const doc = decoder.createArticleNode();
+    return { doc, modelMap };
+};
+const isManuscript = hasObjectType(ObjectTypes.Manuscript);
+export const findManuscript = (modelMap) => {
+    for (const model of modelMap.values()) {
+        if (isManuscript(model)) {
+            return model;
+        }
+    }
+    throw new Error('No manuscript found');
+};
+const isJournal = hasObjectType(ObjectTypes.Journal);
+export const findJournal = (modelMap) => {
+    for (const model of modelMap.values()) {
+        if (isJournal(model)) {
+            return model;
+        }
+    }
+    return null;
+};
+const isManuscriptModel = (model) => 'manuscriptID' in model;
+export const findManuscriptModelByType = (modelMap, manuscript, objectType) => {
+    for (const model of modelMap.values()) {
+        if (model.objectType === objectType &&
+            isManuscriptModel(model) &&
+            manuscript._id === model.manuscriptID) {
+            return model;
+        }
+    }
+};
+export const findManuscriptById = (modelMap, manuscriptID) => {
+    const manuscript = modelMap.get(manuscriptID);
+    if (manuscript && isManuscript(manuscript)) {
+        return manuscript;
+    }
+    throw new Error(`There is no manuscript found for the following _id (${manuscriptID})`);
+};
+const isTitle = hasObjectType(ObjectTypes.Titles);
+export const findTitles = (modelMap) => {
+    for (const model of modelMap.values()) {
+        if (isTitle(model)) {
+            return model;
+        }
+    }
+    const defaultTitle = {
+        _id: 'MPTitles:8EB79C14-9F61-483A-902F-A0B8EF5973C1',
+        createdAt: 1538472121.690101,
+        updatedAt: 1538472121.690101,
+        objectType: 'MPTitles',
+        title: 'main title',
+        subtitle: 'subtitle',
+        runningTitle: 'running title',
+        manuscriptID: 'MPManuscript:E3830344-E77B-42BA-BD77-3E95489712A0',
+        containerID: 'MPProject:1',
+    };
+    return defaultTitle;
+};

package/dist/es/transformer/serializer.js

@@ -0,0 +1,17 @@
+/*!
+ * © 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 serializeToString from 'w3c-xmlserializer';
+export const xmlSerializer = { serializeToString };

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/version.js

@@ -1 +1 @@
-export const VERSION = "2.3.38-LEAN-3911.0";
+export const VERSION = "2.6.0";

package/dist/types/index.d.ts

@@ -1,11 +1,11 @@
-export * from './errors';
-export { getVersion } from './getVersion';
-export * from './jats';
-export * from './jats/types';
 export * from './lib/section-group-type';
 export * from './lib/table-cell-styles';
 export * from './lib/utils';
 export * from './schema';
-export { JSONNode, migrateFor } from './schema/migration/migrate';
-export { isSectionLabelNode } from './schema/nodes/section_label';
 export * from './transformer';
+export * from './jats';
+export * from './types';
+export * from './errors';
+export { getVersion } from './getVersion';
+export { migrateFor, JSONNode } from './schema/migration/migrate';
+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, parseJATSArticle, } from './parse-jats-article';

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

@@ -21,4 +21,4 @@ export type MarkRule = ParseRule & {
 export type NodeRule = ParseRule & {
     node?: Nodes | null;
 };
-export declare const jatsDOMParser: DOMParser;
+export declare const jatsBodyDOMParser: DOMParser;

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

@@ -13,8 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { BibliographyItemAttrs } from '../../schema';
-import { References } from './jats-references';
 export declare const jatsBodyTransformations: {
     ensureSection(body: Element, createElement: (tagName: string) => HTMLElement): void;
     createAbstractSection(abstractNode: Element, createElement: (tagName: string) => HTMLElement): HTMLElement;
@@ -27,6 +25,7 @@ export declare const jatsBodyTransformations: {
     moveBackSections(doc: Document, group: Element): void;
     moveAcknowledgments(doc: Document, group: Element, createElement: (tagName: string) => HTMLElement): void;
     moveAppendices(doc: Document, group: Element, createElement: (tagName: string) => HTMLElement): void;
+    createBoxedElementSection(doc: Document, body: Element, createElement: (tagName: string) => HTMLElement): void;
     createBody(doc: Document, body: Element, createElement: (tagName: string) => HTMLElement): void;
     createAbstracts(doc: Document, body: Element, createElement: (tagName: string) => HTMLElement): void;
     createBackmatter(doc: Document, body: Element, createElement: (tagName: string) => HTMLElement): void;
@@ -38,7 +37,4 @@ export declare const jatsBodyTransformations: {
     moveFloatsGroupToBody(doc: Document, body: Element, createElement: (tagName: string) => HTMLElement): void;
     createKeywords(document: Document, body: Element, createElement: (tagName: string) => HTMLElement): void;
     createSuppleMaterials(document: Document, body: Element, createElement: (tagName: string) => HTMLElement): void;
-    moveReferencesToBackmatter(body: Element, references: References | undefined, createElement: (tagName: string) => HTMLElement): void;
-    createBibliographySection(createElement: (tagName: string) => HTMLElement): HTMLElement;
-    createBibliographyItem(item: BibliographyItemAttrs, createElement: (tagName: string) => HTMLElement): HTMLElement;
 };

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

@@ -13,12 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { CommentAnnotation, Model } from '@manuscripts/json-schema';
+import { References } from './jats-references';
 export type JATSComment = {
-    index: number;
-    text: string;
     id: string;
+    text: string;
+};
+export type JATSCommentMark = {
+    token: string;
+    comment: JATSComment;
 };
-export declare const DEFAULT_PROFILE_ID = "MPUserProfile:0000000000000000000000000000000000000001";
 export declare const isJATSComment: (node: Node) => boolean;
 export declare const parseJATSComment: (node: Node) => JATSComment | undefined;
-export declare const markComments: (doc: Document) => void;
+export declare const markComments: (doc: Document) => JATSCommentMark[];
+export declare const createComments: (models: Model[], marks: JATSCommentMark[]) => CommentAnnotation[];
+export declare const createReferenceComments: (references: References) => CommentAnnotation[];

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

@@ -0,0 +1,84 @@
+/*!
+ * © 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 jatsFrontParser: {
+    parseTitles(element: Element | null, createElement: (tagName: string) => HTMLElement): import("../../transformer").Build<import("@manuscripts/json-schema/dist/types").Titles>;
+    parseDOI(front: Element | null): string | undefined;
+    parseCounts(counts: Element | null): {
+        wordCount: number | undefined;
+        figureCount: number | undefined;
+        tableCount: number | undefined;
+        equationCount: number | undefined;
+        referencesCount: number | undefined;
+        genericCounts: {
+            count: number | undefined;
+            countType: string;
+        }[] | undefined;
+    } | undefined;
+    parseJournal(element: Element | null): {
+        title: string | undefined;
+        templateID?: string | undefined;
+        ISSNs: {
+            [k: string]: any;
+            ISSN: string;
+            publicationType?: string | undefined;
+        }[];
+        abbreviatedTitles: {
+            [k: string]: any;
+            abbreviatedTitle: string;
+            abbrevType?: string | undefined;
+        }[];
+        journalIdentifiers: {
+            [k: string]: any;
+            journalID: string;
+            journalIDType?: string | undefined;
+        }[];
+        submittable?: boolean | undefined;
+        publisherName: string | undefined;
+        _id: string;
+        objectType: string;
+        contributions?: import("@manuscripts/json-schema/dist/types").Contribution[] | undefined;
+    };
+    parseDates(historyNode: Element | null): {
+        acceptanceDate?: number | undefined;
+        correctionDate?: number | undefined;
+        retractionDate?: number | undefined;
+        revisionRequestDate?: number | undefined;
+        revisionReceiveDate?: number | undefined;
+        receiveDate?: number | undefined;
+    } | undefined;
+    parseAffiliations(elements: Element[]): {
+        affiliations: import("../../transformer").Build<import("@manuscripts/json-schema/dist/types").Affiliation>[];
+        affiliationIDs: Map<string, string>;
+    };
+    parseAuthorNotes(element: Element | null): {
+        footnotes: import("../../transformer").Build<import("@manuscripts/json-schema/dist/types").Footnote>[];
+        footnoteIDs: Map<string, string>;
+        authorNotesParagraphs: import("../../transformer").Build<import("@manuscripts/json-schema/dist/types").ParagraphElement>[];
+        authorNotes: import("../../transformer").Build<import("@manuscripts/json-schema/dist/types").AuthorNotes>[];
+        correspondingIDs: Map<string, string>;
+        correspondingList: import("../../transformer").Build<import("@manuscripts/json-schema/dist/types").Corresponding>[];
+    };
+    parseParagraphs(elements: Element[]): import("../../transformer").Build<import("@manuscripts/json-schema/dist/types").ParagraphElement>[];
+    parseFootnotes(elements: Element[]): {
+        footnotes: import("../../transformer").Build<import("@manuscripts/json-schema/dist/types").Footnote>[];
+        footnoteIDs: Map<string, string>;
+    };
+    parseCorresp(elements: Element[]): {
+        correspondingList: import("../../transformer").Build<import("@manuscripts/json-schema/dist/types").Corresponding>[];
+        correspondingIDs: Map<string, string>;
+    };
+    parseContributors(elements: Element[], affiliationIDs: Map<string, string>, footnoteIDs: Map<string, string>, correspondingIDs: Map<string, string>): import("../../transformer").Build<import("@manuscripts/json-schema/dist/types").Contributor>[];
+};

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

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ObjectTypes } from '@manuscripts/json-schema';
 export type ISSN = {
     ISSN: string;
     publicationType?: string;
@@ -36,12 +35,3 @@ export declare const parseJournalMeta: (element: Element | null) => {
     publisherName: string | undefined;
     title: string | undefined;
 };
-export declare const parseJournal: (element: Element | null) => {
-    _id: string;
-    objectType: ObjectTypes;
-    abbreviatedTitles: AbbreviatedTitle[];
-    journalIdentifiers: JournalIdentifier[];
-    ISSNs: ISSN[];
-    publisherName: string | undefined;
-    title: string | undefined;
-};

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

@@ -1,23 +1,12 @@
-/*!
- * © 2023 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 { BibliographyItemAttrs } from '../../schema';
+import { BibliographyItem } from '@manuscripts/json-schema';
+import { JATSComment } from './jats-comments';
 export declare class References {
-    items: Map<string, BibliographyItemAttrs>;
+    items: Map<string, BibliographyItem>;
     IDs: Map<string, string>;
+    comments: Map<string, JATSComment[]>;
     constructor();
-    add(item: BibliographyItemAttrs, id: string | null): void;
-    getBibliographyItems(): BibliographyItemAttrs[];
+    add(item: BibliographyItem, id: string | null, comments: JATSComment[]): void;
+    getBibliographyItems(): BibliographyItem[];
+    getComments(id: string): JATSComment[];
+    private getValue;
 }

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

@@ -13,15 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export declare const parseJATSArticle: (doc: Document, template?: string) => {
-    node: import("prosemirror-model").Node;
-    journal: {
-        _id: string;
-        objectType: import("@manuscripts/json-schema/dist/types").ObjectTypes;
-        abbreviatedTitles: import("./jats-journal-meta-parser").AbbreviatedTitle[];
-        journalIdentifiers: import("./jats-journal-meta-parser").JournalIdentifier[];
-        ISSNs: import("./jats-journal-meta-parser").ISSN[];
-        publisherName: string | undefined;
-        title: string | undefined;
-    };
-};
+import { Model } from '@manuscripts/json-schema';
+import { References } from './jats-references';
+export declare const parseJATSFront: (doc: Document, front: Element) => Model[];
+export declare const parseJATSBody: (doc: Document, body: Element, references?: References) => IterableIterator<Model>;
+export declare const parseJATSArticle: (doc: Document) => Model[];

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

@@ -13,8 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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';
+export { parseJATSFront, parseJATSBody, parseJATSArticle } from './importer';
+export * from './jats-exporter';
+export * from './jats-versions';