jats-xml 0.1.0 → 1.0.0

package/README.md

@@ -106,3 +106,16 @@ selectAll('fig', jats.body) // Or selectAll figures
 ## Write JATS in Node
 
 TODO!
+
+---
+
+As of v1.0.0 this package is [ESM only](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c).
+
+---
+
+<p style="text-align: center; color: #aaa; padding-top: 50px">
+  Made with love by
+  <a href="https://curvenote.com" target="_blank" style="color: #aaa">
+    <img src="https://curvenote.dev/images/icon.png" style="height: 1em" /> Curvenote
+  </a>
+</p>

package/dist/{types/cli → cli}/download.d.ts

@@ -1,4 +1,4 @@
-import type { ISession, Options } from '../types';
+import type { ISession, Options } from '../types.js';
 /**
  * https://www.ncbi.nlm.nih.gov/pmc/tools/id-converter-api/
  */
@@ -9,4 +9,3 @@ export declare function downloadJatsFromUrl(session: ISession, urlOrDoi: string,
     source: string;
     data?: string;
 }>;
-//# sourceMappingURL=download.d.ts.map

package/dist/cli/download.js

@@ -0,0 +1,158 @@
+import { doi } from 'doi-utils';
+import fetch from 'node-fetch';
+import { isUrl, tic } from 'myst-cli-utils';
+import { customResolveJatsUrlFromDoi } from '../resolvers.js';
+async function downloadFromUrl(session, jatsUrl, opts) {
+    var _a, _b;
+    const toc = tic();
+    session.log.debug(`Fetching JATS from ${jatsUrl}`);
+    const resp = await ((_a = opts === null || opts === void 0 ? void 0 : opts.fetcher) !== null && _a !== void 0 ? _a : defaultFetcher)(jatsUrl, 'xml');
+    if (!resp.ok) {
+        session.log.debug(`JATS failed to download from "${jatsUrl}"`);
+        throw new Error(`STATUS ${resp.status}: ${resp.statusText}`);
+    }
+    const contentType = (_b = resp.headers) === null || _b === void 0 ? void 0 : _b.get('content-type');
+    if (!((contentType === null || contentType === void 0 ? void 0 : contentType.includes('application/xml')) ||
+        (contentType === null || contentType === void 0 ? void 0 : contentType.includes('text/xml')) ||
+        (contentType === null || contentType === void 0 ? void 0 : contentType.includes('text/plain')))) {
+        session.log.warn(`Expected content-type "application/xml" instead we got "${contentType}" for ${jatsUrl}`);
+    }
+    const data = await resp.text();
+    session.log.debug(toc(`Fetched document with content-type "${contentType}" in %s`));
+    return data;
+}
+function defaultFetcher(url, kind) {
+    switch (kind) {
+        case 'json':
+            return fetch(url, { headers: [['Accept', 'application/json']] });
+        case 'xml':
+            return fetch(url, { headers: [['Accept', 'application/xml']] });
+        default:
+            return fetch(url);
+    }
+}
+/**
+ * There are 5.8M or so DOIs that have a full XML record:
+ *
+ * https://api.crossref.org/works?filter=full-text.type:application/xml,full-text.application:text-mining&facet=publisher-name:*&rows=0
+ *
+ * This function tries to find the correct URL for the record.
+ */
+async function checkIfDoiHasJats(session, urlOrDoi, opts) {
+    var _a, _b, _c, _d, _e;
+    if (!doi.validate(urlOrDoi))
+        return;
+    const toc = tic();
+    const doiUrl = doi.buildUrl(urlOrDoi);
+    session.log.debug(`Attempting to resolving full XML from DOI ${doiUrl}`);
+    const resp = await ((_a = opts === null || opts === void 0 ? void 0 : opts.fetcher) !== null && _a !== void 0 ? _a : defaultFetcher)(doiUrl, 'json');
+    if (!resp.ok) {
+        // Silently return -- other functions can try!
+        session.log.debug(`DOI failed to resolve: ${doiUrl}`);
+        return;
+    }
+    const data = (await resp.json());
+    session.log.debug(toc(`DOI resolved in %s with ${(_c = (_b = data.link) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0} links to content`));
+    if (data.link) {
+        session.log.debug(['', ...data.link.map((link) => `content-type: ${link['content-type']}, ${link.URL}\n`)].join('  - '));
+    }
+    const fullXml = (_e = (_d = data.link) === null || _d === void 0 ? void 0 : _d.find((link) => { var _a; return ['text/xml', 'application/xml'].includes((_a = link['content-type']) !== null && _a !== void 0 ? _a : ''); })) === null || _e === void 0 ? void 0 : _e.URL;
+    if (fullXml)
+        return fullXml;
+    session.log.debug(`Could not find XML in DOI record ${doiUrl}`);
+    return undefined;
+}
+/**
+ * https://www.ncbi.nlm.nih.gov/pmc/tools/id-converter-api/
+ */
+export async function convertPMID2PMCID(session, PMID, opts) {
+    var _a, _b, _c;
+    if (PMID.startsWith('https://')) {
+        const idPart = new URL(PMID).pathname.slice(1);
+        session.log.debug(`Extract ${PMID} to ${idPart}`);
+        return convertPMID2PMCID(session, idPart, opts);
+    }
+    const toc = tic();
+    const converter = 'https://www.ncbi.nlm.nih.gov/pmc/utils/idconv/v1.0/';
+    const resp = await ((_a = opts === null || opts === void 0 ? void 0 : opts.fetcher) !== null && _a !== void 0 ? _a : defaultFetcher)(`${converter}?tool=jats-xml&format=json&ids=${PMID}`, 'json');
+    if (!resp.ok) {
+        // Silently return -- other functions can try!
+        session.log.debug(`Failed to convert PubMedID: ${PMID}`);
+        return;
+    }
+    const data = await resp.json();
+    const PMCID = (_c = (_b = data === null || data === void 0 ? void 0 : data.records) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.pmcid;
+    session.log.debug(toc(`Used nih.gov to transform ${PMID} to ${PMCID} in %s.`));
+    return PMCID;
+}
+function pubMedCentralJats(PMCID) {
+    const normalized = PMCID.replace(/^PMC:?/, '');
+    return `https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=pmc&id=${normalized}`;
+}
+export async function checkIfPubMedCentralHasJats(session, urlOrDoi, opts) {
+    var _a, _b, _c;
+    if (urlOrDoi.match(/^PMC:?([0-9]+)$/))
+        return pubMedCentralJats(urlOrDoi);
+    if (!doi.validate(urlOrDoi))
+        return;
+    const toc = tic();
+    const doiUrl = doi.buildUrl(urlOrDoi);
+    session.log.debug(`Attempting to resolve PMCID using OpenAlex from ${doiUrl}`);
+    const openAlexUrl = `https://api.openalex.org/works/${doiUrl}`;
+    const resp = await ((_a = opts === null || opts === void 0 ? void 0 : opts.fetcher) !== null && _a !== void 0 ? _a : defaultFetcher)(openAlexUrl, 'json');
+    if (!resp.ok) {
+        // Silently return -- other functions can try!
+        session.log.debug(`Failed to lookup on OpenAlex: ${openAlexUrl}`);
+        return;
+    }
+    const data = (await resp.json());
+    const PMID = (_b = data === null || data === void 0 ? void 0 : data.ids) === null || _b === void 0 ? void 0 : _b.pmid;
+    let PMCID = (_c = data === null || data === void 0 ? void 0 : data.ids) === null || _c === void 0 ? void 0 : _c.pmcid;
+    if (!PMCID && !!PMID) {
+        session.log.debug(toc(`OpenAlex resolved ${data === null || data === void 0 ? void 0 : data.ids.openalex} in %s. There is no PMCID, but there is a PMID`));
+        PMCID = await convertPMID2PMCID(session, PMID, opts);
+        if (!PMCID) {
+            session.log.debug(toc(`PubMed does not have a record of ${PMID}`));
+            return;
+        }
+    }
+    if (!PMCID) {
+        session.log.debug(toc(`OpenAlex resolved ${data === null || data === void 0 ? void 0 : data.ids.openalex} in %s, but there is no PMCID`));
+        return;
+    }
+    session.log.debug(toc(`OpenAlex resolved in %s, with a PMCID of ${PMCID}`));
+    return pubMedCentralJats(PMCID);
+}
+export async function downloadJatsFromUrl(session, urlOrDoi, opts = {}) {
+    const expectedUrls = (await Promise.all([
+        checkIfPubMedCentralHasJats(session, urlOrDoi, opts),
+        checkIfDoiHasJats(session, urlOrDoi, opts),
+    ])).filter((u) => !!u);
+    if (expectedUrls.length > 0) {
+        session.log.debug(['Trying URLs:\n', ...expectedUrls.map((url) => ` ${url}\n`)].join('  - '));
+        for (let index = 0; index < expectedUrls.length; index++) {
+            const url = expectedUrls[index];
+            try {
+                const data = await downloadFromUrl(session, url, opts);
+                if (data)
+                    return { success: true, source: url, data };
+            }
+            catch (error) {
+                session.log.debug(error.message);
+            }
+        }
+        // If there are expected URLs that don't work: see something, say something, etc.
+        return { success: false, source: expectedUrls[0] };
+    }
+    if (doi.validate(urlOrDoi)) {
+        const jatsUrl = await customResolveJatsUrlFromDoi(session, urlOrDoi, opts);
+        const data = await downloadFromUrl(session, jatsUrl, opts);
+        return { success: true, source: jatsUrl, data };
+    }
+    if (isUrl(urlOrDoi)) {
+        session.log.debug("No resolver matched, and the URL doesn't look like a DOI. We will attempt to download it directly.");
+        const data = await downloadFromUrl(session, urlOrDoi, opts);
+        return { success: true, source: urlOrDoi, data };
+    }
+    throw new Error(`Could not find ${urlOrDoi} locally, and it doesn't look like a URL or DOI`);
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/{esm/cli → cli}/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import commander from 'commander';
-import version from '../version';
-import { addDownloadCLI } from './parse';
-import { addValidateCLI } from './validate';
-import { addTestCLI } from './jats-test';
-const program = new commander.Command();
+import { Command } from 'commander';
+import version from '../version.js';
+import { addDownloadCLI } from './parse.js';
+import { addValidateCLI } from './validate.js';
+import { addTestCLI } from './jats-test.js';
+const program = new Command();
 addDownloadCLI(program);
 addValidateCLI(program);
 addTestCLI(program);

package/dist/{types/cli → cli}/jats-test.d.ts

@@ -1,9 +1,8 @@
 import { Command } from 'commander';
-import type { ISession } from '../types';
+import type { ISession } from '../types.js';
 type Options = {
     cases: string;
 };
 export declare function testJatsFile(session: ISession, file: string, opts: Options): Promise<boolean>;
 export declare function addTestCLI(program: Command): void;
 export {};
-//# sourceMappingURL=jats-test.d.ts.map

package/dist/cli/jats-test.js

@@ -0,0 +1,106 @@
+import { Command, Option } from 'commander';
+import { clirun, tic } from 'myst-cli-utils';
+import yaml from 'js-yaml';
+import fs from 'fs';
+import { select, selectAll } from 'unist-util-select';
+import { is } from 'unist-util-is';
+import chalk from 'chalk';
+import { getSession } from '../session.js';
+import { parseJats } from './parse.js';
+const INDENT = '       ';
+function printNodes(expected, received) {
+    return chalk.reset(`\n${INDENT}${chalk.greenBright('Expected node containing')}:\n${INDENT}  ${yaml
+        .dump(expected)
+        .replace(/\n/g, `\n${INDENT}  `)}\n${INDENT}${chalk.redBright('Received node')}:\n${INDENT}  ${yaml.dump(received).replace(/\n/g, `\n${INDENT}  `)}`);
+}
+export async function testJatsFile(session, file, opts) {
+    const toc = tic();
+    const jats = await parseJats(session, file);
+    const tests = yaml.load(fs.readFileSync(opts.cases).toString());
+    const results = tests.cases.map((testCase, index) => {
+        if (!testCase.title) {
+            return [`Test Case ${index}`, null, 'Test must include a title'];
+        }
+        if (testCase.equals === undefined) {
+            return [testCase.title, null, 'Test must have an equals statement'];
+        }
+        if (testCase.select) {
+            const node = select(testCase.select, jats.tree);
+            const pass = is(node, testCase.equals);
+            if (testCase.equals == null && node) {
+                return [testCase.title, false, 'Expected no node to be present'];
+            }
+            if (!node && testCase.equals == null)
+                return [testCase.title, true];
+            if (!node)
+                return [testCase.title, false];
+            let failed = false;
+            const messages = [];
+            if (!pass) {
+                failed = failed || true;
+                messages.push(`Failed to validate node\n${printNodes(testCase.equals, node)}`);
+            }
+            return [testCase.title, !failed, messages.join('\n')];
+        }
+        else if (testCase.selectAll) {
+            const testNodes = selectAll(testCase.selectAll, jats.tree);
+            if (!testNodes && testCase.equals == null)
+                return [testCase.title, true];
+            if (!testNodes)
+                return [testCase.title, false, 'Node not found'];
+            let equals = testCase.equals;
+            if (!Array.isArray(testCase.equals)) {
+                equals = Array(testNodes.length).fill(testCase.equals);
+            }
+            let failed = false;
+            const messages = [];
+            if (equals.length !== testNodes.length) {
+                failed = failed || true;
+                messages.push(`Expected ${equals.length} nodes, got ${testNodes.length}\n${printNodes(equals, testNodes)}`);
+            }
+            else {
+                equals.forEach((node, ii) => {
+                    const pass = is(testNodes[ii], node);
+                    if (!pass) {
+                        failed = failed || true;
+                        messages.push(`Failed to validate node ${ii}\n${printNodes(node, testNodes[ii])}`);
+                    }
+                });
+            }
+            return [testCase.title, !failed, messages.join('\n')];
+        }
+        else {
+            return [testCase.title, false, 'Test must have either `select` or `selectAll`'];
+        }
+    });
+    results.forEach((result) => {
+        const [title, pass, message] = result;
+        if (pass === null)
+            session.log.info(`${chalk.redBright.bold(`ERROR`)} - ${title}\n  ${chalk.blueBright(message)}`);
+        else if (pass)
+            session.log.info(`${chalk.green(`PASS`)} - ${title}`);
+        else
+            session.log.info(`${chalk.red(`FAIL`)} - ${title}\n\n${INDENT}${chalk.blueBright(message)}\n`);
+    }, true);
+    const passed = results.reduce((num, [, pass]) => num + (pass ? 1 : 0), 0);
+    const failed = results.length - passed;
+    if (failed > 0 && passed === 0) {
+        throw new Error(toc(`${chalk.red(`Failed ${failed} tests in %s`)} 👎`));
+    }
+    if (failed > 0) {
+        throw new Error(toc(`${chalk.green(`Passed ${passed}/${results.length} tests in %s`)}\n${chalk.red(`Failed ${failed} tests`)} 👎`));
+    }
+    session.log.info(chalk.green(toc(`Passed ${passed} tests in %s 🚀`)));
+    return true;
+}
+function makeTestCLI(program) {
+    const command = new Command('test')
+        .description('Test JATS file against a list of cases')
+        .argument('<file>', 'JATS file to test')
+        .addOption(new Option('--cases <value>', 'The YAML file of unit tests to test against'))
+        .action(clirun(testJatsFile, { program, getSession }));
+    return command;
+}
+export function addTestCLI(program) {
+    program.addCommand(makeTestCLI(program));
+}

package/dist/{types/cli → cli}/parse.d.ts

@@ -1,6 +1,5 @@
 import { Command } from 'commander';
-import type { ISession, Options } from '../types';
-import { Jats } from '../jats';
+import type { ISession, Options } from '../types.js';
+import { Jats } from '../jats.js';
 export declare function parseJats(session: ISession, file: string, opts?: Options): Promise<Jats>;
 export declare function addDownloadCLI(program: Command): void;
-//# sourceMappingURL=parse.d.ts.map

package/dist/cli/parse.js

@@ -0,0 +1,200 @@
+import { Command } from 'commander';
+import fs from 'fs';
+import { extname } from 'path';
+import { clirun, isUrl, tic, writeFileToFolder } from 'myst-cli-utils';
+import { doi } from 'doi-utils';
+import chalk from 'chalk';
+import { formatPrinciples, highlightFAIR } from 'fair-principles';
+import { Tags } from 'jats-tags';
+import { toText } from 'myst-common';
+import { select, selectAll } from 'unist-util-select';
+import { getSession } from '../session.js';
+import { Jats } from '../jats.js';
+import { downloadJatsFromUrl } from './download.js';
+import { DEFAULT_RESOLVERS } from '../resolvers.js';
+import { findArticleId, formatDate, toDate } from '../utils.js';
+function hasValidExtension(output) {
+    return ['.xml', '.jats'].includes(extname(output).toLowerCase());
+}
+async function downloadAndSaveJats(session, urlOrDoi, output, opts = { resolvers: DEFAULT_RESOLVERS }) {
+    if (fs.existsSync(urlOrDoi)) {
+        throw new Error(`File "${urlOrDoi}" is local and cannot be downloaded!`);
+    }
+    if (!(doi.validate(urlOrDoi) || isUrl(urlOrDoi))) {
+        throw new Error(`Path must be a URL or DOI, not "${urlOrDoi}"`);
+    }
+    if (!hasValidExtension(output)) {
+        session.log.warn(`The extension ${extname(output)} is not a valid extension for JATS, try using ".xml" or ".jats"`);
+    }
+    const { success, data, source } = await downloadJatsFromUrl(session, urlOrDoi, opts);
+    if (!success || !data) {
+        logAboutJatsFailing(session, [source]);
+        process.exit(1);
+    }
+    writeFileToFolder(output, data);
+    return data;
+}
+function logAboutJatsFailing(session, jatsUrls) {
+    session.log.warn('⛔️ JATS may not be Open Access 😭, you should petition your local representative 🪧');
+    session.log.info(`${chalk.green(`\nThe XML ${chalk.bold('should')} be here:\n\n${jatsUrls.join('\n')}`)}\n`);
+    const FAIR = highlightFAIR('A', { chalk });
+    session.log.info(`Some publishers aggressively block programmatic access, which isn't ${FAIR}.`);
+    session.log.debug(formatPrinciples('A*', { chalk }));
+    session.log.info(`\n${chalk.blue('The link may work in a browser.')}\n`);
+}
+export async function parseJats(session, file, opts = { resolvers: DEFAULT_RESOLVERS }) {
+    const toc = tic();
+    if (fs.existsSync(file)) {
+        session.log.debug(`Found ${file} locally, parsing`);
+        const data = fs.readFileSync(file).toString();
+        return new Jats(data, { log: session.log });
+    }
+    const { success, source, data } = await downloadJatsFromUrl(session, file, opts);
+    if (!success || !data) {
+        logAboutJatsFailing(session, [source]);
+        process.exit(1);
+    }
+    const jats = new Jats(data, { source, log: session.log });
+    session.log.debug(toc(`Downloaded and parsed JATS file in %s`));
+    return jats;
+}
+function formatLongString(data, offset = 0, length = 88 - offset) {
+    const out = [data.slice(0, length)];
+    let left = data.slice(length);
+    while (left.length > length) {
+        out.push(left.slice(0, length).trim());
+        left = left.slice(length);
+    }
+    if (left)
+        out.push(left.trim());
+    return out.join(`\n${' '.repeat(offset)}`);
+}
+function formatDictionary(dict, opts) {
+    const maxLabel = Object.keys(dict).reduce((a, b) => Math.max(a, b.length), 0);
+    return Object.entries(dict)
+        .map(([k, t]) => {
+        var _a;
+        if (!t)
+            return null;
+        let wrap = typeof (opts === null || opts === void 0 ? void 0 : opts.wrap) === 'boolean' ? opts.wrap : true;
+        let value = t;
+        let color = chalk.yellow.bold;
+        if (t && typeof t === 'object') {
+            if (!t.value)
+                return null;
+            color = (_a = t.label) !== null && _a !== void 0 ? _a : color;
+            value = t.value;
+            wrap = typeof t.wrap === 'boolean' ? t.wrap : wrap;
+        }
+        const wrapped = wrap ? formatLongString(String(value), maxLabel + 2) : String(value);
+        return `${color(k)}:${' '.repeat(maxLabel - k.length + 1)}${wrapped}`;
+    })
+        .filter((o) => !!o)
+        .join('\n');
+}
+async function jatsSummaryCLI(session, file) {
+    var _a, _b, _c;
+    const jats = await parseJats(session, file);
+    const summary = {
+        Source: { value: jats.source, wrap: false },
+        DOI: jats.doi ? { value: doi.buildUrl(jats.doi), wrap: false } : null,
+        Title: (_a = toText(jats.articleTitle)) === null || _a === void 0 ? void 0 : _a.replace(/\n/g, ' '),
+        Date: formatDate(toDate(jats.publicationDate)),
+        Authors: jats.articleAuthors
+            .map((a) => `${toText(select(Tags.givenNames, a))} ${toText(select(Tags.surname, a))}`)
+            .join(', '),
+        Abstract: (_b = toText(jats.abstract)) === null || _b === void 0 ? void 0 : _b.replace(/\n/g, ' '),
+        Keywords: jats.keywords.map((k) => toText(k)).join(', '),
+        License: (_c = jats.license) === null || _c === void 0 ? void 0 : _c['xlink:href'],
+    };
+    if (jats.body) {
+        summary.Figures = {
+            label: chalk.blue.bold,
+            value: String(selectAll(Tags.fig, jats.body).length),
+        };
+        summary.Equations = {
+            label: chalk.blue.bold,
+            value: String(selectAll(Tags.dispFormula, jats.body).length),
+        };
+        summary.Tables = {
+            label: chalk.blue.bold,
+            value: String(selectAll(Tags.table, jats.body).length),
+        };
+        summary.Code = {
+            label: chalk.blue.bold,
+            value: String(selectAll(Tags.code, jats.body).length),
+        };
+        summary.Sections = {
+            label: chalk.blue.bold,
+            value: String(selectAll(Tags.sec, jats.body).length),
+        };
+        summary.Paragraphs = {
+            label: chalk.blue.bold,
+            value: String(selectAll(Tags.p, jats.body).length),
+        };
+        summary.Citations = { label: chalk.blue.bold, value: String(jats.references.length) };
+        summary['Cross-References'] = {
+            label: chalk.blue.bold,
+            value: String(selectAll(Tags.xref, jats.body).length),
+        };
+        summary['Sub Articles'] = { label: chalk.blue.bold, value: String(jats.subArticles.length) };
+    }
+    session.log.info(formatDictionary(summary));
+    if (!jats.body) {
+        session.log.warn('\nThis is a partial JATS record that does not have <body>.');
+    }
+}
+async function jatsReferencesCLI(session, file) {
+    const jats = await parseJats(session, file);
+    const sorted = jats.references
+        .map((ref) => {
+        const doiString = findArticleId(ref, 'doi');
+        const title = toText(select(Tags.articleTitle, ref));
+        const year = toText(select(Tags.year, ref));
+        const surnames = selectAll(Tags.surname, ref);
+        const short = surnames.length > 2
+            ? toText(surnames[0]) + ' et al.'
+            : surnames.length === 2
+                ? toText(surnames[0]) + ' and ' + toText(surnames[1])
+                : toText(surnames[0]);
+        const s = selectAll(`[rid=${ref.id}]`, jats.body);
+        return {
+            Citation: `${short} (${year})`,
+            Title: title,
+            DOI: doiString ? doi.buildUrl(doiString) : null,
+            Count: s.length,
+        };
+    })
+        .sort((a, b) => b.Count - a.Count);
+    sorted.forEach((r) => {
+        session.log.info(formatDictionary(r, { wrap: false }) + '\n');
+    });
+}
+function makeSummaryCLI(program) {
+    const command = new Command('summary')
+        .description('Parse a JATS file and provide a summary')
+        .argument('<jats>', 'The JATS file or remote URL to be parsed')
+        .action(clirun(jatsSummaryCLI, { program, getSession }));
+    return command;
+}
+function makeReferencesCLI(program) {
+    const command = new Command('refs')
+        .alias('references')
+        .description('Parse a JATS file and provide a summary')
+        .argument('<jats>', 'The JATS file or remote URL to be parsed')
+        .action(clirun(jatsReferencesCLI, { program, getSession }));
+    return command;
+}
+function makeDownloadCLI(program) {
+    const command = new Command('download')
+        .description('Parse a JATS file and provide a summary')
+        .argument('<url>', 'The JATS url or a DOI')
+        .argument('<output>', 'The JATS output file')
+        .action(clirun(downloadAndSaveJats, { program, getSession }));
+    return command;
+}
+export function addDownloadCLI(program) {
+    program.addCommand(makeDownloadCLI(program));
+    program.addCommand(makeSummaryCLI(program));
+    program.addCommand(makeReferencesCLI(program));
+}

package/dist/{types/cli → cli}/validate.d.ts

@@ -1,3 +1,2 @@
 import { Command } from 'commander';
 export declare function addValidateCLI(program: Command): void;
-//# sourceMappingURL=validate.d.ts.map

package/dist/{esm/cli → cli}/validate.js

@@ -1,12 +1,12 @@
 import { Command, Option } from 'commander';
 import { clirun } from 'myst-cli-utils';
-import { getSession } from '../session';
-import { validateJatsAgainstDtdWrapper } from '../validate';
+import { getSession } from '../session.js';
+import { validateJatsAgainstDtdWrapper } from '../validate/index.js';
 function makeValidateCLI(program) {
     const command = new Command('validate')
         .description(`
       Validate JATS file against DTD schema.
-      
+
       The JATS DTD schema file is fetched from nih.gov ftp server if not available locally.
       This will attempt to infer the specific JATS DTD version, library, etc from the file header,
       but options are available to override the inferred values.

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { default as version } from './version.js';
+export { Jats } from './jats.js';
+export * from './types.js';
+export * from './validate/index.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { default as version } from './version.js';
+export { Jats } from './jats.js';
+export * from './types.js';
+export * from './validate/index.js';