@publisle/research 0.0.0-stage → 0.1.0

package/src/csl.ts

@@ -0,0 +1,367 @@
+import CSL from "citeproc";
+import { locales } from "./locales.ts";
+import { toCslJson } from "./bibtex.ts";
+import type {
+  CitationCluster,
+  CitationEntry,
+  ResearchLoss,
+} from "./article.ts";
+
+export interface XmlElement {
+  readonly type: "element";
+  readonly name: string;
+  readonly attributes: Readonly<Record<string, string>>;
+  readonly children: readonly XmlNode[];
+}
+export type XmlNode =
+  XmlElement | { readonly type: "text"; readonly value: string };
+
+const NUMERIC_STYLE = `<?xml version="1.0"?>
+<style class="in-text" version="1.0">
+  <info><title>Publisle numeric</title><category citation-format="numeric"/></info>
+  <citation collapse="citation-number">
+    <sort><key variable="citation-number"/></sort>
+    <layout prefix="[" suffix="]" delimiter=", ">
+      <text variable="citation-number"/><group prefix=", " delimiter=" "><label variable="locator" form="short"/><text variable="locator"/></group>
+    </layout>
+  </citation>
+  <bibliography>
+    <layout>
+      <text variable="citation-number" suffix=". "/>
+      <names variable="author"><name form="long" and="text" delimiter=", "/><et-al term="et-al"/></names>
+      <text variable="title" prefix=", "/>
+      <text variable="container-title" prefix=", "/>
+      <text variable="volume" prefix=" "/>
+      <text variable="issue" prefix="(" suffix=")"/>
+      <text variable="page" prefix=": "/>
+      <date variable="issued" prefix=" (" suffix=")"><date-part name="year"/></date>
+      <text variable="DOI" prefix=". https://doi.org/"/>
+    </layout>
+  </bibliography>
+</style>`;
+
+const AUTHOR_DATE_STYLE = `<?xml version="1.0"?>
+<style class="in-text" version="1.0">
+  <info><title>Publisle author-date</title><category citation-format="author-date"/></info>
+  <macro name="author-short">
+    <names variable="author">
+      <name form="short" and="symbol" delimiter=", "/>
+      <et-al term="et-al"/>
+    </names>
+  </macro>
+  <citation et-al-min="3" et-al-use-first="1" disambiguate-add-year-suffix="true" disambiguate-add-givenname="true">
+    <layout prefix="(" suffix=")" delimiter="; ">
+      <group delimiter=", ">
+        <text macro="author-short"/>
+        <date variable="issued"><date-part name="year"/></date>
+      </group>
+    </layout>
+  </citation>
+  <bibliography>
+    <sort><key variable="author"/><key variable="issued"/></sort>
+    <layout suffix=".">
+      <names variable="author"><name and="text" name-as-sort-order="first" delimiter=", "/></names>
+      <date variable="issued" prefix=" (" suffix=")"><date-part name="year"/></date>
+      <text variable="title" prefix=". "/>
+      <text variable="container-title" prefix=". "/>
+    </layout>
+  </bibliography>
+</style>`;
+
+function decodeXml(value: string): string {
+  return value.replace(
+    /&(?:amp|lt|gt|quot|apos|#\d+|#x[a-f0-9]+);/giu,
+    (entity) => {
+      const named: Readonly<Record<string, string>> = {
+        "&amp;": "&",
+        "&lt;": "<",
+        "&gt;": ">",
+        "&quot;": '"',
+        "&apos;": "'",
+      };
+      if (named[entity]) return named[entity];
+      return String.fromCodePoint(
+        entity.startsWith("&#x")
+          ? parseInt(entity.slice(3, -1), 16)
+          : parseInt(entity.slice(2, -1), 10),
+      );
+    },
+  );
+}
+function parseXml(source: string): XmlElement {
+  let index = 0;
+  const skip = () => {
+    while (index < source.length) {
+      if (source.startsWith("<!--", index)) {
+        const end = source.indexOf("-->", index);
+        if (end === -1) throw new Error("CSL comment is not closed.");
+        index = end + 3;
+        continue;
+      }
+      if (source.startsWith("<?", index) || source.startsWith("<!", index)) {
+        const end = source.indexOf(">", index);
+        if (end === -1) throw new Error("CSL declaration is not closed.");
+        index = end + 1;
+        continue;
+      }
+      if (/\s/u.test(source[index] ?? "")) {
+        index += 1;
+        continue;
+      }
+      break;
+    }
+  };
+  const readAttributes = (): Record<string, string> => {
+    const attributes: Record<string, string> = {};
+    while (
+      index < source.length &&
+      source[index] !== ">" &&
+      source[index] !== "/"
+    ) {
+      if (/\s/u.test(source[index] ?? "")) {
+        index += 1;
+        continue;
+      }
+      const nameEnd = source.slice(index).search(/[\s=/>]/u);
+      if (nameEnd <= 0) throw new Error("CSL attribute name is missing.");
+      const name = source.slice(index, index + nameEnd);
+      index += nameEnd;
+      while (/\s/u.test(source[index] ?? "")) index += 1;
+      if (source[index] !== "=")
+        throw new Error(`CSL attribute ${name} is missing a value.`);
+      index += 1;
+      while (/\s/u.test(source[index] ?? "")) index += 1;
+      const quote = source[index];
+      if (quote !== '"' && quote !== "'")
+        throw new Error(`CSL attribute ${name} is not quoted.`);
+      const valueEnd = source.indexOf(quote, index + 1);
+      if (valueEnd === -1)
+        throw new Error(`CSL attribute ${name} is not closed.`);
+      attributes[name] = decodeXml(source.slice(index + 1, valueEnd));
+      index = valueEnd + 1;
+    }
+    return attributes;
+  };
+  const readNodes = (until: string): XmlNode[] => {
+    const children: XmlNode[] = [];
+    while (index < source.length && !source.startsWith(until, index)) {
+      if (source.startsWith("<!--", index)) {
+        const end = source.indexOf("-->", index);
+        if (end < 0) throw new Error("Unclosed CSL comment");
+        index = end + 3;
+        continue;
+      }
+      if (source[index] === "<") children.push(readElement());
+      else {
+        const next = source.indexOf("<", index);
+        const value = source.slice(index, next === -1 ? source.length : next);
+        index = next === -1 ? source.length : next;
+        if (value.trim().length > 0)
+          children.push({ type: "text", value: decodeXml(value.trim()) });
+      }
+    }
+    return children;
+  };
+  const readElement = (): XmlElement => {
+    if (source[index] !== "<") throw new Error("Expected a CSL element.");
+    index += 1;
+    const nameEnd = source.slice(index).search(/[\s/>]/u);
+    if (nameEnd <= 0) throw new Error("CSL element name is missing.");
+    const name = source.slice(index, index + nameEnd);
+    index += nameEnd;
+    const attributes = readAttributes();
+    if (source.startsWith("/>", index)) {
+      index += 2;
+      return { type: "element", name, attributes, children: [] };
+    }
+    if (source[index] !== ">")
+      throw new Error(`CSL element ${name} is not closed.`);
+    index += 1;
+    const children = readNodes(`</${name}>`);
+    if (!source.startsWith(`</${name}>`, index))
+      throw new Error(`CSL element ${name} has no end tag.`);
+    index += name.length + 3;
+    return { type: "element", name, attributes, children };
+  };
+  skip();
+  const root = readElement();
+  skip();
+  if (index < source.length) throw new Error("CSL style has trailing content.");
+  if (root.name !== "style") throw new Error("CSL root element must be style.");
+  return root;
+}
+
+export function builtinCsl(name: "numeric" | "author-date"): XmlElement {
+  return parseXml(name === "numeric" ? NUMERIC_STYLE : AUTHOR_DATE_STYLE);
+}
+
+export function parseCslStyle(xml: string): XmlElement {
+  return parseXml(xml);
+}
+
+function descendants(node: XmlElement, name: string): XmlElement[] {
+  const found: XmlElement[] = [];
+  for (const child of node.children) {
+    if (child.type !== "element") continue;
+    if (child.name === name) found.push(child);
+    found.push(...descendants(child, name));
+  }
+  return found;
+}
+
+function attr(node: XmlElement, name: string): string | undefined {
+  return node.attributes[name];
+}
+
+export type CitationForm = "numeric" | "author-date" | "note";
+
+export function citationForm(style: XmlElement): CitationForm {
+  if (style.attributes["class"] === "note") return "note";
+  const category = descendants(style, "category").find((item) =>
+    attr(item, "citation-format"),
+  );
+  const format = category ? attr(category, "citation-format") : undefined;
+  if (format === "numeric") return "numeric";
+  if (format === "author-date") return "author-date";
+  return style.attributes["class"] === "in-text"
+    ? descendants(style, "text").some(
+        (node) => node.attributes["variable"] === "citation-number",
+      )
+      ? "numeric"
+      : "author-date"
+    : "note";
+}
+
+export interface FormattedResearch {
+  readonly form: CitationForm;
+  readonly citations: readonly string[];
+  readonly bibliography: readonly {
+    readonly id: string;
+    readonly label: string;
+    readonly text: string;
+  }[];
+  readonly unresolved: readonly string[];
+  readonly losses: readonly ResearchLoss[];
+}
+
+export interface CslOptions {
+  readonly locale?: string;
+  readonly locales?: Readonly<Record<string, string>>;
+  /** Complete CSL-JSON records, including structured names, dates and additional variables. */
+  readonly items?: readonly Readonly<Record<string, unknown>>[];
+  readonly noteIndices?: readonly number[];
+}
+function xml(node: XmlNode): string {
+  const escape = (value: string) =>
+    value
+      .replace(/&/gu, "&amp;")
+      .replace(/"/gu, "&quot;")
+      .replace(/</gu, "&lt;");
+  if (node.type === "text") return escape(node.value);
+  return `<${node.name}${Object.entries(node.attributes)
+    .map(([key, value]) => ` ${key}="${escape(value)}"`)
+    .join("")}>${node.children.map(xml).join("")}</${node.name}>`;
+}
+export function formatCitations(
+  entries: readonly CitationEntry[],
+  clusters: readonly CitationCluster[],
+  style: XmlElement,
+  options: CslOptions = {},
+): FormattedResearch {
+  const records = JSON.parse(toCslJson(entries)) as Record<string, unknown>[];
+  const byId = new Map(records.map((item) => [String(item["id"]), item]));
+  for (const item of options.items ?? [])
+    byId.set(String(item["id"]), structuredClone(item));
+  const losses: ResearchLoss[] = [];
+  for (const entry of entries)
+    if (entry.raw && !entry.title && !entry.authors.length && !entry.issued) {
+      byId.set(entry.id, { id: entry.id, type: "document", title: entry.raw });
+      losses.push({
+        code: "opaque-reference-literal",
+        message: `Reference ${entry.id} is preserved literally and cannot be restyled.`,
+      });
+    }
+  const unresolved = [
+    ...new Set(
+      clusters.flatMap((cluster) =>
+        cluster.items
+          .filter((item) => !byId.has(item.id))
+          .map((item) => item.id),
+      ),
+    ),
+  ];
+  for (const id of unresolved)
+    losses.push({
+      code: "unresolved-citation",
+      message: `Citation ${id} has no bibliography entry.`,
+    });
+  const localeMap = { ...locales, ...options.locales };
+  const processor = new CSL.Engine(
+    {
+      retrieveLocale: (language: string) => {
+        const exact = localeMap[language];
+        if (exact) return exact;
+        const match = Object.keys(localeMap).find(
+          (key) => key.split("-")[0] === language.split("-")[0],
+        );
+        if (match) return localeMap[match] ?? "";
+        throw new Error(`No CSL locale resource for ${language}`);
+      },
+      retrieveItem: (id: string) =>
+        byId.get(id) ?? { id, type: "document", title: id },
+    },
+    xml(style),
+    options.locale ?? "en-US",
+    Boolean(options.locale),
+  );
+  processor.setOutputFormat("text");
+  const form = citationForm(style);
+  const citations: string[] = clusters.map(() => "");
+  const history: [string, number][] = [];
+  const positions: number[] = [];
+  clusters.forEach((cluster, index) => {
+    const noteIndex =
+      options.noteIndices?.[index] ?? (form === "note" ? index + 1 : 0);
+    const citation = {
+      citationID: `publisle-${String(index)}`,
+      citationItems: cluster.items
+        .filter((item) => byId.has(item.id))
+        .map((item) => ({
+          id: item.id,
+          ...(item.locator
+            ? {
+                locator: item.locator,
+                label: item.label === "p." ? "page" : (item.label ?? "page"),
+              }
+            : {}),
+          ...(item.suppressAuthor ? { "suppress-author": true } : {}),
+        })),
+      properties: { noteIndex },
+    };
+    if (citation.citationItems.length) {
+      const result = processor.processCitationCluster(citation, history, []);
+      positions.push(index);
+      for (const [position, value] of result[1]) {
+        const target = positions[position];
+        if (target !== undefined) citations[target] = value;
+      }
+      history.push([citation.citationID, noteIndex]);
+    }
+  });
+  clusters.forEach((cluster, index) => {
+    const missing = cluster.items
+      .filter((item) => !byId.has(item.id))
+      .map((item) => item.id);
+    citations[index] =
+      `${cluster.prefix ?? ""}${citations[index] ?? ""}${missing.length ? `[${missing.join(", ")}]` : ""}${cluster.suffix ?? ""}`;
+  });
+  const bibliographyResult = processor.makeBibliography();
+  const bibliography = bibliographyResult
+    ? bibliographyResult[1].map((text, index) => ({
+        id: bibliographyResult[0].entry_ids[index]?.[0] ?? "",
+        label: String(index + 1),
+        text: text.trim(),
+      }))
+    : [];
+  return { form, citations, bibliography, unresolved, losses };
+}

package/src/index.ts

@@ -0,0 +1,29 @@
+export type { CitationEntry, ResearchLoss } from "./article.ts";
+export { parseBibtex, toBibtex, toCslJson } from "./bibtex.ts";
+export { parseCslStyle } from "./csl.ts";
+export { toJats, createJatsPackage, type JatsPackage } from "./jats.ts";
+export { toLatex } from "./latex.ts";
+export {
+  researchPaperProfile,
+  scholarlyProfile,
+  type ResearchPaperProfileOptions,
+} from "./profiles.ts";
+// eslint-disable-next-line @typescript-eslint/no-deprecated -- retained migration export
+export { toPdf } from "./pdf.ts";
+export { resolveDocument, type ResolvedDocument } from "./resolve.ts";
+export {
+  resolvePortableCitations,
+  PORTABLE_CITATION_CAPABILITIES,
+  type PortableCitations,
+} from "./portable-citations.ts";
+
+export {
+  createLatexPackage,
+  type LatexPackage,
+  type LatexPackageOptions,
+  type LatexEngine,
+} from "./package.ts";
+
+export { createSubmissionPackage } from "./package.ts";
+
+export type { CslOptions } from "./csl.ts";

package/src/jats.ts

@@ -0,0 +1,242 @@
+import type { ArticleInline } from "./article.ts";
+import type { ResolvedDocument } from "./resolve.ts";
+
+function xml(value: string): string {
+  return value
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;");
+}
+
+function xmlId(value: string): string {
+  return /^[A-Za-z_][A-Za-z0-9_.-]*$/u.test(value) &&
+    !value.startsWith("publisle-id-")
+    ? value
+    : "publisle-id-" +
+        Array.from(new TextEncoder().encode(value), (byte) =>
+          byte.toString(16).padStart(2, "0"),
+        ).join("");
+}
+function inlineJats(
+  inlines: readonly ArticleInline[],
+  resolved: ResolvedDocument,
+  cursor: { index: number },
+): string {
+  return inlines
+    .map((inline) => {
+      if (inline.type === "break") return "<break/>";
+      if (inline.type === "math")
+        return `<inline-formula><tex-math><![CDATA[${inline.value.replaceAll("]]>", "]]]]><![CDATA[>")}]]></tex-math></inline-formula>`;
+      if (inline.type === "link")
+        return `<ext-link ext-link-type="uri" xlink:href="${xml(inline.url)}">${xml(inline.value)}</ext-link>`;
+      if (inline.type === "citation") {
+        const text = resolved.citations[cursor.index] ?? "";
+        cursor.index += 1;
+        const rid = inline.cluster.items
+          .map((item) => xmlId(item.id))
+          .join(" ");
+        return `<xref ref-type="bibr" rid="${xml(rid)}">${xml(text)}</xref>`;
+      }
+      if (inline.reference) {
+        const target = resolved.article.blocks.find(
+          (block) => block.label === inline.reference?.target,
+        );
+        const kind =
+          inline.reference.kind === "footnote"
+            ? "fn"
+            : target?.kind === "figure"
+              ? "fig"
+              : target?.kind === "table"
+                ? "table"
+                : target?.kind === "math"
+                  ? "disp-formula"
+                  : "sec";
+        return `<xref ref-type="${kind}" rid="${xmlId(inline.reference.target)}">${xml(inline.value)}</xref>`;
+      }
+      const value = xml(inline.value);
+      if (inline.mark === "emphasis") return `<italic>${value}</italic>`;
+      if (inline.mark === "strong") return `<bold>${value}</bold>`;
+      if (inline.mark === "code") return `<monospace>${value}</monospace>`;
+      if (inline.mark === "strike") return `<strike>${value}</strike>`;
+      return value;
+    })
+    .join("");
+}
+
+function publicationType(type: string | undefined): string {
+  if (type === "article-journal") return "journal";
+  if (type === "book") return "book";
+  if (type === "paper-conference") return "confproc";
+  return "other";
+}
+
+function name(author: string): string {
+  const comma = author.indexOf(",");
+  const surname = xml((comma === -1 ? author : author.slice(0, comma)).trim());
+  const given = comma === -1 ? "" : author.slice(comma + 1).trim();
+  return `<name><surname>${surname}</surname>${given.length === 0 ? "" : `<given-names>${xml(given)}</given-names>`}</name>`;
+}
+
+/** JATS Archiving 1.3 article XML. It is not a publisher submission bundle. */
+export function toJats(resolved: ResolvedDocument): string {
+  const cursor = { index: 0 };
+  const take = (inlines: readonly ArticleInline[]) =>
+    inlineJats(inlines, resolved, cursor);
+  const abstract: string[] = [];
+  const body: string[] = [];
+  const footnotes: string[] = [];
+  const sections: number[] = [];
+  const closeSections = (level = 0) => {
+    while (sections.length && (sections[sections.length - 1] ?? 0) >= level) {
+      body.push("</sec>");
+      sections.pop();
+    }
+  };
+  for (const block of resolved.article.blocks) {
+    const target =
+      block.kind !== "footnote" &&
+      block.kind !== "bibliography" &&
+      block.abstract
+        ? abstract
+        : body;
+    if (block.kind === "heading") {
+      if (!block.abstract) {
+        closeSections(block.level);
+        sections.push(block.level);
+        target.push(
+          `<sec${block.label ? ` id="${xmlId(block.label)}"` : ""}><title>${take(block.inlines)}</title>`,
+        );
+      } else abstract.push(`<title>${take(block.inlines)}</title>`);
+    } else if (block.kind === "paragraph")
+      target.push(`<p>${take(block.inlines)}</p>`);
+    else if (block.kind === "list") {
+      target.push(
+        `<list list-type="${block.ordered ? "order" : "bullet"}">${block.items
+          .map((item) => `<list-item><p>${take(item)}</p></list-item>`)
+          .join("")}</list>`,
+      );
+    } else if (block.kind === "quote") {
+      target.push(
+        `<disp-quote>${block.paragraphs.map((paragraph) => `<p>${take(paragraph)}</p>`).join("")}</disp-quote>`,
+      );
+    } else if (block.kind === "code")
+      target.push(`<preformat>${xml(block.value)}</preformat>`);
+    else if (block.kind === "math")
+      target.push(
+        `<disp-formula${block.label ? ` id="${xmlId(block.label)}"` : ""}><tex-math><![CDATA[${block.value.replaceAll("]]>", "]]]]><![CDATA[>")}]]></tex-math></disp-formula>`,
+      );
+    else if (block.kind === "figure")
+      target.push(
+        `<fig${block.label ? ` id="${xmlId(block.label)}"` : ""}><caption><p>${take(block.caption)}</p></caption><alt-text>${xml(block.alt)}</alt-text><graphic xlink:href="${xml(block.src)}"/></fig>`,
+      );
+    else if (block.kind === "table") {
+      const caption = block.caption
+        ? `<caption><p>${take(block.caption)}</p></caption>`
+        : "";
+      const rows = block.rows
+        .map(
+          (row) =>
+            `<tr>${row.map((cell) => `<td>${take(cell)}</td>`).join("")}</tr>`,
+        )
+        .join("");
+      target.push(
+        `<table-wrap${block.label ? ` id="${xmlId(block.label)}"` : ""}>${caption}<table>${rows}</table></table-wrap>`,
+      );
+    } else if (block.kind === "footnote") {
+      footnotes.push(
+        `<fn id="${xmlId(block.id)}"><p>${block.paragraphs.map((paragraph) => take(paragraph)).join(" ")}</p></fn>`,
+      );
+    }
+  }
+  closeSections();
+  const entryById = new Map(
+    resolved.article.entries.map((entry) => [entry.id, entry]),
+  );
+  const refs = resolved.bibliography
+    .map((item) => {
+      const entry = entryById.get(item.id);
+      if (
+        !entry ||
+        (entry.raw && !entry.title && !entry.authors.length && !entry.issued)
+      )
+        return `<ref id="${xmlId(item.id)}"><mixed-citation>${xml(entry?.raw ?? item.text)}</mixed-citation></ref>`;
+      const pages = (entry.page ?? "").split(/--|-|–/u);
+      const first = pages[0]?.trim() ?? "";
+      const last = pages[1]?.trim();
+      return `<ref id="${xmlId(item.id)}"><element-citation publication-type="${publicationType(entry.type)}">${
+        entry.authors.length > 0
+          ? `<person-group person-group-type="author">${entry.authors.map(name).join("")}</person-group>`
+          : ""
+      }${entry.title === undefined ? "" : `<article-title>${xml(entry.title)}</article-title>`}${
+        entry.containerTitle === undefined
+          ? ""
+          : `<source>${xml(entry.containerTitle)}</source>`
+      }${entry.issued === undefined ? "" : `<year>${xml(entry.issued.slice(0, 4))}</year>`}${
+        entry.volume === undefined
+          ? ""
+          : `<volume>${xml(entry.volume)}</volume>`
+      }${entry.issue === undefined ? "" : `<issue>${xml(entry.issue)}</issue>`}${
+        first.length === 0 ? "" : `<fpage>${xml(first)}</fpage>`
+      }${last === undefined || last.length === 0 ? "" : `<lpage>${xml(last)}</lpage>`}${
+        entry.doi === undefined
+          ? ""
+          : `<pub-id pub-id-type="doi">${xml(entry.doi)}</pub-id>`
+      }</element-citation></ref>`;
+    })
+    .join("");
+  const authors = resolved.article.authors
+    .map(
+      (author) =>
+        `<contrib contrib-type="author"><name><surname>${xml(author)}</surname></name></contrib>`,
+    )
+    .join("");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<article xmlns:xlink="http://www.w3.org/1999/xlink" article-type="research-article" dtd-version="1.3"${resolved.article.language ? ` xml:lang="${xml(resolved.article.language)}"` : ""}>
+<front><article-meta>
+<title-group><article-title>${xml(resolved.article.title ?? "Untitled")}</article-title></title-group>
+${authors.length === 0 ? "" : `<contrib-group>${authors}</contrib-group>`}
+${abstract.length === 0 ? "" : `<abstract>${abstract.join("")}</abstract>`}
+</article-meta></front>
+<body>${body.join("")}</body>
+<back>
+${footnotes.length === 0 ? "" : `<fn-group>${footnotes.join("")}</fn-group>`}
+<ref-list>${refs}</ref-list>
+</back>
+</article>
+`;
+}
+
+export interface JatsPackage {
+  readonly files: Readonly<Record<string, string>>;
+  readonly assets: readonly {
+    readonly source: string;
+    readonly destination: string;
+  }[];
+  readonly diagnostics: ResolvedDocument["losses"];
+}
+/** Pure article-and-assets package. Node collection validates with the bundled offline DTD. */
+export function createJatsPackage(resolved: ResolvedDocument): JatsPackage {
+  if (resolved.unresolved.length)
+    throw new Error(`Unresolved citations: ${resolved.unresolved.join(", ")}`);
+  const assets: { source: string; destination: string }[] = [];
+  const blocks = resolved.article.blocks.map((block) => {
+    if (block.kind !== "figure") return block;
+    if (/^(?:[a-z]+:|\/\/)/iu.test(block.src))
+      throw new Error("JATS package requires local figure assets.");
+    const extension = /\.([a-z0-9]+)$/iu.exec(block.src)?.[1] ?? "bin";
+    const destination = `assets/figure-${String(assets.length + 1)}.${extension}`;
+    assets.push({ source: block.src, destination });
+    return { ...block, src: destination };
+  });
+  return {
+    files: {
+      "article.xml": toJats({
+        ...resolved,
+        article: { ...resolved.article, blocks },
+      }),
+    },
+    assets,
+    diagnostics: resolved.losses,
+  };
+}

package/src/latex.ts

@@ -0,0 +1,21 @@
+import { template } from "@publisle/template-article";
+import { citationClusters } from "./article.ts";
+import type { ResolvedDocument } from "./resolve.ts";
+export { latexText, latexKey } from "@publisle/template-sdk";
+/** Unicode article source. Use a submission package to collect referenced figure assets. */
+export function toLatex(resolved: ResolvedDocument): string {
+  const citations = new Map(
+    citationClusters(resolved.article).map((cluster, index) => [
+      cluster,
+      resolved.citations[index] ?? "",
+    ]),
+  );
+  const source = template.render(resolved.article, {
+    style: resolved.form,
+    citationForm: resolved.form,
+    citations: resolved.citations,
+    citationText: (cluster) => citations.get(cluster) ?? "",
+    bibliography: resolved.bibliography,
+  });
+  return source.files["manuscript.tex"] ?? "";
+}