@ncukondo/search-hub 0.12.1 → 0.12.2

package/dist/node_modules/@ncukondo/academic-fulltext/dist/convert/jats-parser.js

@@ -0,0 +1,1060 @@
+import { XMLParser } from "fast-xml-parser";
+const parser = new XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  textNodeName: "#text",
+  trimValues: false,
+  preserveOrder: true,
+  processEntities: true,
+  htmlEntities: true
+});
+function getTagName(node) {
+  for (const key of Object.keys(node)) {
+    if (key !== ":@" && key !== "#text")
+      return key;
+  }
+  return void 0;
+}
+function getChildren(node) {
+  const tag = getTagName(node);
+  if (!tag)
+    return [];
+  const children = node[tag];
+  return Array.isArray(children) ? children : [];
+}
+function getAttr(node, attrName) {
+  const attrs = node[":@"];
+  if (!attrs)
+    return void 0;
+  const val = attrs[`@_${attrName}`];
+  return val != null ? String(val) : void 0;
+}
+function getAttrs(node) {
+  const attrs = node[":@"];
+  if (!attrs)
+    return {};
+  const result = {};
+  for (const [key, value] of Object.entries(attrs)) {
+    if (key.startsWith("@_")) {
+      result[key.slice(2)] = String(value);
+    }
+  }
+  return result;
+}
+function findChild(children, tagName) {
+  for (const child of children) {
+    if (tagName in child) {
+      const childArr = child[tagName];
+      return {
+        node: child,
+        children: Array.isArray(childArr) ? childArr : [],
+        attrs: getAttrs(child)
+      };
+    }
+  }
+  return void 0;
+}
+function findChildren(children, tagName) {
+  const results = [];
+  for (const child of children) {
+    if (tagName in child) {
+      const childArr = child[tagName];
+      results.push({
+        node: child,
+        children: Array.isArray(childArr) ? childArr : [],
+        attrs: getAttrs(child)
+      });
+    }
+  }
+  return results;
+}
+function getTextContent(child) {
+  if ("#text" in child) {
+    const val = child["#text"];
+    return val != null ? String(val) : void 0;
+  }
+  return void 0;
+}
+function findArticle(parsed) {
+  const direct = findChild(parsed, "article");
+  if (direct)
+    return direct;
+  const wrapper = findChild(parsed, "pmc-articleset");
+  if (wrapper)
+    return findChild(wrapper.children, "article");
+  return void 0;
+}
+const SPACE_AFTER_TAGS = /* @__PURE__ */ new Set(["surname", "given-names", "name", "string-name"]);
+function extractAllText(node) {
+  if (node == null)
+    return "";
+  if (typeof node === "string")
+    return node;
+  if (typeof node === "number")
+    return String(node);
+  if (Array.isArray(node)) {
+    return joinChildTexts(node);
+  }
+  if (typeof node === "object") {
+    const obj = node;
+    const text = getTextContent(obj);
+    if (text != null)
+      return text;
+    const tag = getTagName(obj);
+    if (tag) {
+      const children = obj[tag];
+      if (Array.isArray(children)) {
+        return joinChildTexts(children);
+      }
+    }
+  }
+  return "";
+}
+function joinChildTexts(children) {
+  const parts = [];
+  for (const child of children) {
+    const text = extractAllText(child);
+    if (!text)
+      continue;
+    const tag = getTagName(child);
+    if (tag && SPACE_AFTER_TAGS.has(tag) && parts.length > 0) {
+      const prev = parts.at(-1);
+      if (prev && !/[\s,;.:()\-/]$/.test(prev)) {
+        parts.push(" ");
+      }
+    }
+    parts.push(text);
+  }
+  return parts.join("");
+}
+function parseArticleIds(metaChildren) {
+  const articleIds = findChildren(metaChildren, "article-id");
+  const result = {};
+  for (const idEntry of articleIds) {
+    const idType = idEntry.attrs["pub-id-type"];
+    const idText = extractAllText(idEntry.children);
+    if (idType === "doi")
+      result.doi = idText;
+    if (idType === "pmc" || idType === "pmcid") {
+      result.pmcid = idText.replace(/^PMC/, "");
+    }
+    if (idType === "pmid")
+      result.pmid = idText;
+  }
+  return result;
+}
+function parseAuthors(metaChildren) {
+  const authors = [];
+  const contribGroup = findChild(metaChildren, "contrib-group");
+  if (!contribGroup)
+    return authors;
+  const contribs = findChildren(contribGroup.children, "contrib");
+  for (const contrib of contribs) {
+    if (contrib.attrs["contrib-type"] !== "author")
+      continue;
+    const nameNode = findChild(contrib.children, "name");
+    if (!nameNode)
+      continue;
+    const surnameNode = findChild(nameNode.children, "surname");
+    const givenNamesNode = findChild(nameNode.children, "given-names");
+    const author = {
+      surname: surnameNode ? extractAllText(surnameNode.children) : ""
+    };
+    const givenNames = givenNamesNode ? extractAllText(givenNamesNode.children) : "";
+    if (givenNames) {
+      author.givenNames = givenNames;
+    }
+    authors.push(author);
+  }
+  return authors;
+}
+function parseAbstract(metaChildren) {
+  const abstractNode = findChild(metaChildren, "abstract");
+  if (!abstractNode)
+    return void 0;
+  const sections = findChildren(abstractNode.children, "sec");
+  if (sections.length > 0) {
+    return parseStructuredAbstract(sections);
+  }
+  const paragraphs = findChildren(abstractNode.children, "p");
+  if (paragraphs.length > 0) {
+    return paragraphs.map((p) => extractAllText(p.children)).join("\n\n");
+  }
+  const text = extractAllText(abstractNode.children);
+  return text || void 0;
+}
+function parseStructuredAbstract(sections) {
+  const parts = [];
+  for (const sec of sections) {
+    const secTitleNode = findChild(sec.children, "title");
+    const secTitle = secTitleNode ? extractAllText(secTitleNode.children) : "";
+    const secPs = findChildren(sec.children, "p");
+    const text = secPs.map((p) => extractAllText(p.children)).join(" ");
+    parts.push(secTitle ? `${secTitle}: ${text}` : text);
+  }
+  return parts.join("\n\n");
+}
+function extractDateFromNode(pd) {
+  const yearNode = findChild(pd.children, "year");
+  if (!yearNode)
+    return void 0;
+  const year = extractAllText(yearNode.children);
+  const monthNode = findChild(pd.children, "month");
+  const dayNode = findChild(pd.children, "day");
+  const date = { year };
+  if (monthNode)
+    date.month = extractAllText(monthNode.children);
+  if (dayNode)
+    date.day = extractAllText(dayNode.children);
+  return date;
+}
+function parsePublicationDate(metaChildren) {
+  const pubDates = findChildren(metaChildren, "pub-date");
+  const datePriority = { epub: 0, ppub: 1, collection: 2 };
+  let bestPriority = Number.POSITIVE_INFINITY;
+  let publicationDate;
+  for (const pd of pubDates) {
+    const dateType = pd.attrs["pub-type"] ?? pd.attrs["date-type"] ?? "";
+    const priority = datePriority[dateType] ?? 3;
+    if (priority < bestPriority) {
+      bestPriority = priority;
+      publicationDate = extractDateFromNode(pd);
+    }
+  }
+  if (!publicationDate && pubDates.length > 0) {
+    const pd = pubDates.at(0);
+    if (pd) {
+      publicationDate = extractDateFromNode(pd);
+    }
+  }
+  return publicationDate;
+}
+function parseLicense(metaChildren) {
+  const permissions = findChild(metaChildren, "permissions");
+  if (!permissions)
+    return void 0;
+  const licenseNode = findChild(permissions.children, "license");
+  if (!licenseNode)
+    return void 0;
+  const href = licenseNode.attrs["xlink:href"];
+  if (href)
+    return href;
+  const licenseP = findChild(licenseNode.children, "license-p");
+  if (licenseP)
+    return extractAllText(licenseP.children).trim();
+  return void 0;
+}
+function parseKeywords(metaChildren) {
+  const kwdGroups = findChildren(metaChildren, "kwd-group");
+  const keywords = [];
+  for (const kwdGroup of kwdGroups) {
+    const kwds = findChildren(kwdGroup.children, "kwd");
+    for (const kwd of kwds) {
+      const text = extractAllText(kwd.children).trim();
+      if (text)
+        keywords.push(text);
+    }
+  }
+  return keywords;
+}
+function parseVolumeAndPages(metaChildren) {
+  const volumeNode = findChild(metaChildren, "volume");
+  const volume = volumeNode ? extractAllText(volumeNode.children) : void 0;
+  const issueNode = findChild(metaChildren, "issue");
+  const issue = issueNode ? extractAllText(issueNode.children) : void 0;
+  let pages;
+  const fpageNode = findChild(metaChildren, "fpage");
+  const lpageNode = findChild(metaChildren, "lpage");
+  if (fpageNode) {
+    const fp = extractAllText(fpageNode.children);
+    const lp = lpageNode ? extractAllText(lpageNode.children) : "";
+    pages = lp ? `${fp}-${lp}` : fp;
+  } else {
+    const elocationNode = findChild(metaChildren, "elocation-id");
+    if (elocationNode)
+      pages = extractAllText(elocationNode.children);
+  }
+  const result = {};
+  if (volume !== void 0)
+    result.volume = volume;
+  if (issue !== void 0)
+    result.issue = issue;
+  if (pages !== void 0)
+    result.pages = pages;
+  return result;
+}
+function parseJournalName(frontChildren) {
+  const journalMeta = findChild(frontChildren, "journal-meta");
+  if (!journalMeta)
+    return void 0;
+  const titleGroup = findChild(journalMeta.children, "journal-title-group");
+  if (titleGroup) {
+    const jTitle2 = findChild(titleGroup.children, "journal-title");
+    if (jTitle2)
+      return extractAllText(jTitle2.children);
+  }
+  const jTitle = findChild(journalMeta.children, "journal-title");
+  if (jTitle)
+    return extractAllText(jTitle.children);
+  return void 0;
+}
+function parseArticleTitle(metaChildren) {
+  const titleGroup = findChild(metaChildren, "title-group");
+  const articleTitle = titleGroup ? findChild(titleGroup.children, "article-title") : void 0;
+  return articleTitle ? extractAllText(articleTitle.children) : "";
+}
+function assembleMetadata(base, fields) {
+  const result = { ...base };
+  if (fields.doi)
+    result.doi = fields.doi;
+  if (fields.pmcid)
+    result.pmcid = fields.pmcid;
+  if (fields.pmid)
+    result.pmid = fields.pmid;
+  if (fields.journal)
+    result.journal = fields.journal;
+  if (fields.publicationDate)
+    result.publicationDate = fields.publicationDate;
+  if (fields.volume)
+    result.volume = fields.volume;
+  if (fields.issue)
+    result.issue = fields.issue;
+  if (fields.pages)
+    result.pages = fields.pages;
+  if (fields.keywords.length > 0)
+    result.keywords = fields.keywords;
+  if (fields.articleType)
+    result.articleType = fields.articleType;
+  if (fields.license)
+    result.license = fields.license;
+  if (fields.abstract)
+    result.abstract = fields.abstract;
+  return result;
+}
+function parseJatsMetadata(xml) {
+  const parsed = parser.parse(xml);
+  const article = findArticle(parsed);
+  if (!article)
+    return { title: "", authors: [] };
+  const front = findChild(article.children, "front");
+  if (!front)
+    return { title: "", authors: [] };
+  const articleMeta = findChild(front.children, "article-meta");
+  if (!articleMeta)
+    return { title: "", authors: [] };
+  const metaChildren = articleMeta.children;
+  const journal = parseJournalName(front.children);
+  const publicationDate = parsePublicationDate(metaChildren);
+  const articleType = article.attrs["article-type"] || void 0;
+  const license = parseLicense(metaChildren);
+  const abstract = parseAbstract(metaChildren);
+  return assembleMetadata({ title: parseArticleTitle(metaChildren), authors: parseAuthors(metaChildren) }, {
+    ...parseArticleIds(metaChildren),
+    ...journal !== void 0 ? { journal } : {},
+    ...publicationDate !== void 0 ? { publicationDate } : {},
+    ...parseVolumeAndPages(metaChildren),
+    keywords: parseKeywords(metaChildren),
+    ...articleType !== void 0 ? { articleType } : {},
+    ...license !== void 0 ? { license } : {},
+    ...abstract !== void 0 ? { abstract } : {}
+  });
+}
+function handleInlineFormula(innerChildren) {
+  let texMath = findChild(innerChildren, "tex-math");
+  if (!texMath) {
+    const alternatives = findChild(innerChildren, "alternatives");
+    if (alternatives) {
+      texMath = findChild(alternatives.children, "tex-math");
+    }
+  }
+  const tex = texMath ? extractAllText(texMath.children) : void 0;
+  const text = tex || extractAllText(innerChildren);
+  const entry = {
+    type: "inline-formula",
+    text
+  };
+  if (tex)
+    entry.tex = tex;
+  return entry;
+}
+function handleExtLink(child, innerChildren) {
+  const href = getAttr(child, "xlink:href");
+  if (href) {
+    return { type: "link", url: href, children: parseInlineContent(innerChildren) };
+  }
+  const linkText = extractAllText(innerChildren);
+  if (linkText)
+    return { type: "text", text: linkText };
+  return null;
+}
+function handleUri(child, innerChildren) {
+  const href = getAttr(child, "xlink:href");
+  const textContent = extractAllText(innerChildren);
+  const url = href || textContent;
+  if (url) {
+    return { type: "link", url, children: parseInlineContent(innerChildren) };
+  }
+  return null;
+}
+function handleXref(child, innerChildren) {
+  const refType = getAttr(child, "ref-type");
+  if (refType === "bibr") {
+    return {
+      type: "citation",
+      refId: getAttr(child, "rid") ?? "",
+      text: extractAllText(innerChildren)
+    };
+  }
+  const xrefText = extractAllText(innerChildren);
+  if (xrefText)
+    return { type: "text", text: xrefText };
+  return null;
+}
+const inlineTagHandlers = {
+  bold: (_child, innerChildren) => ({
+    type: "bold",
+    children: parseInlineContent(innerChildren)
+  }),
+  italic: (_child, innerChildren) => ({
+    type: "italic",
+    children: parseInlineContent(innerChildren)
+  }),
+  sup: (_child, innerChildren) => ({
+    type: "superscript",
+    text: extractAllText(innerChildren)
+  }),
+  sub: (_child, innerChildren) => ({
+    type: "subscript",
+    text: extractAllText(innerChildren)
+  }),
+  "inline-formula": (_child, innerChildren) => handleInlineFormula(innerChildren),
+  monospace: (_child, innerChildren) => ({
+    type: "code",
+    text: extractAllText(innerChildren)
+  }),
+  "ext-link": (child, innerChildren) => handleExtLink(child, innerChildren),
+  uri: (child, innerChildren) => handleUri(child, innerChildren),
+  underline: (_child, innerChildren) => {
+    const passText = extractAllText(innerChildren);
+    return passText ? { type: "text", text: passText } : null;
+  },
+  sc: (_child, innerChildren) => {
+    const passText = extractAllText(innerChildren);
+    return passText ? { type: "text", text: passText } : null;
+  },
+  xref: (child, innerChildren) => handleXref(child, innerChildren)
+};
+function processInlineChild(child) {
+  const text = getTextContent(child);
+  if (text != null) {
+    return text ? { type: "text", text } : null;
+  }
+  const tag = getTagName(child);
+  if (!tag)
+    return null;
+  const innerChildren = getChildren(child);
+  const handler = inlineTagHandlers[tag];
+  if (handler)
+    return handler(child, innerChildren);
+  const unknownText = extractAllText(innerChildren);
+  return unknownText ? { type: "text", text: unknownText } : null;
+}
+function parseInlineContent(children) {
+  const result = [];
+  for (const child of children) {
+    const content = processInlineChild(child);
+    if (content)
+      result.push(content);
+  }
+  return result;
+}
+function parseList(listNode) {
+  const listType = getAttr(listNode, "list-type");
+  const ordered = listType === "order";
+  const listChildren = getChildren(listNode);
+  const listItems = findChildren(listChildren, "list-item");
+  const items = [];
+  for (const item of listItems) {
+    const pNodes = findChildren(item.children, "p");
+    const content = pNodes.flatMap((p) => parseInlineContent(p.children));
+    items.push(content);
+  }
+  return { type: "list", ordered, items };
+}
+function parseTableRow(trChildren) {
+  const cells = [];
+  for (const child of trChildren) {
+    const tag = getTagName(child);
+    if (tag === "th" || tag === "td") {
+      const cellChildren = getChildren(child);
+      const paragraphs = findChildren(cellChildren, "p");
+      if (paragraphs.length > 1) {
+        cells.push(paragraphs.map((p) => extractAllText(p.children)).join("<br>"));
+      } else {
+        cells.push(extractAllText(cellChildren));
+      }
+    }
+  }
+  return cells;
+}
+function parseTableWrap(tableWrapNode) {
+  const children = getChildren(tableWrapNode);
+  const labelNode = findChild(children, "label");
+  const label = labelNode ? extractAllText(labelNode.children) : "";
+  const captionNode = findChild(children, "caption");
+  const captionText = captionNode ? extractAllText(captionNode.children) : "";
+  const captionStr = [label, captionText].filter(Boolean).join(". ");
+  const tableNode = findChild(children, "table");
+  const result = {
+    headers: [],
+    rows: []
+  };
+  if (captionStr)
+    result.caption = captionStr;
+  if (!tableNode)
+    return result;
+  const thead = findChild(tableNode.children, "thead");
+  if (thead) {
+    const headRows = findChildren(thead.children, "tr");
+    if (headRows.length > 0) {
+      result.headers.push(...parseTableRow(headRows[0]?.children ?? []));
+    }
+  }
+  const tbody = findChild(tableNode.children, "tbody");
+  if (tbody) {
+    const bodyRows = findChildren(tbody.children, "tr");
+    for (const row of bodyRows) {
+      result.rows.push(parseTableRow(row.children));
+    }
+  }
+  return result;
+}
+function parseBoxedText(node) {
+  const children = getChildren(node);
+  const titleNode = findChild(children, "title");
+  const title = titleNode ? extractAllText(titleNode.children) : void 0;
+  const content = parseBlockContent(children);
+  const block = { type: "boxed-text", content };
+  if (title)
+    block.title = title;
+  return block;
+}
+function parseDefList(node) {
+  const children = getChildren(node);
+  const titleNode = findChild(children, "title");
+  const title = titleNode ? extractAllText(titleNode.children) : void 0;
+  const defItems = findChildren(children, "def-item");
+  const items = [];
+  for (const item of defItems) {
+    const termNode = findChild(item.children, "term");
+    const defNode = findChild(item.children, "def");
+    const term = termNode ? extractAllText(termNode.children) : "";
+    const definition = defNode ? extractAllText(defNode.children) : "";
+    items.push({ term, definition });
+  }
+  const block = { type: "def-list", items };
+  if (title)
+    block.title = title;
+  return block;
+}
+function parseDispFormula(node) {
+  const children = getChildren(node);
+  const id = getAttr(node, "id");
+  const labelNode = findChild(children, "label");
+  const label = labelNode ? extractAllText(labelNode.children) : void 0;
+  const alternatives = findChild(children, "alternatives");
+  const searchChildren = alternatives ? alternatives.children : children;
+  const texMath = findChild(searchChildren, "tex-math");
+  const block = { type: "formula" };
+  if (id)
+    block.id = id;
+  if (label)
+    block.label = label;
+  if (texMath) {
+    block.tex = extractAllText(texMath.children);
+  } else {
+    const textChildren = children.filter((c) => !("label" in c));
+    const text = extractAllText(textChildren).trim();
+    if (text)
+      block.text = text;
+  }
+  return block;
+}
+const BLOCK_TAGS = /* @__PURE__ */ new Set(["table-wrap", "fig", "disp-quote", "boxed-text"]);
+function parseDispQuote(node) {
+  const children = getChildren(node);
+  const paragraphs = findChildren(children, "p");
+  const content = [];
+  for (let i = 0; i < paragraphs.length; i++) {
+    if (i > 0)
+      content.push({ type: "text", text: "\n\n" });
+    const para = paragraphs[i];
+    if (para)
+      content.push(...parseInlineContent(para.children));
+  }
+  if (paragraphs.length === 0) {
+    content.push(...parseInlineContent(children));
+  }
+  return { type: "blockquote", content };
+}
+function parseTableBlock(node) {
+  const tableResult = parseTableWrap(node);
+  const tableBlock = {
+    type: "table",
+    headers: tableResult.headers,
+    rows: tableResult.rows
+  };
+  if (tableResult.caption)
+    tableBlock.caption = tableResult.caption;
+  return tableBlock;
+}
+function parseFigBlock(node) {
+  const innerChildren = getChildren(node);
+  const figBlock = { type: "figure" };
+  const figId = getAttr(node, "id");
+  if (figId)
+    figBlock.id = figId;
+  const figLabel = findChild(innerChildren, "label");
+  if (figLabel) {
+    const labelText = extractAllText(figLabel.children);
+    if (labelText)
+      figBlock.label = labelText;
+  }
+  const figCaption = findChild(innerChildren, "caption");
+  if (figCaption) {
+    const captionText = extractAllText(figCaption.children);
+    if (captionText)
+      figBlock.caption = captionText;
+  }
+  return figBlock;
+}
+function parseParagraph(pChildren) {
+  const hasNestedBlocks = pChildren.some((child) => {
+    const tag = getTagName(child);
+    return tag != null && BLOCK_TAGS.has(tag);
+  });
+  if (!hasNestedBlocks) {
+    return [{ type: "paragraph", content: parseInlineContent(pChildren) }];
+  }
+  const blocks = [];
+  let inlineBuffer = [];
+  const flushInline = () => {
+    if (inlineBuffer.length > 0) {
+      const content = parseInlineContent(inlineBuffer);
+      const hasNonWhitespace = content.some((c) => c.type !== "text" || c.text.trim() !== "");
+      if (content.length > 0 && hasNonWhitespace) {
+        blocks.push({ type: "paragraph", content });
+      }
+      inlineBuffer = [];
+    }
+  };
+  for (const child of pChildren) {
+    const tag = getTagName(child);
+    if (tag === "table-wrap") {
+      flushInline();
+      blocks.push(parseTableBlock(child));
+    } else if (tag === "fig") {
+      flushInline();
+      blocks.push(parseFigBlock(child));
+    } else if (tag === "disp-quote") {
+      flushInline();
+      blocks.push(parseDispQuote(child));
+    } else if (tag === "boxed-text") {
+      flushInline();
+      blocks.push(parseBoxedText(child));
+    } else {
+      inlineBuffer.push(child);
+    }
+  }
+  flushInline();
+  return blocks;
+}
+function parseSupplementaryMaterial(child) {
+  const innerChildren = getChildren(child);
+  const labelNode = findChild(innerChildren, "label");
+  const captionNode = findChild(innerChildren, "caption");
+  const labelText = labelNode ? extractAllText(labelNode.children) : "";
+  const captionText = captionNode ? extractAllText(captionNode.children) : "";
+  const text = [labelText, captionText].filter(Boolean).join(": ");
+  if (text) {
+    return { type: "paragraph", content: [{ type: "text", text }] };
+  }
+  return null;
+}
+const blockTagHandlers = {
+  p: (child) => parseParagraph(getChildren(child)),
+  list: (child) => parseList(child),
+  "table-wrap": (child) => parseTableBlock(child),
+  fig: (child) => parseFigBlock(child),
+  "disp-quote": (child) => parseDispQuote(child),
+  "boxed-text": (child) => parseBoxedText(child),
+  "def-list": (child) => parseDefList(child),
+  "disp-formula": (child) => parseDispFormula(child),
+  preformat: (child) => ({ type: "preformat", text: extractAllText(getChildren(child)) }),
+  "supplementary-material": (child) => parseSupplementaryMaterial(child)
+};
+function parseBlockContent(sectionChildren) {
+  const blocks = [];
+  for (const child of sectionChildren) {
+    const tag = getTagName(child);
+    if (!tag)
+      continue;
+    const handler = blockTagHandlers[tag];
+    if (!handler)
+      continue;
+    const result = handler(child);
+    if (result == null)
+      continue;
+    if (Array.isArray(result)) {
+      blocks.push(...result);
+    } else {
+      blocks.push(result);
+    }
+  }
+  return blocks;
+}
+function parseSection(secChildren, level) {
+  const titleNode = findChild(secChildren, "title");
+  const title = titleNode ? extractAllText(titleNode.children) : "";
+  const content = parseBlockContent(secChildren);
+  const subsections = [];
+  const nestedSecs = findChildren(secChildren, "sec");
+  for (const sub of nestedSecs) {
+    subsections.push(parseSection(sub.children, level + 1));
+  }
+  return { title, level, content, subsections };
+}
+function parseJatsBody(xml) {
+  const parsed = parser.parse(xml);
+  const article = findArticle(parsed);
+  if (!article)
+    return [];
+  const body = findChild(article.children, "body");
+  if (!body)
+    return [];
+  const sections = [];
+  const secs = findChildren(body.children, "sec");
+  if (secs.length > 0) {
+    for (const sec of secs) {
+      sections.push(parseSection(sec.children, 2));
+    }
+  } else {
+    const content = parseBlockContent(body.children);
+    if (content.length > 0) {
+      sections.push({ title: "", level: 2, content, subsections: [] });
+    }
+  }
+  return sections;
+}
+function extractCitationAuthors(children) {
+  const personGroup = findChild(children, "person-group");
+  if (!personGroup)
+    return void 0;
+  const names = findChildren(personGroup.children, "name");
+  const authorParts = [];
+  for (const name of names) {
+    const surname = findChild(name.children, "surname");
+    const givenNames = findChild(name.children, "given-names");
+    const surnameText = surname ? extractAllText(surname.children) : "";
+    const givenText = givenNames ? extractAllText(givenNames.children) : "";
+    if (surnameText && givenText) {
+      authorParts.push(`${surnameText} ${givenText}`);
+    } else if (surnameText) {
+      authorParts.push(surnameText);
+    }
+  }
+  return authorParts.length > 0 ? authorParts.join(", ") : void 0;
+}
+function formatYearVolumePage(children) {
+  const year = findChild(children, "year");
+  if (!year)
+    return void 0;
+  let yearStr = extractAllText(year.children);
+  const volume = findChild(children, "volume");
+  if (volume) {
+    yearStr += `;${extractAllText(volume.children)}`;
+  }
+  const fpage = findChild(children, "fpage");
+  if (fpage) {
+    const fpageText = extractAllText(fpage.children);
+    const lpage = findChild(children, "lpage");
+    const lpageText = lpage ? extractAllText(lpage.children) : "";
+    yearStr += `:${fpageText}${lpageText ? `-${lpageText}` : ""}`;
+  }
+  return yearStr;
+}
+function formatElementCitation(children) {
+  const parts = [];
+  const authorsStr = extractCitationAuthors(children);
+  if (authorsStr)
+    parts.push(authorsStr);
+  const articleTitle = findChild(children, "article-title");
+  if (articleTitle) {
+    parts.push(extractAllText(articleTitle.children));
+  }
+  const source = findChild(children, "source");
+  if (source) {
+    parts.push(extractAllText(source.children));
+  }
+  const yearVolumePage = formatYearVolumePage(children);
+  if (yearVolumePage)
+    parts.push(yearVolumePage);
+  return `${parts.join(". ")}.`;
+}
+function extractMixedCitationText(children) {
+  const pubIds = findChildren(children, "pub-id");
+  const pubIdValues = pubIds.map((p) => extractAllText(p.children).trim()).filter(Boolean);
+  if (pubIdValues.length === 0) {
+    return extractAllText(children).trim();
+  }
+  const fullText = extractAllText(children).trim();
+  let result = fullText;
+  for (const val of pubIdValues) {
+    const escaped = val.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const matches = result.match(new RegExp(escaped, "g"));
+    if (matches && matches.length > 1) {
+      result = result.replace(val, "");
+      result = result.replace(/\s{2,}/g, " ").trim();
+    }
+  }
+  return result;
+}
+function extractPubIds(children) {
+  const pubIds = findChildren(children, "pub-id");
+  const result = {};
+  for (const p of pubIds) {
+    const idType = p.attrs["pub-id-type"];
+    const value = extractAllText(p.children).trim();
+    if (!value)
+      continue;
+    if (idType === "doi")
+      result.doi = value;
+    if (idType === "pmid")
+      result.pmid = value;
+    if (idType === "pmc" || idType === "pmcid") {
+      result.pmcid = value.replace(/^PMC/, "");
+    }
+  }
+  return result;
+}
+function stripPubIdValues(text, pubIds) {
+  let result = text;
+  const values = [pubIds.doi, pubIds.pmid, pubIds.pmcid].filter(Boolean);
+  for (const val of values) {
+    const escaped = val.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    result = result.replace(new RegExp(`(?:doi|PMID|pmid|PMC|pmc)[:\\s]*${escaped}`, "gi"), "");
+    result = result.replace(new RegExp(escaped, "g"), "");
+  }
+  if (pubIds.pmcid) {
+    const pmcFull = `PMC${pubIds.pmcid}`;
+    const escaped = pmcFull.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    result = result.replace(new RegExp(`(?:pmc|pmcid)[:\\s]*${escaped}`, "gi"), "");
+    result = result.replace(new RegExp(escaped, "g"), "");
+  }
+  result = result.replace(/\s{2,}/g, " ").trim();
+  result = result.replace(/\.\s*\.$/, ".");
+  return result;
+}
+function parseSingleReference(ref) {
+  const id = getAttr(ref.node, "id") ?? "";
+  const citationAlternatives = findChild(ref.children, "citation-alternatives");
+  const searchChildren = citationAlternatives ? citationAlternatives.children : ref.children;
+  const mixedCitation = findChild(searchChildren, "mixed-citation");
+  if (mixedCitation) {
+    const rawText = extractMixedCitationText(mixedCitation.children);
+    const pubIds = extractPubIds(mixedCitation.children);
+    const text2 = stripPubIdValues(rawText, pubIds);
+    if (id && text2)
+      return { id, text: text2, ...pubIds };
+    return null;
+  }
+  const elementCitation = findChild(searchChildren, "element-citation");
+  if (elementCitation) {
+    const rawText = formatElementCitation(elementCitation.children);
+    const pubIds = extractPubIds(elementCitation.children);
+    const text2 = stripPubIdValues(rawText, pubIds);
+    if (id && text2)
+      return { id, text: text2, ...pubIds };
+    return null;
+  }
+  const childrenWithoutLabel = ref.children.filter((c) => !("label" in c));
+  const text = extractAllText(childrenWithoutLabel).trim();
+  if (id && text)
+    return { id, text };
+  return null;
+}
+function parseJatsReferences(xml) {
+  const parsed = parser.parse(xml);
+  const article = findArticle(parsed);
+  if (!article)
+    return [];
+  const back = findChild(article.children, "back");
+  if (!back)
+    return [];
+  const refList = findChild(back.children, "ref-list");
+  if (!refList)
+    return [];
+  const refs = findChildren(refList.children, "ref");
+  const references = [];
+  for (const ref of refs) {
+    const reference = parseSingleReference(ref);
+    if (reference)
+      references.push(reference);
+  }
+  return references;
+}
+function parseAcknowledgments(backChildren) {
+  const ack = findChild(backChildren, "ack");
+  if (!ack)
+    return void 0;
+  const paragraphs = findChildren(ack.children, "p");
+  if (paragraphs.length > 0) {
+    return paragraphs.map((p) => extractAllText(p.children)).join("\n\n");
+  }
+  return void 0;
+}
+function parseAppendices(backChildren) {
+  const appGroup = findChild(backChildren, "app-group");
+  if (!appGroup)
+    return void 0;
+  const apps = findChildren(appGroup.children, "app");
+  if (apps.length === 0)
+    return void 0;
+  return apps.map((app) => parseSection(app.children, 2));
+}
+function parseSingleFootnote(fn) {
+  const parts = [];
+  const titleNode = findChild(fn.children, "title");
+  if (titleNode) {
+    const titleText = extractAllText(titleNode.children).trim();
+    if (titleText)
+      parts.push(titleText);
+  }
+  const paragraphs = findChildren(fn.children, "p");
+  for (const p of paragraphs) {
+    const pText = extractAllText(p.children).trim();
+    if (pText)
+      parts.push(pText);
+  }
+  return {
+    id: getAttr(fn.node, "id") ?? "",
+    text: parts.join(" ")
+  };
+}
+function parseFootnotes(backChildren) {
+  const fnGroup = findChild(backChildren, "fn-group");
+  if (!fnGroup)
+    return void 0;
+  const fns = findChildren(fnGroup.children, "fn");
+  if (fns.length === 0)
+    return void 0;
+  return fns.map(parseSingleFootnote);
+}
+function parseSingleNotesElement(note) {
+  const notes = [];
+  const secs = findChildren(note.children, "sec");
+  const nestedNotes = findChildren(note.children, "notes");
+  const subItems = secs.length > 0 ? secs : nestedNotes;
+  if (subItems.length > 0) {
+    for (const sub of subItems) {
+      const subTitleNode = findChild(sub.children, "title");
+      const subTitle = subTitleNode ? extractAllText(subTitleNode.children) : "";
+      const subParagraphs = findChildren(sub.children, "p");
+      const subText = subParagraphs.map((p) => extractAllText(p.children)).join("\n\n");
+      if (subTitle || subText) {
+        notes.push({ title: subTitle, text: subText });
+      }
+    }
+    return notes;
+  }
+  const titleNode = findChild(note.children, "title");
+  const title = titleNode ? extractAllText(titleNode.children) : "";
+  const paragraphs = findChildren(note.children, "p");
+  const text = paragraphs.map((p) => extractAllText(p.children)).join("\n\n");
+  if (title || text) {
+    notes.push({ title, text });
+  }
+  return notes;
+}
+function parseNotes(backChildren) {
+  const notesElements = findChildren(backChildren, "notes");
+  if (notesElements.length === 0)
+    return void 0;
+  const notes = [];
+  for (const note of notesElements) {
+    notes.push(...parseSingleNotesElement(note));
+  }
+  return notes.length > 0 ? notes : void 0;
+}
+function parseGlossary(backChildren) {
+  const glossaryElements = findChildren(backChildren, "glossary");
+  const notes = [];
+  for (const glossary of glossaryElements) {
+    const titleNode = findChild(glossary.children, "title");
+    const title = titleNode ? extractAllText(titleNode.children) : "Glossary";
+    const defList = findChild(glossary.children, "def-list");
+    if (!defList)
+      continue;
+    const defItems = findChildren(defList.children, "def-item");
+    const lines = [];
+    for (const item of defItems) {
+      const termNode = findChild(item.children, "term");
+      const defNode = findChild(item.children, "def");
+      const term = termNode ? extractAllText(termNode.children) : "";
+      const definition = defNode ? extractAllText(defNode.children) : "";
+      lines.push(`${term}: ${definition}`);
+    }
+    notes.push({ title, text: lines.join("\n") });
+  }
+  return notes;
+}
+function parseFloatsGroup(articleChildren) {
+  const floatsGroup = findChild(articleChildren, "floats-group");
+  if (!floatsGroup)
+    return void 0;
+  const blocks = [];
+  for (const child of floatsGroup.children) {
+    const tag = getTagName(child);
+    if (tag === "fig") {
+      blocks.push(parseFigBlock(child));
+    } else if (tag === "table-wrap") {
+      blocks.push(parseTableBlock(child));
+    }
+  }
+  return blocks.length > 0 ? blocks : void 0;
+}
+function parseJatsBackMatter(xml) {
+  const parsed = parser.parse(xml);
+  const article = findArticle(parsed);
+  if (!article)
+    return {};
+  const result = {};
+  const back = findChild(article.children, "back");
+  if (back) {
+    const ack = parseAcknowledgments(back.children);
+    if (ack)
+      result.acknowledgments = ack;
+    const app = parseAppendices(back.children);
+    if (app)
+      result.appendices = app;
+    const fn = parseFootnotes(back.children);
+    if (fn)
+      result.footnotes = fn;
+    const notes = parseNotes(back.children);
+    const glossaryNotes = parseGlossary(back.children);
+    if (notes || glossaryNotes.length > 0) {
+      result.notes = [...notes ?? [], ...glossaryNotes];
+    }
+  }
+  const floats = parseFloatsGroup(article.children);
+  if (floats)
+    result.floats = floats;
+  return result;
+}
+export {
+  parseJatsBackMatter,
+  parseJatsBody,
+  parseJatsMetadata,
+  parseJatsReferences
+};
+//# sourceMappingURL=jats-parser.js.map