@everdeep/pubmed 0.1.0

package/dist/index.js

@@ -0,0 +1,2515 @@
+// src/client.ts
+import { XMLParser as XMLParser2 } from "fast-xml-parser";
+
+// src/errors.ts
+var PubMedError = class extends Error {
+  code;
+  retryable;
+  constructor(message, code, retryable = false, options) {
+    super(message, options);
+    this.name = "PubMedError";
+    this.code = code;
+    this.retryable = retryable;
+  }
+  toJSON() {
+    return { name: this.name, message: this.message, code: this.code, retryable: this.retryable };
+  }
+};
+var ValidationError = class extends PubMedError {
+  constructor(message) {
+    super(message, "VALIDATION_ERROR");
+    this.name = "ValidationError";
+  }
+};
+var HttpError = class extends PubMedError {
+  status;
+  constructor(status, retryable) {
+    super(`PubMed request failed with HTTP status ${status}`, "HTTP_ERROR", retryable);
+    this.name = "HttpError";
+    this.status = status;
+  }
+};
+var RateLimitError = class extends PubMedError {
+  status = 429;
+  constructor() {
+    super("PubMed rate limit was exceeded", "RATE_LIMIT_ERROR", true);
+    this.name = "RateLimitError";
+  }
+};
+var TimeoutError = class extends PubMedError {
+  constructor(options) {
+    super("PubMed request timed out", "TIMEOUT_ERROR", true, options);
+    this.name = "TimeoutError";
+  }
+};
+var NetworkError = class extends PubMedError {
+  constructor(options) {
+    super("PubMed network request failed", "NETWORK_ERROR", true, options);
+    this.name = "NetworkError";
+  }
+};
+var ResponseTooLargeError = class extends PubMedError {
+  limitBytes;
+  constructor(limitBytes) {
+    super(`PubMed response exceeded the configured ${limitBytes} byte limit`, "RESPONSE_TOO_LARGE");
+    this.name = "ResponseTooLargeError";
+    this.limitBytes = limitBytes;
+  }
+};
+var QueueFullError = class extends PubMedError {
+  constructor() {
+    super("PubMed rate-limit queue is full", "QUEUE_FULL");
+    this.name = "QueueFullError";
+  }
+};
+var ParseError = class extends PubMedError {
+  constructor(message = "PubMed returned malformed XML", options) {
+    super(message, "PARSE_ERROR", false, options);
+    this.name = "ParseError";
+  }
+};
+var InvalidResponseError = class extends PubMedError {
+  constructor(message = "PubMed returned an invalid response", options) {
+    super(message, "INVALID_RESPONSE", false, options);
+    this.name = "InvalidResponseError";
+  }
+};
+var CursorExpiredError = class extends PubMedError {
+  constructor() {
+    super("The PubMed search cursor has expired", "CURSOR_EXPIRED");
+    this.name = "CursorExpiredError";
+  }
+};
+var CursorInvalidError = class extends PubMedError {
+  constructor() {
+    super("The PubMed search cursor is invalid", "CURSOR_INVALID");
+    this.name = "CursorInvalidError";
+  }
+};
+var AbortedError = class extends PubMedError {
+  constructor(options) {
+    super("PubMed request was aborted", "ABORTED", false, options);
+    this.name = "AbortedError";
+  }
+};
+var SearchLimitError = class extends PubMedError {
+  limit;
+  constructor(limit = 1e4) {
+    super(`PubMed searches cannot retrieve results beyond the ${limit} record window`, "SEARCH_LIMIT");
+    this.name = "SearchLimitError";
+    this.limit = limit;
+  }
+};
+
+// src/parser/xml-framing.ts
+import { XMLValidator } from "fast-xml-parser";
+
+// src/parser/xml-values.ts
+function object(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function at(value, key) {
+  return object(value)?.[key];
+}
+function list(value) {
+  if (value === void 0 || value === null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function isXmlCodePoint(codePoint) {
+  return codePoint === 9 || codePoint === 10 || codePoint === 13 || codePoint >= 32 && codePoint <= 55295 || codePoint >= 57344 && codePoint <= 65533 || codePoint >= 65536 && codePoint <= 1114111;
+}
+function decodeNumericReference(body) {
+  const hexadecimal = body.toLowerCase().startsWith("#x");
+  const codePoint = Number.parseInt(body.slice(hexadecimal ? 2 : 1), hexadecimal ? 16 : 10);
+  if (!Number.isSafeInteger(codePoint) || !isXmlCodePoint(codePoint)) throw new ParseError();
+  try {
+    return String.fromCodePoint(codePoint);
+  } catch {
+    throw new ParseError();
+  }
+}
+function decodeEntities(value) {
+  return value.replace(/&(lt|gt|quot|apos|amp|#x[0-9a-f]+|#[0-9]+);/gi, (_entity, body) => {
+    const named = body.toLowerCase();
+    if (named === "lt") return "<";
+    if (named === "gt") return ">";
+    if (named === "quot") return '"';
+    if (named === "apos") return "'";
+    if (named === "amp") return "&";
+    return decodeNumericReference(body);
+  });
+}
+function normalizeText(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function cleanText(value) {
+  return normalizeText(decodeEntities(value));
+}
+function text(value) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    const result2 = cleanText(String(value));
+    return result2 === "" ? void 0 : result2;
+  }
+  if (Array.isArray(value)) {
+    const result2 = cleanText(value.map((item) => text(item) ?? "").join(" "));
+    return result2 === "" ? void 0 : result2;
+  }
+  const record = object(value);
+  if (record === void 0) return void 0;
+  const parts = [];
+  for (const [key, child] of Object.entries(record)) {
+    if (!key.startsWith("@")) parts.push(text(child) ?? "");
+  }
+  const result = cleanText(parts.join(" "));
+  return result === "" ? void 0 : result;
+}
+function attribute(value, name) {
+  return text(object(value)?.[`@${name}`]);
+}
+function json(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
+  if (Array.isArray(value)) return value.map(json);
+  const record = object(value);
+  if (record === void 0) return null;
+  const result = {};
+  for (const [key, child] of Object.entries(record)) {
+    if (child !== void 0) result[key] = json(child);
+  }
+  return result;
+}
+function partialDate(value) {
+  const source = object(value);
+  if (source === void 0) return void 0;
+  const result = {};
+  const keys = ["Year", "Month", "Day", "Season", "MedlineDate", "Hour", "Minute", "Second"];
+  const targets = ["year", "month", "day", "season", "medlineDate", "hour", "minute", "second"];
+  keys.forEach((key, index) => {
+    const found = text(source[key]);
+    const target = targets[index];
+    if (found !== void 0 && target !== void 0) result[target] = found;
+  });
+  return Object.keys(result).length === 0 ? void 0 : result;
+}
+
+// src/parser/xml-framing.ts
+function markupEnd(xml, start) {
+  if (xml.startsWith("<!--", start)) {
+    const end = xml.indexOf("-->", start + 4);
+    if (end < 0) throw new ParseError();
+    return end + 3;
+  }
+  if (xml.startsWith("<![CDATA[", start)) {
+    const end = xml.indexOf("]]>", start + 9);
+    if (end < 0) throw new ParseError();
+    return end + 3;
+  }
+  if (xml.startsWith("<?", start)) {
+    const end = xml.indexOf("?>", start + 2);
+    if (end < 0) throw new ParseError();
+    return end + 2;
+  }
+  let quote;
+  let subsetDepth = 0;
+  for (let index = start + 1; index < xml.length; index += 1) {
+    const character = xml[index];
+    if (quote !== void 0) {
+      if (character === quote) quote = void 0;
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+    } else if (character === "[") {
+      subsetDepth += 1;
+    } else if (character === "]" && subsetDepth > 0) {
+      subsetDepth -= 1;
+    } else if (character === ">" && subsetDepth === 0) {
+      return index + 1;
+    }
+  }
+  throw new ParseError();
+}
+function tagDetails(token) {
+  if (token.startsWith("<!--") || token.startsWith("<![") || token.startsWith("<?") || /^<!DOCTYPE/i.test(token)) {
+    return { kind: "other" };
+  }
+  const endMatch = /^<\/\s*([^\s>]+)\s*>$/.exec(token);
+  if (endMatch?.[1] !== void 0) return { kind: "end", name: endMatch[1] };
+  const startMatch = /^<\s*([^\s/>]+)/.exec(token);
+  if (startMatch?.[1] === void 0) return { kind: "other" };
+  return { kind: "start", name: startMatch[1], selfClosing: /\/\s*>$/.test(token) };
+}
+function validateNumericReferencesIn(value) {
+  let position = 0;
+  while (true) {
+    const start = value.indexOf("&#", position);
+    if (start < 0) return;
+    const match = /^&#(?:x[0-9a-f]+|[0-9]+);/i.exec(value.slice(start));
+    const body = match?.[0].slice(1, -1);
+    if (match === null || body === void 0) throw new ParseError();
+    decodeNumericReference(body);
+    position = start + match[0].length;
+  }
+}
+function validateNumericReferences(xml) {
+  let position = 0;
+  while (position < xml.length) {
+    const markupStart = xml.indexOf("<", position);
+    const textEnd = markupStart < 0 ? xml.length : markupStart;
+    validateNumericReferencesIn(xml.slice(position, textEnd));
+    if (markupStart < 0) return;
+    const markupFinish = markupEnd(xml, markupStart);
+    const token = xml.slice(markupStart, markupFinish);
+    if (!token.startsWith("<![CDATA[") && !token.startsWith("<!--") && !token.startsWith("<?")) {
+      validateNumericReferencesIn(token);
+    }
+    position = markupFinish;
+  }
+}
+function extractFragments(xml) {
+  validateNumericReferences(xml);
+  const validation = XMLValidator.validate(xml, { allowBooleanAttributes: false });
+  if (validation !== true) throw new ParseError();
+  const fragments = [];
+  const stack = [];
+  let rootSeen = false;
+  let rootClosed = false;
+  let childStart = -1;
+  let childName = "";
+  let position = 0;
+  while (position < xml.length) {
+    const start = xml.indexOf("<", position);
+    if (start < 0) break;
+    const end = markupEnd(xml, start);
+    const details = tagDetails(xml.slice(start, end));
+    position = end;
+    if (details.kind === "other") continue;
+    if (details.kind === "start") {
+      const name2 = details.name;
+      if (name2 === void 0) throw new ParseError();
+      if (!rootSeen) {
+        if (name2 !== "PubmedArticleSet") throw new ParseError("Expected a PubmedArticleSet root element");
+        rootSeen = true;
+        if (details.selfClosing === true) rootClosed = true;
+        else stack.push(name2);
+        continue;
+      }
+      if (rootClosed || stack.length === 0) throw new ParseError();
+      if (stack.length === 1) {
+        childStart = start;
+        childName = name2;
+      }
+      if (details.selfClosing === true) {
+        if (stack.length === 1) fragments.push({ name: name2, rawXml: xml.slice(start, end) });
+      } else {
+        stack.push(name2);
+      }
+      continue;
+    }
+    const name = details.name;
+    const expected = stack.at(-1);
+    if (name === void 0 || expected !== name) throw new ParseError();
+    if (stack.length === 2) {
+      if (childStart < 0) throw new ParseError();
+      fragments.push({ name: childName, rawXml: xml.slice(childStart, end) });
+      childStart = -1;
+      childName = "";
+    }
+    stack.pop();
+    if (stack.length === 0) rootClosed = true;
+  }
+  if (!rootSeen || !rootClosed || stack.length !== 0) throw new ParseError();
+  return fragments;
+}
+function rawElementTexts(xml, elementName) {
+  const results = [];
+  let position = 0;
+  while (position < xml.length) {
+    const candidate = xml.indexOf("<", position);
+    if (candidate < 0) break;
+    const openingEnd = markupEnd(xml, candidate);
+    const opening = tagDetails(xml.slice(candidate, openingEnd));
+    if (opening.kind !== "start" || opening.name !== elementName) {
+      position = openingEnd;
+      continue;
+    }
+    if (opening.selfClosing === true) {
+      results.push("");
+      position = openingEnd;
+      continue;
+    }
+    let innerPosition = openingEnd;
+    let depth = 1;
+    const parts = [];
+    while (innerPosition < xml.length) {
+      const start = xml.indexOf("<", innerPosition);
+      if (start < 0) return results;
+      parts.push(decodeEntities(xml.slice(innerPosition, start)));
+      const end = markupEnd(xml, start);
+      const token = xml.slice(start, end);
+      if (token.startsWith("<![CDATA[")) parts.push(token.slice(9, -3));
+      const details = tagDetails(token);
+      if (details.kind === "start" && details.selfClosing !== true) depth += 1;
+      if (details.kind === "end") depth -= 1;
+      innerPosition = end;
+      if (depth === 0) {
+        results.push(normalizeText(parts.join("")));
+        position = end;
+        break;
+      }
+    }
+    if (depth !== 0) break;
+  }
+  return results;
+}
+function rawElementText(xml, elementName) {
+  const result = rawElementTexts(xml, elementName)[0];
+  return result === void 0 || result === "" ? void 0 : result;
+}
+
+// src/parser/record-mapping.ts
+import { XMLParser } from "fast-xml-parser";
+var parser = new XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@",
+  textNodeName: "#text",
+  parseTagValue: false,
+  parseAttributeValue: false,
+  trimValues: false,
+  processEntities: false,
+  allowBooleanAttributes: false
+});
+function affiliations(author) {
+  return list(at(author, "AffiliationInfo")).map((item) => {
+    const identifiers3 = list(at(item, "Identifier")).flatMap((identifier) => {
+      const value = text(identifier);
+      return value === void 0 ? [] : [{ type: attribute(identifier, "Source") ?? "unknown", value, provenance: "citation" }];
+    });
+    return { text: text(at(item, "Affiliation")) ?? "", identifiers: identifiers3 };
+  }).filter((item) => item.text !== "" || item.identifiers.length > 0);
+}
+function authors(value) {
+  return list(at(value, "Author")).flatMap((author) => {
+    const collectiveName = text(at(author, "CollectiveName"));
+    const identifiers3 = list(at(author, "Identifier")).flatMap((identifier) => {
+      const identifierText = text(identifier);
+      const source = attribute(identifier, "Source");
+      return identifierText === void 0 ? [] : [{ value: identifierText, ...source === void 0 ? {} : { source } }];
+    });
+    const common = { affiliations: affiliations(author), identifiers: identifiers3 };
+    if (collectiveName !== void 0) return [{ type: "collective", name: collectiveName, ...common }];
+    const lastName = text(at(author, "LastName"));
+    const foreName = text(at(author, "ForeName"));
+    const initials = text(at(author, "Initials"));
+    const suffix = text(at(author, "Suffix"));
+    const fullName = [foreName ?? initials, lastName, suffix].filter((part) => part !== void 0).join(" ");
+    if (fullName === "") return [];
+    const orcid = identifiers3.find((identifier) => identifier.source?.toLowerCase() === "orcid")?.value;
+    return [{
+      type: "personal",
+      fullName,
+      ...common,
+      ...lastName === void 0 ? {} : { lastName },
+      ...foreName === void 0 ? {} : { foreName },
+      ...initials === void 0 ? {} : { initials },
+      ...suffix === void 0 ? {} : { suffix },
+      ...attribute(author, "ValidYN") === void 0 ? {} : { valid: attribute(author, "ValidYN") === "Y" },
+      ...orcid === void 0 ? {} : { orcid }
+    }];
+  });
+}
+function abstracts(value, rawXml) {
+  const rawTexts = rawElementTexts(rawXml, "AbstractText");
+  return list(at(value, "AbstractText")).flatMap((section, index) => {
+    const rawText = rawTexts[index];
+    const sectionText = rawText === void 0 || rawText === "" ? text(section) : rawText;
+    if (sectionText === void 0) return [];
+    const label = attribute(section, "Label");
+    const category = attribute(section, "NlmCategory");
+    return [{ text: sectionText, ...label === void 0 ? {} : { label }, ...category === void 0 ? {} : { category } }];
+  });
+}
+function meshHeadings(value) {
+  return list(at(value, "MeshHeading")).flatMap((heading) => {
+    const descriptorNode = at(heading, "DescriptorName");
+    const descriptor = text(descriptorNode);
+    if (descriptor === void 0) return [];
+    const descriptorUi = attribute(descriptorNode, "UI");
+    const descriptorMajor = attribute(descriptorNode, "MajorTopicYN");
+    const qualifiers = list(at(heading, "QualifierName")).flatMap((qualifier) => {
+      const name = text(qualifier);
+      if (name === void 0) return [];
+      const ui = attribute(qualifier, "UI");
+      const major = attribute(qualifier, "MajorTopicYN");
+      return [{ name, ...ui === void 0 ? {} : { ui }, ...major === void 0 ? {} : { majorTopic: major === "Y" } }];
+    });
+    return [{ descriptor, qualifiers, ...descriptorUi === void 0 ? {} : { descriptorUi }, ...descriptorMajor === void 0 ? {} : { majorTopic: descriptorMajor === "Y" } }];
+  });
+}
+function keywords(value) {
+  return list(value).flatMap((keywordList) => {
+    const owner = attribute(keywordList, "Owner");
+    return list(at(keywordList, "Keyword")).flatMap((keyword) => {
+      const found = text(keyword);
+      if (found === void 0) return [];
+      const major = attribute(keyword, "MajorTopicYN");
+      return [{ value: found, ...owner === void 0 ? {} : { owner }, ...major === void 0 ? {} : { majorTopic: major === "Y" } }];
+    });
+  });
+}
+function identifiers(pmidNode, articleIds, provenance) {
+  const result = [];
+  const pmid = text(pmidNode);
+  if (pmid !== void 0) result.push({ type: "pubmed", value: pmid, provenance: "citation" });
+  for (const id of list(at(articleIds, "ArticleId"))) {
+    const value = text(id);
+    if (value !== void 0) result.push({ type: attribute(id, "IdType") ?? "unknown", value, provenance });
+  }
+  return result;
+}
+function conveniences(ids) {
+  const find = (...types) => ids.find((id) => types.includes(id.type.toLowerCase()))?.value;
+  const pmid = find("pubmed", "pmid");
+  const doi = find("doi");
+  const pmcid = find("pmc", "pmcid");
+  return { ...pmid === void 0 ? {} : { pmid }, ...doi === void 0 ? {} : { doi }, ...pmcid === void 0 ? {} : { pmcid } };
+}
+function canonicalLinks(ids) {
+  const values2 = conveniences(ids);
+  const links = [];
+  if (values2.pmid !== void 0 && /^[1-9][0-9]*$/.test(values2.pmid)) {
+    links.push({ url: `https://pubmed.ncbi.nlm.nih.gov/${values2.pmid}/`, type: "pubmed", provenance: "canonical" });
+  }
+  if (values2.doi !== void 0) {
+    links.push({ url: `https://doi.org/${encodeURIComponent(values2.doi)}`, type: "doi", provenance: "canonical" });
+  }
+  if (values2.pmcid !== void 0 && /^PMC[1-9][0-9]*$/i.test(values2.pmcid)) {
+    links.push({ url: `https://pmc.ncbi.nlm.nih.gov/articles/${values2.pmcid.toUpperCase()}/`, type: "pmc", provenance: "canonical" });
+  }
+  return links;
+}
+function dates(citation, article, pubmedData) {
+  const history2 = list(at(at(pubmedData, "History"), "PubMedPubDate")).flatMap((entry) => {
+    const date = partialDate(entry);
+    return date === void 0 ? [] : [{ status: attribute(entry, "PubStatus") ?? "unknown", date }];
+  });
+  const articleDates = list(at(article, "ArticleDate"));
+  const electronic = partialDate(articleDates.find((entry) => (attribute(entry, "DateType") ?? "").toLowerCase() === "electronic"));
+  const journalPubDate = partialDate(at(at(at(article, "Journal"), "JournalIssue"), "PubDate"));
+  const pubModel = attribute(article, "PubModel")?.toLowerCase();
+  const print = pubModel?.includes("print") === true ? journalPubDate : void 0;
+  const completed = partialDate(at(citation, "DateCompleted"));
+  const revised = partialDate(at(citation, "DateRevised"));
+  return {
+    history: history2,
+    ...completed === void 0 ? {} : { completed },
+    ...revised === void 0 ? {} : { revised },
+    ...electronic === void 0 ? {} : { electronic },
+    ...print === void 0 ? {} : { print }
+  };
+}
+function parseArticle(root, rawXml) {
+  const citation = at(root, "MedlineCitation");
+  const article = at(citation, "Article");
+  const pubmedData = at(root, "PubmedData");
+  const baseIds = identifiers(at(citation, "PMID"), at(pubmedData, "ArticleIdList"), "article-id");
+  const citationIds = [
+    ...list(at(article, "ELocationID")).flatMap((identifier) => {
+      const value = text(identifier);
+      return value === void 0 ? [] : [{ type: attribute(identifier, "EIdType") ?? "elocation", value, provenance: "citation" }];
+    }),
+    ...list(at(citation, "OtherID")).flatMap((identifier) => {
+      const value = text(identifier);
+      return value === void 0 ? [] : [{ type: attribute(identifier, "Source") ?? "other", value, provenance: "citation" }];
+    })
+  ];
+  const [firstId, ...remainingIds] = baseIds;
+  const ids = firstId === void 0 ? citationIds : [firstId, ...citationIds, ...remainingIds];
+  const values2 = conveniences(ids);
+  const journalNode = at(article, "Journal");
+  const issueNode = at(journalNode, "JournalIssue");
+  const journalTitle = text(at(journalNode, "Title"));
+  const isoAbbreviation = text(at(journalNode, "ISOAbbreviation"));
+  const issn = text(at(journalNode, "ISSN"));
+  const issnType = attribute(at(journalNode, "ISSN"), "IssnType");
+  const volume = text(at(issueNode, "Volume"));
+  const issue = text(at(issueNode, "Issue"));
+  const pagination = text(at(at(article, "Pagination"), "MedlinePgn"));
+  const pubDate = partialDate(at(issueNode, "PubDate"));
+  const title = rawElementText(rawXml, "ArticleTitle") ?? text(at(article, "ArticleTitle"));
+  const vernacularTitle = text(at(article, "VernacularTitle"));
+  const citationStatus = attribute(citation, "Status");
+  const abstractNode = at(article, "Abstract");
+  const abstractCopyright = text(at(abstractNode, "CopyrightInformation"));
+  const journal2 = {
+    ...journalTitle === void 0 ? {} : { title: journalTitle },
+    ...isoAbbreviation === void 0 ? {} : { isoAbbreviation },
+    ...issn === void 0 ? {} : { issn },
+    ...issnType === void 0 ? {} : { issnType },
+    ...volume === void 0 ? {} : { volume },
+    ...issue === void 0 ? {} : { issue },
+    ...pagination === void 0 ? {} : { pagination },
+    ...pubDate === void 0 ? {} : { pubDate }
+  };
+  return {
+    kind: "article",
+    recordType: "PubmedArticle",
+    rawXml,
+    source: json(root),
+    identifiers: ids,
+    links: canonicalLinks(ids),
+    abstract: abstracts(abstractNode, rawXml),
+    ...abstractCopyright === void 0 ? {} : { abstractCopyright },
+    authors: authors(at(article, "AuthorList")),
+    languages: list(at(article, "Language")).flatMap((item) => text(item) ?? []),
+    publicationTypes: list(at(at(article, "PublicationTypeList"), "PublicationType")).flatMap((item) => text(item) ?? []),
+    keywords: keywords(at(citation, "KeywordList")),
+    meshHeadings: meshHeadings(at(citation, "MeshHeadingList")),
+    dates: dates(citation, article, pubmedData),
+    journal: journal2,
+    ...values2,
+    ...title === void 0 ? {} : { title },
+    ...vernacularTitle === void 0 ? {} : { vernacularTitle },
+    ...citationStatus === void 0 ? {} : { citationStatus }
+  };
+}
+function parseBook(root, rawXml) {
+  const document = at(root, "BookDocument");
+  const pubmedBookData = at(root, "PubmedBookData");
+  const ids = identifiers(at(document, "PMID"), at(pubmedBookData, "ArticleIdList"), "book");
+  const values2 = conveniences(ids);
+  const bookNode = at(document, "Book");
+  const publisher = at(bookNode, "Publisher");
+  const bookTitle = text(at(bookNode, "BookTitle"));
+  const collectionTitle = text(at(bookNode, "CollectionTitle"));
+  const publisherName = text(at(publisher, "PublisherName"));
+  const publisherLocation = text(at(publisher, "PublisherLocation"));
+  const edition = text(at(bookNode, "Edition"));
+  const title = rawElementText(rawXml, "ArticleTitle") ?? text(at(document, "ArticleTitle"));
+  const abstractNode = at(document, "Abstract");
+  const abstractCopyright = text(at(abstractNode, "CopyrightInformation"));
+  return {
+    kind: "book",
+    recordType: "PubmedBookArticle",
+    rawXml,
+    source: json(root),
+    identifiers: ids,
+    links: canonicalLinks(ids),
+    abstract: abstracts(abstractNode, rawXml),
+    ...abstractCopyright === void 0 ? {} : { abstractCopyright },
+    authors: authors(at(document, "AuthorList")),
+    languages: list(at(document, "Language")).flatMap((item) => text(item) ?? []),
+    publicationTypes: list(at(at(document, "PublicationTypeList"), "PublicationType")).flatMap((item) => text(item) ?? []),
+    keywords: keywords(at(document, "KeywordList")),
+    meshHeadings: [],
+    dates: dates(document, document, pubmedBookData),
+    book: {
+      isbn: list(at(bookNode, "Isbn")).flatMap((item) => text(item) ?? []),
+      ...bookTitle === void 0 ? {} : { title: bookTitle },
+      ...collectionTitle === void 0 ? {} : { collectionTitle },
+      ...publisherName === void 0 ? {} : { publisher: publisherName },
+      ...publisherLocation === void 0 ? {} : { location: publisherLocation },
+      ...edition === void 0 ? {} : { edition }
+    },
+    ...values2,
+    ...title === void 0 ? {} : { title }
+  };
+}
+function parseFragment(fragment) {
+  let parsed;
+  try {
+    parsed = parser.parse(fragment.rawXml);
+  } catch {
+    throw new ParseError();
+  }
+  const document = object(parsed);
+  const rootValue = document?.[fragment.name];
+  const root = object(rootValue);
+  if (fragment.name === "PubmedArticle") {
+    if (root === void 0) throw new ParseError();
+    return parseArticle(root, fragment.rawXml);
+  }
+  if (fragment.name === "PubmedBookArticle") {
+    if (root === void 0) throw new ParseError();
+    return parseBook(root, fragment.rawXml);
+  }
+  const source = root === void 0 ? { value: json(rootValue) } : json(root);
+  return {
+    kind: "unknown",
+    recordType: fragment.name,
+    rawXml: fragment.rawXml,
+    source,
+    identifiers: [],
+    links: [],
+    abstract: [],
+    authors: [],
+    languages: [],
+    publicationTypes: [],
+    keywords: [],
+    meshHeadings: [],
+    dates: { history: [] }
+  };
+}
+
+// src/parser.ts
+function parsePubMedXml(xml) {
+  const records = extractFragments(xml).map(parseFragment);
+  const warnings = records.flatMap((record) => record.kind === "unknown" ? [{ code: "UNKNOWN_RECORD", message: `Unknown PubMed record type: ${record.recordType}`, recordType: record.recordType }] : []);
+  return { records, warnings };
+}
+
+// src/rate-limiter.ts
+var SharedLimiter = class {
+  #intervalMs;
+  #queue = [];
+  #nextAvailable = 0;
+  #cooldownUntil = 0;
+  #timer;
+  constructor(requestsPerSecond) {
+    this.#intervalMs = 1e3 / requestsPerSecond;
+  }
+  acquire(maxQueue, signal, onEvent) {
+    if (signal?.aborted === true) return Promise.reject(new AbortedError());
+    if (this.#queue.length >= maxQueue) return Promise.reject(new QueueFullError());
+    return new Promise((resolve, reject) => {
+      const item = { enqueuedAt: Date.now(), resolve, reject, ...signal === void 0 ? {} : { signal } };
+      if (signal !== void 0) {
+        item.abortListener = () => {
+          const index = this.#queue.indexOf(item);
+          if (index < 0) return;
+          this.#queue.splice(index, 1);
+          reject(new AbortedError());
+          this.#schedule(onEvent);
+        };
+        signal.addEventListener("abort", item.abortListener, { once: true });
+      }
+      this.#queue.push(item);
+      this.#schedule(onEvent);
+    });
+  }
+  cooldown(delayMs, onEvent) {
+    this.#cooldownUntil = Math.max(this.#cooldownUntil, Date.now() + delayMs);
+    safeEvent(onEvent, { type: "rate-cooldown", delayMs });
+    this.#schedule(onEvent);
+  }
+  isIdle(now) {
+    return this.#queue.length === 0 && this.#timer === void 0 && this.#nextAvailable <= now && this.#cooldownUntil <= now;
+  }
+  #schedule(onEvent) {
+    if (this.#timer !== void 0) {
+      clearTimeout(this.#timer);
+      this.#timer = void 0;
+    }
+    if (this.#queue.length === 0) return;
+    const now = Date.now();
+    const at2 = Math.max(now, this.#nextAvailable, this.#cooldownUntil);
+    const delay = Math.max(0, at2 - now);
+    this.#timer = setTimeout(() => {
+      this.#timer = void 0;
+      if (Date.now() < at2) {
+        this.#schedule(onEvent);
+        return;
+      }
+      const item = this.#queue.shift();
+      if (item === void 0) return;
+      if (item.abortListener !== void 0 && item.signal !== void 0) {
+        item.signal.removeEventListener("abort", item.abortListener);
+      }
+      if (item.signal?.aborted === true) {
+        item.reject(new AbortedError());
+      } else {
+        const waited = Date.now() - item.enqueuedAt;
+        if (waited > 0) safeEvent(onEvent, { type: "queue-delay", delayMs: waited });
+        this.#nextAvailable = Math.max(Date.now(), this.#nextAvailable) + this.#intervalMs;
+        item.resolve();
+      }
+      this.#schedule(onEvent);
+    }, Math.min(delay, 2147e6));
+  }
+};
+var REGISTRY_SYMBOL = /* @__PURE__ */ Symbol.for("@everdeep/pubmed/shared-rate-limiters/v1");
+var KEYED_OVERFLOW_SYMBOL = /* @__PURE__ */ Symbol.for("@everdeep/pubmed/shared-rate-limiters/overflow/keyed/v1");
+var NO_KEY_OVERFLOW_SYMBOL = /* @__PURE__ */ Symbol.for("@everdeep/pubmed/shared-rate-limiters/overflow/no-key/v1");
+var HOST = "eutils.ncbi.nlm.nih.gov";
+var MAX_LIMITER_REGISTRY_ENTRIES = 256;
+var LIMITER_IDLE_TTL_MS = 10 * 6e4;
+function limiterRegistry() {
+  const existing = Reflect.get(globalThis, REGISTRY_SYMBOL);
+  if (existing instanceof Map) return existing;
+  const registry = /* @__PURE__ */ new Map();
+  Reflect.set(globalThis, REGISTRY_SYMBOL, registry);
+  return registry;
+}
+function canEvict(entry, now) {
+  return entry.activeAdmissions === 0 && entry.limiter.isIdle(now);
+}
+function evictOne(registry, now, protectedKey) {
+  for (const [key, entry] of registry) {
+    if (key === protectedKey || !canEvict(entry, now)) continue;
+    registry.delete(key);
+    return true;
+  }
+  return false;
+}
+function pruneRegistry(registry, now, protectedKey) {
+  for (const [key, entry] of registry) {
+    if (key !== protectedKey && now - entry.lastUsedAt >= LIMITER_IDLE_TTL_MS && canEvict(entry, now)) registry.delete(key);
+  }
+  while (registry.size > MAX_LIMITER_REGISTRY_ENTRIES && evictOne(registry, now, protectedKey)) {
+  }
+}
+function isLimiterRegistryEntry(value) {
+  if (typeof value !== "object" || value === null || !("limiter" in value) || !("activeAdmissions" in value) || !("lastUsedAt" in value)) {
+    return false;
+  }
+  const limiter = value.limiter;
+  return typeof value.activeAdmissions === "number" && typeof value.lastUsedAt === "number" && typeof limiter === "object" && limiter !== null && "acquire" in limiter && typeof limiter.acquire === "function" && "cooldown" in limiter && typeof limiter.cooldown === "function" && "isIdle" in limiter && typeof limiter.isIdle === "function";
+}
+function overflowLimiterEntry(keyed, requestsPerSecond) {
+  const symbol = keyed ? KEYED_OVERFLOW_SYMBOL : NO_KEY_OVERFLOW_SYMBOL;
+  const existing = Reflect.get(globalThis, symbol);
+  if (isLimiterRegistryEntry(existing)) return existing;
+  const created = { limiter: new SharedLimiter(requestsPerSecond), activeAdmissions: 0, lastUsedAt: Date.now() };
+  Reflect.set(globalThis, symbol, created);
+  return created;
+}
+function limiterEntry(registryKey, requestsPerSecond, keyed) {
+  const registry = limiterRegistry();
+  const now = Date.now();
+  const existing = registry.get(registryKey);
+  if (existing !== void 0 && now - existing.lastUsedAt < LIMITER_IDLE_TTL_MS) {
+    existing.lastUsedAt = now;
+    registry.delete(registryKey);
+    registry.set(registryKey, existing);
+    pruneRegistry(registry, now, registryKey);
+    return { entry: existing, overflow: false };
+  }
+  if (existing !== void 0 && canEvict(existing, now)) registry.delete(registryKey);
+  const current = registry.get(registryKey);
+  if (current !== void 0) {
+    current.lastUsedAt = now;
+    return { entry: current, overflow: false };
+  }
+  pruneRegistry(registry, now);
+  if (registry.size >= MAX_LIMITER_REGISTRY_ENTRIES && !evictOne(registry, now)) {
+    return { entry: overflowLimiterEntry(keyed, requestsPerSecond), overflow: true };
+  }
+  const created = { limiter: new SharedLimiter(requestsPerSecond), activeAdmissions: 0, lastUsedAt: now };
+  registry.set(registryKey, created);
+  return { entry: created, overflow: false };
+}
+async function waitWithAbort(promise, signal) {
+  if (signal === void 0) {
+    await promise;
+    return;
+  }
+  if (signal.aborted) throw new AbortedError();
+  await new Promise((resolve, reject) => {
+    let finished = false;
+    const finish = (complete) => {
+      if (finished) return;
+      finished = true;
+      signal.removeEventListener("abort", abort);
+      complete();
+    };
+    const abort = () => finish(() => reject(new AbortedError()));
+    signal.addEventListener("abort", abort, { once: true });
+    void promise.then(
+      () => finish(resolve),
+      (error) => finish(() => reject(error))
+    );
+  });
+}
+function safeEvent(handler, event) {
+  if (handler === void 0) return;
+  try {
+    handler(event);
+  } catch {
+  }
+}
+var RequestRateLimiter = class {
+  #registryKey;
+  #requestsPerSecond;
+  #keyed;
+  #bucket;
+  #maxQueue;
+  #coordinator;
+  #onEvent;
+  #overflowEntry;
+  constructor(credentialFingerprint, keyed, maxQueue, coordinator, onEvent) {
+    this.#requestsPerSecond = keyed ? 9 : 2.8;
+    this.#keyed = keyed;
+    this.#registryKey = `${HOST}:${credentialFingerprint}`;
+    const selection = limiterEntry(this.#registryKey, this.#requestsPerSecond, this.#keyed);
+    if (selection.overflow) this.#overflowEntry = selection.entry;
+    this.#bucket = { host: HOST, credentialFingerprint, requestsPerSecond: this.#requestsPerSecond };
+    this.#maxQueue = maxQueue;
+    this.#coordinator = coordinator;
+    this.#onEvent = onEvent;
+  }
+  #entry() {
+    if (this.#overflowEntry !== void 0) return this.#overflowEntry;
+    const selection = limiterEntry(this.#registryKey, this.#requestsPerSecond, this.#keyed);
+    if (selection.overflow) this.#overflowEntry = selection.entry;
+    return selection.entry;
+  }
+  async acquire(signal) {
+    const entry = this.#entry();
+    entry.activeAdmissions += 1;
+    try {
+      await entry.limiter.acquire(this.#maxQueue, signal, this.#onEvent);
+      if (this.#coordinator !== void 0) await waitWithAbort(this.#coordinator.acquire(this.#bucket, signal), signal);
+    } finally {
+      entry.activeAdmissions -= 1;
+      entry.lastUsedAt = Date.now();
+      pruneRegistry(limiterRegistry(), entry.lastUsedAt, this.#registryKey);
+    }
+  }
+  async cooldown(delayMs, signal, waitForCoordinator = true) {
+    const entry = this.#entry();
+    entry.activeAdmissions += 1;
+    try {
+      entry.limiter.cooldown(delayMs, this.#onEvent);
+      if (this.#coordinator?.cooldown !== void 0) {
+        if (waitForCoordinator) {
+          await waitWithAbort(this.#coordinator.cooldown(this.#bucket, delayMs), signal);
+        } else {
+          try {
+            void this.#coordinator.cooldown(this.#bucket, delayMs).catch(() => {
+            });
+          } catch {
+          }
+        }
+      }
+    } finally {
+      entry.activeAdmissions -= 1;
+      entry.lastUsedAt = Date.now();
+      pruneRegistry(limiterRegistry(), entry.lastUsedAt, this.#registryKey);
+    }
+  }
+};
+
+// src/summary.ts
+var PMID_PATTERN = /^[1-9][0-9]*$/;
+function object2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function scalarText(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return normalized === "" ? void 0 : normalized;
+}
+function items(value) {
+  if (value === void 0 || value === null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function stringItems(value) {
+  return items(value).flatMap((item) => scalarText(item) ?? []);
+}
+function toJsonObject(value) {
+  return value;
+}
+function authors2(value) {
+  return items(value).flatMap((item) => {
+    const author = object2(item);
+    const name = scalarText(author?.name);
+    if (name === void 0) return [];
+    const type = scalarText(author?.authtype);
+    const clusterId = scalarText(author?.clusterid);
+    return [{
+      name,
+      ...type === void 0 ? {} : { type },
+      ...clusterId === void 0 ? {} : { clusterId }
+    }];
+  });
+}
+function identifiers2(value, pmid) {
+  const found = items(value).flatMap((item) => {
+    const identifier = object2(item);
+    const type = scalarText(identifier?.idtype);
+    const identifierValue2 = scalarText(identifier?.value);
+    if (type === void 0 || identifierValue2 === void 0) return [];
+    const numericType = identifier?.idtypen;
+    return [{
+      type,
+      value: identifierValue2,
+      ...typeof numericType === "number" && Number.isSafeInteger(numericType) ? { numericType } : {}
+    }];
+  });
+  return found.some((identifier) => ["pubmed", "pmid"].includes(identifier.type.toLowerCase())) ? found : [{ type: "pubmed", value: pmid }, ...found];
+}
+function history(value) {
+  return items(value).flatMap((item) => {
+    const entry = object2(item);
+    const status = scalarText(entry?.pubstatus);
+    const date = scalarText(entry?.date);
+    return status === void 0 || date === void 0 ? [] : [{ status, date }];
+  });
+}
+function journal(record) {
+  const title = scalarText(record.fulljournalname);
+  const abbreviation = scalarText(record.source);
+  const issn = scalarText(record.issn);
+  const electronicIssn = scalarText(record.essn);
+  const volume = scalarText(record.volume);
+  const issue = scalarText(record.issue);
+  const pages = scalarText(record.pages);
+  if ((title ?? abbreviation ?? issn ?? electronicIssn ?? volume ?? issue ?? pages) === void 0) return void 0;
+  return {
+    ...title === void 0 ? {} : { title },
+    ...abbreviation === void 0 ? {} : { abbreviation },
+    ...issn === void 0 ? {} : { issn },
+    ...electronicIssn === void 0 ? {} : { electronicIssn },
+    ...volume === void 0 ? {} : { volume },
+    ...issue === void 0 ? {} : { issue },
+    ...pages === void 0 ? {} : { pages }
+  };
+}
+function book(record) {
+  const title = scalarText(record.booktitle);
+  const name = scalarText(record.bookname);
+  const chapter = scalarText(record.chapter);
+  const edition = scalarText(record.edition);
+  const publisher = scalarText(record.publishername);
+  const location = scalarText(record.publisherlocation);
+  if ((title ?? name ?? chapter ?? edition ?? publisher ?? location) === void 0) return void 0;
+  return {
+    ...title === void 0 ? {} : { title },
+    ...name === void 0 ? {} : { name },
+    ...chapter === void 0 ? {} : { chapter },
+    ...edition === void 0 ? {} : { edition },
+    ...publisher === void 0 ? {} : { publisher },
+    ...location === void 0 ? {} : { location }
+  };
+}
+function mapSummary(record, pmid) {
+  const mappedIdentifiers = identifiers2(record.articleids, pmid);
+  const findIdentifier = (...types) => mappedIdentifiers.find((identifier) => types.includes(identifier.type.toLowerCase()))?.value;
+  const title = scalarText(record.title);
+  const sortTitle = scalarText(record.sorttitle);
+  const lastAuthor = scalarText(record.lastauthor);
+  const sortFirstAuthor = scalarText(record.sortfirstauthor);
+  const publicationDate = scalarText(record.pubdate);
+  const electronicPublicationDate = scalarText(record.epubdate);
+  const sortPublicationDate = scalarText(record.sortpubdate);
+  const electronicLocationId = scalarText(record.elocationid);
+  const sourceDate = scalarText(record.srcdate);
+  const documentDate = scalarText(record.docdate);
+  const recordStatus = scalarText(record.recordstatus);
+  const publicationStatus = scalarText(record.pubstatus);
+  const documentType = scalarText(record.doctype);
+  const medium = scalarText(record.medium);
+  const edition = scalarText(record.edition);
+  const publisher = scalarText(record.publishername);
+  const publisherLocation = scalarText(record.publisherlocation);
+  const reportNumber = scalarText(record.reportnumber);
+  const availableFromUrl = scalarText(record.availablefromurl);
+  const doi = findIdentifier("doi");
+  const pmcid = findIdentifier("pmc", "pmcid");
+  const mappedJournal = journal(record);
+  const mappedBook = book(record);
+  return {
+    kind: "summary",
+    uid: pmid,
+    pmid,
+    source: toJsonObject(record),
+    authors: authors2(record.authors),
+    languages: stringItems(record.lang),
+    publicationTypes: stringItems(record.pubtype),
+    identifiers: mappedIdentifiers,
+    history: history(record.history),
+    ...title === void 0 ? {} : { title },
+    ...sortTitle === void 0 ? {} : { sortTitle },
+    ...lastAuthor === void 0 ? {} : { lastAuthor },
+    ...sortFirstAuthor === void 0 ? {} : { sortFirstAuthor },
+    ...mappedJournal === void 0 ? {} : { journal: mappedJournal },
+    ...mappedBook === void 0 ? {} : { book: mappedBook },
+    ...publicationDate === void 0 ? {} : { publicationDate },
+    ...electronicPublicationDate === void 0 ? {} : { electronicPublicationDate },
+    ...sortPublicationDate === void 0 ? {} : { sortPublicationDate },
+    ...electronicLocationId === void 0 ? {} : { electronicLocationId },
+    ...sourceDate === void 0 ? {} : { sourceDate },
+    ...documentDate === void 0 ? {} : { documentDate },
+    ...doi === void 0 ? {} : { doi },
+    ...pmcid === void 0 ? {} : { pmcid },
+    ...recordStatus === void 0 ? {} : { recordStatus },
+    ...publicationStatus === void 0 ? {} : { publicationStatus },
+    ...documentType === void 0 ? {} : { documentType },
+    ...medium === void 0 ? {} : { medium },
+    ...edition === void 0 ? {} : { edition },
+    ...publisher === void 0 ? {} : { publisher },
+    ...publisherLocation === void 0 ? {} : { publisherLocation },
+    ...reportNumber === void 0 ? {} : { reportNumber },
+    ...availableFromUrl === void 0 ? {} : { availableFromUrl }
+  };
+}
+function parseESummaryJson(body, expectedPmids) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch (error) {
+    throw new InvalidResponseError("PubMed returned invalid summary metadata", { cause: error });
+  }
+  const result = object2(object2(parsed)?.result);
+  const rawUids = result?.uids;
+  if (result === void 0 || !Array.isArray(rawUids)) {
+    throw new InvalidResponseError("PubMed returned invalid summary metadata");
+  }
+  const expected = new Set(expectedPmids);
+  const seen = /* @__PURE__ */ new Set();
+  const summaries = [];
+  for (const rawUid of rawUids) {
+    if (typeof rawUid !== "string" || !PMID_PATTERN.test(rawUid) || !expected.has(rawUid) || seen.has(rawUid)) {
+      throw new InvalidResponseError("PubMed returned summaries that did not match the requested PMIDs");
+    }
+    const record = object2(result[rawUid]);
+    if (record === void 0 || record.uid !== rawUid) {
+      throw new InvalidResponseError("PubMed returned summaries that did not match the requested PMIDs");
+    }
+    seen.add(rawUid);
+    if (scalarText(record.error) !== void 0) continue;
+    summaries.push(mapSummary(record, rawUid));
+  }
+  if (Object.keys(result).some((key) => PMID_PATTERN.test(key) && !seen.has(key))) {
+    throw new InvalidResponseError("PubMed returned summaries that did not match the requested PMIDs");
+  }
+  return summaries;
+}
+
+// src/transport.ts
+import { createHash, randomUUID } from "crypto";
+
+// src/transport/cache-lifecycle.ts
+var INVALID_CACHE_KEY_LIMIT = 1e3;
+var INVALID_CACHE_KEY_TTL_MS = 5 * 6e4;
+var PENDING_CACHE_WRITE_LIMIT = 100;
+var CACHE_MUTATION_TOKEN_LIMIT = INVALID_CACHE_KEY_LIMIT + PENDING_CACHE_WRITE_LIMIT;
+var InvalidCacheTracker = class {
+  #entries = /* @__PURE__ */ new Map();
+  #maxEntries;
+  #ttlMs;
+  constructor(maxEntries = INVALID_CACHE_KEY_LIMIT, ttlMs = INVALID_CACHE_KEY_TTL_MS) {
+    this.#maxEntries = maxEntries;
+    this.#ttlMs = ttlMs;
+  }
+  has(key) {
+    const expiresAt = this.#entries.get(key);
+    if (expiresAt === void 0) return false;
+    if (expiresAt <= Date.now()) {
+      this.#entries.delete(key);
+      return false;
+    }
+    this.#entries.delete(key);
+    this.#entries.set(key, expiresAt);
+    return true;
+  }
+  add(key) {
+    const now = Date.now();
+    for (const [cachedKey, expiresAt] of this.#entries) {
+      if (expiresAt <= now) this.#entries.delete(cachedKey);
+    }
+    this.#entries.delete(key);
+    this.#entries.set(key, now + this.#ttlMs);
+    while (this.#entries.size > this.#maxEntries) {
+      const oldest = this.#entries.keys().next();
+      if (oldest.done) break;
+      this.#entries.delete(oldest.value);
+    }
+  }
+  delete(key) {
+    this.#entries.delete(key);
+  }
+  get size() {
+    return this.#entries.size;
+  }
+};
+async function waitWithAbort2(promise, signal) {
+  if (signal === void 0) return promise;
+  if (signal.aborted) throw new AbortedError();
+  return new Promise((resolve, reject) => {
+    let finished = false;
+    const finish = (complete) => {
+      if (finished) return;
+      finished = true;
+      signal.removeEventListener("abort", abort);
+      complete();
+    };
+    const abort = () => finish(() => reject(new AbortedError()));
+    signal.addEventListener("abort", abort, { once: true });
+    void promise.then(
+      (value) => finish(() => resolve(value)),
+      (error) => finish(() => reject(error))
+    );
+  });
+}
+var CacheLifecycle = class {
+  #cache;
+  #invalidCacheKeys = new InvalidCacheTracker();
+  #pendingCacheDeletes = /* @__PURE__ */ new Map();
+  #pendingCacheWrites = /* @__PURE__ */ new Set();
+  #pendingCacheMutationsByKey = /* @__PURE__ */ new Map();
+  #latestCacheMutation = /* @__PURE__ */ new Map();
+  constructor(cache) {
+    this.#cache = cache;
+  }
+  async read(key, signal) {
+    if (this.#cache === void 0 || this.#invalidCacheKeys.has(key)) return { status: "disabled" };
+    try {
+      const value = await waitWithAbort2(this.#cache.get(key), signal);
+      return value === void 0 ? { status: "miss" } : { status: "hit", value };
+    } catch (error) {
+      if (error instanceof AbortedError) throw error;
+      return { status: "miss" };
+    }
+  }
+  async invalidate(key) {
+    this.#invalidCacheKeys.add(key);
+    if (this.#pendingCacheDeletes.has(key)) return;
+    this.#beginMutation(key);
+    if (this.#cache?.delete === void 0 || this.#pendingCacheDeletes.size >= INVALID_CACHE_KEY_LIMIT) return;
+    const pendingMutation = this.#pendingCacheMutationsByKey.get(key);
+    const deletion = this.#deleteAfterMutation(key, pendingMutation);
+    this.#pendingCacheDeletes.set(key, deletion);
+    this.#pendingCacheMutationsByKey.set(key, deletion);
+    void this.#clearPendingDelete(key, deletion);
+  }
+  write(key, body) {
+    if (this.#cache === void 0) return;
+    const token = this.#beginMutation(key);
+    if (this.#pendingCacheWrites.size >= PENDING_CACHE_WRITE_LIMIT) return;
+    const pendingMutation = this.#pendingCacheMutationsByKey.get(key);
+    const write = this.#performWrite(key, body, token, pendingMutation);
+    this.#pendingCacheWrites.add(write);
+    this.#pendingCacheMutationsByKey.set(key, write);
+    void write.then(() => {
+      this.#pendingCacheWrites.delete(write);
+      if (this.#pendingCacheMutationsByKey.get(key) === write) this.#pendingCacheMutationsByKey.delete(key);
+    });
+  }
+  #beginMutation(key) {
+    const token = {};
+    this.#latestCacheMutation.delete(key);
+    this.#latestCacheMutation.set(key, token);
+    while (this.#latestCacheMutation.size > CACHE_MUTATION_TOKEN_LIMIT) {
+      const oldest = this.#latestCacheMutation.keys().next();
+      if (oldest.done) break;
+      this.#latestCacheMutation.delete(oldest.value);
+    }
+    return token;
+  }
+  async #deleteAfterMutation(key, pendingMutation) {
+    await pendingMutation;
+    await this.#delete(key);
+  }
+  async #delete(key) {
+    try {
+      await this.#cache?.delete?.(key);
+    } catch {
+    }
+  }
+  async #clearPendingDelete(key, deletion) {
+    await deletion;
+    if (this.#pendingCacheDeletes.get(key) === deletion) this.#pendingCacheDeletes.delete(key);
+    if (this.#pendingCacheMutationsByKey.get(key) === deletion) this.#pendingCacheMutationsByKey.delete(key);
+  }
+  async #performWrite(key, body, token, pendingMutation) {
+    await pendingMutation;
+    try {
+      await this.#cache?.set(key, body);
+      if (this.#latestCacheMutation.get(key) === token) {
+        this.#latestCacheMutation.delete(key);
+        this.#invalidCacheKeys.delete(key);
+      } else {
+        await this.#delete(key);
+      }
+    } catch {
+    }
+  }
+};
+
+// src/transport/http-execution.ts
+var ORIGIN = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/";
+var MAX_RETRY_AFTER_MS = 5 * 6e4;
+var HTTP_DATE_PATTERN = /^(?:(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), \d{2} (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{4} \d{2}:\d{2}:\d{2} GMT|(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), \d{2}-(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-\d{2} \d{2}:\d{2}:\d{2} GMT|(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (?: \d|\d{2}) \d{2}:\d{2}:\d{2} \d{4})$/;
+function boundedRetryAfter(delayMs) {
+  return {
+    delayMs: Math.min(delayMs, MAX_RETRY_AFTER_MS),
+    exceedsMaximum: delayMs > MAX_RETRY_AFTER_MS
+  };
+}
+function retryAfter(headers) {
+  const raw = headers.get("retry-after")?.trim();
+  if (raw === void 0 || raw.length === 0) return void 0;
+  if (/^\d+$/.test(raw)) {
+    const seconds = Number(raw);
+    if (!Number.isFinite(seconds) || seconds > MAX_RETRY_AFTER_MS / 1e3) {
+      return { delayMs: MAX_RETRY_AFTER_MS, exceedsMaximum: true };
+    }
+    return boundedRetryAfter(seconds * 1e3);
+  }
+  if (!HTTP_DATE_PATTERN.test(raw)) return void 0;
+  const date = Date.parse(raw);
+  return Number.isFinite(date) ? boundedRetryAfter(Math.max(0, date - Date.now())) : void 0;
+}
+async function sleep(delayMs, signal) {
+  const deadline = Date.now() + delayMs;
+  while (Date.now() < deadline) {
+    const remaining = Math.min(deadline - Date.now(), 2147e6);
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        signal.removeEventListener("abort", abort);
+        resolve();
+      }, remaining);
+      const abort = () => {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", abort);
+        reject(new AbortedError());
+      };
+      signal.addEventListener("abort", abort, { once: true });
+      if (signal.aborted) abort();
+    });
+  }
+}
+function discardBody(response) {
+  if (response.body === null) return;
+  void response.body.cancel().catch(() => {
+  });
+}
+async function readCapped(response, limitBytes) {
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > limitBytes) throw new ResponseTooLargeError(limitBytes);
+  if (response.body === null) return { body: "", bytes: 0 };
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  const parts = [];
+  let total = 0;
+  try {
+    while (true) {
+      const result = await reader.read();
+      if (result.done) break;
+      total += result.value.byteLength;
+      if (total > limitBytes) {
+        await reader.cancel();
+        throw new ResponseTooLargeError(limitBytes);
+      }
+      parts.push(decoder.decode(result.value, { stream: true }));
+    }
+    parts.push(decoder.decode());
+    return { body: parts.join(""), bytes: total };
+  } finally {
+    reader.releaseLock();
+  }
+}
+var HttpExecutor = class {
+  #email;
+  #tool;
+  #apiKey;
+  #fetch;
+  #timeoutMs;
+  #maxAttempts;
+  #maxResponseBytes;
+  #limiter;
+  #onEvent;
+  constructor(options) {
+    this.#email = options.email;
+    this.#tool = options.tool;
+    this.#apiKey = options.apiKey;
+    this.#fetch = options.fetch;
+    this.#timeoutMs = options.timeoutMs;
+    this.#maxAttempts = options.maxAttempts;
+    this.#maxResponseBytes = options.maxResponseBytes;
+    this.#limiter = options.limiter;
+    this.#onEvent = options.onEvent;
+  }
+  async execute(endpoint, parameters, operationSignal, decode, correlationId) {
+    let lastError = new NetworkError();
+    for (let attempt = 1; attempt <= this.#maxAttempts; attempt += 1) {
+      if (operationSignal.aborted) throw new AbortedError();
+      await this.#limiter.acquire(operationSignal);
+      if (operationSignal.aborted) throw new AbortedError();
+      const controller = new AbortController();
+      let timedOut = false;
+      const abortAttempt = () => controller.abort();
+      operationSignal.addEventListener("abort", abortAttempt, { once: true });
+      const timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+      }, this.#timeoutMs);
+      const started = Date.now();
+      let retryDelay;
+      let retryReason = "network";
+      let stopAutomaticRetry = false;
+      try {
+        const form = new URLSearchParams({ db: "pubmed", ...parameters, tool: this.#tool, email: this.#email });
+        if (this.#apiKey !== void 0) form.set("api_key", this.#apiKey);
+        const path = `${ORIGIN}${endpoint}.fcgi`;
+        const response = await this.#fetch(path, {
+          method: "POST",
+          headers: { "content-type": "application/x-www-form-urlencoded" },
+          body: form.toString(),
+          signal: controller.signal
+        });
+        safeEvent(this.#onEvent, { type: "request", endpoint, status: response.status, durationMs: Date.now() - started, attempt, correlationId });
+        if (response.ok) {
+          const capped = await readCapped(response, this.#maxResponseBytes);
+          safeEvent(this.#onEvent, { type: "response-bytes", endpoint, correlationId, attempt, bytes: capped.bytes });
+          if (endpoint === "efetch" && /<(?:ERROR|Error)>[\s\S]*(?:history|webenv|query\s*key)/i.test(capped.body)) {
+            throw new CursorExpiredError();
+          }
+          const value = decode(capped.body);
+          if (operationSignal.aborted) throw new AbortedError();
+          return { value, body: capped.body };
+        }
+        discardBody(response);
+        if (response.status === 429) {
+          const serverDelay = retryAfter(response.headers);
+          retryDelay = serverDelay?.delayMs ?? Math.random() * 1e3 * 2 ** (attempt - 1);
+          stopAutomaticRetry = serverDelay?.exceedsMaximum ?? false;
+          await this.#limiter.cooldown(retryDelay, operationSignal, !stopAutomaticRetry);
+          lastError = new RateLimitError();
+        } else {
+          const retryable = response.status === 408 || response.status >= 500;
+          lastError = new HttpError(response.status, retryable);
+          if (retryable) retryDelay = Math.random() * 500 * 2 ** (attempt - 1);
+        }
+        retryReason = "http";
+      } catch (error) {
+        if (operationSignal.aborted) throw new AbortedError();
+        if (error instanceof ResponseTooLargeError || error instanceof CursorExpiredError) throw error;
+        if (error instanceof PubMedError && !error.retryable) throw error;
+        if (timedOut) {
+          lastError = new TimeoutError();
+          retryDelay = Math.random() * 500 * 2 ** (attempt - 1);
+          retryReason = "timeout";
+        } else if (error instanceof RateLimitError || error instanceof HttpError) {
+          lastError = error;
+          if (error.retryable) retryDelay ??= Math.random() * 500 * 2 ** (attempt - 1);
+          retryReason = "http";
+        } else if (error instanceof AbortedError) {
+          throw error;
+        } else {
+          lastError = new NetworkError();
+          retryDelay = Math.random() * 500 * 2 ** (attempt - 1);
+          retryReason = "network";
+        }
+      } finally {
+        clearTimeout(timer);
+        operationSignal.removeEventListener("abort", abortAttempt);
+      }
+      if (stopAutomaticRetry) throw new RateLimitError();
+      if (retryDelay === void 0 || attempt === this.#maxAttempts) throw lastError;
+      safeEvent(this.#onEvent, { type: "retry", endpoint, attempt, delayMs: retryDelay, reason: retryReason, correlationId });
+      await sleep(retryDelay, operationSignal);
+    }
+    throw lastError;
+  }
+};
+
+// src/transport/inflight-coalescer.ts
+var InflightCoalescer = class {
+  #requests = /* @__PURE__ */ new Map();
+  request(key, correlationId, signal, create, onCoalesced) {
+    const existing = this.#requests.get(key);
+    if (existing !== void 0) {
+      onCoalesced({ correlationId, sharedCorrelationId: existing.correlationId });
+      return this.#subscribe(key, existing, signal);
+    }
+    const controller = new AbortController();
+    const operation = {
+      controller,
+      correlationId,
+      subscribers: 0,
+      settled: false,
+      promise: create(controller.signal)
+    };
+    this.#requests.set(key, operation);
+    void operation.promise.then(
+      () => this.#settle(key, operation),
+      () => this.#settle(key, operation)
+    );
+    return this.#subscribe(key, operation, signal);
+  }
+  #settle(key, operation) {
+    operation.settled = true;
+    if (this.#requests.get(key) === operation) this.#requests.delete(key);
+  }
+  #subscribe(key, operation, signal) {
+    if (signal?.aborted === true) {
+      if (operation.subscribers === 0 && !operation.settled) {
+        if (this.#requests.get(key) === operation) this.#requests.delete(key);
+        operation.controller.abort();
+      }
+      return Promise.reject(new AbortedError());
+    }
+    operation.subscribers += 1;
+    return new Promise((resolve, reject) => {
+      let finished = false;
+      const finish = (aborted, complete) => {
+        if (finished) return;
+        finished = true;
+        signal?.removeEventListener("abort", onAbort);
+        operation.subscribers -= 1;
+        if (aborted && operation.subscribers === 0 && !operation.settled) {
+          if (this.#requests.get(key) === operation) this.#requests.delete(key);
+          operation.controller.abort();
+        }
+        complete();
+      };
+      const onAbort = () => finish(true, () => reject(new AbortedError()));
+      signal?.addEventListener("abort", onAbort, { once: true });
+      void operation.promise.then(
+        (value) => finish(false, () => resolve(value)),
+        (error) => finish(false, () => reject(error))
+      );
+    });
+  }
+};
+
+// src/transport.ts
+var encoder = new TextEncoder();
+function digest(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+var Transport = class {
+  #maxResponseBytes;
+  #onEvent;
+  #cache;
+  #inflight = new InflightCoalescer();
+  #http;
+  constructor(options) {
+    this.#maxResponseBytes = options.maxResponseBytes;
+    this.#onEvent = options.onEvent;
+    this.#cache = new CacheLifecycle(options.cache);
+    const fingerprint = options.apiKey === void 0 ? digest("no-api-key") : digest(options.apiKey);
+    const limiter = new RequestRateLimiter(
+      fingerprint,
+      options.apiKey !== void 0,
+      options.maxQueuedRequests,
+      options.rateLimitCoordinator,
+      options.onEvent
+    );
+    this.#http = new HttpExecutor({
+      email: options.email,
+      tool: options.tool,
+      fetch: options.fetch,
+      timeoutMs: options.timeoutMs,
+      maxAttempts: options.maxAttempts,
+      maxResponseBytes: options.maxResponseBytes,
+      limiter,
+      ...options.apiKey === void 0 ? {} : { apiKey: options.apiKey },
+      ...options.onEvent === void 0 ? {} : { onEvent: options.onEvent }
+    });
+  }
+  async request(endpoint, parameters, decode, options = {}) {
+    const correlationId = randomUUID();
+    safeEvent(this.#onEvent, { type: "correlation-id", endpoint, correlationId });
+    try {
+      return await this.#coordinate(endpoint, parameters, decode, options, correlationId);
+    } catch (error) {
+      safeEvent(this.#onEvent, {
+        type: "terminal-failure",
+        endpoint,
+        correlationId,
+        errorCode: error instanceof PubMedError ? error.code : "UNKNOWN_ERROR"
+      });
+      throw error;
+    }
+  }
+  async #coordinate(endpoint, parameters, decode, options, correlationId) {
+    const { signal } = options;
+    const useCache = options.cache ?? true;
+    if (signal?.aborted === true) throw new AbortedError();
+    const semantic = new URLSearchParams(parameters);
+    semantic.sort();
+    const key = digest(`${endpoint}
+${semantic.toString()}`);
+    const inflightKey = `${key}:${digest(decode.key)}`;
+    if (useCache) {
+      const cached = await this.#cache.read(key, signal);
+      if (cached.status === "hit") {
+        safeEvent(this.#onEvent, { type: "cache-hit", endpoint, correlationId });
+        if (encoder.encode(cached.value).byteLength > this.#maxResponseBytes) {
+          await this.#cache.invalidate(key);
+        } else {
+          try {
+            return decode.decode(cached.value);
+          } catch (error) {
+            if (error instanceof ResponseTooLargeError || error instanceof AbortedError) throw error;
+            await this.#cache.invalidate(key);
+          }
+        }
+      } else if (cached.status === "miss") {
+        safeEvent(this.#onEvent, { type: "cache-miss", endpoint, correlationId });
+      }
+    }
+    return this.#inflight.request(
+      inflightKey,
+      correlationId,
+      signal,
+      async (operationSignal) => {
+        const result = await this.#http.execute(endpoint, parameters, operationSignal, decode.decode, correlationId);
+        if (operationSignal.aborted) throw new AbortedError();
+        if (useCache) this.#cache.write(key, result.body);
+        if (operationSignal.aborted) throw new AbortedError();
+        return result.value;
+      },
+      ({ correlationId: joinedCorrelationId, sharedCorrelationId }) => {
+        safeEvent(this.#onEvent, {
+          type: "request-coalesced",
+          endpoint,
+          correlationId: joinedCorrelationId,
+          sharedCorrelationId
+        });
+      }
+    );
+  }
+};
+
+// src/client.ts
+var DEFAULT_PAGE_SIZE = 20;
+var MAX_BATCH_SIZE = 200;
+var SEARCH_WINDOW = 1e4;
+var CURSOR_TTL_MS = 8 * 60 * 6e4;
+var CURSOR_FUTURE_SKEW_MS = 5 * 6e4;
+var linkParser = new XMLParser2({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@",
+  textNodeName: "#text",
+  parseTagValue: false,
+  parseAttributeValue: false,
+  processEntities: false,
+  trimValues: true
+});
+function object3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function list2(value) {
+  if (value === void 0 || value === null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function text2(value) {
+  if (typeof value === "string" || typeof value === "number") {
+    const result = String(value).trim();
+    return result === "" ? void 0 : result;
+  }
+  const record = object3(value);
+  return record === void 0 ? void 0 : text2(record["#text"]);
+}
+function positiveInteger(value, name, maximum) {
+  if (!Number.isSafeInteger(value) || value <= 0 || maximum !== void 0 && value > maximum) {
+    throw new ValidationError(`${name} must be a positive integer${maximum === void 0 ? "" : ` no greater than ${maximum}`}`);
+  }
+  return value;
+}
+function isAbortSignal(value) {
+  const candidate = object3(value);
+  return typeof candidate?.aborted === "boolean" && typeof candidate.addEventListener === "function" && typeof candidate.removeEventListener === "function";
+}
+function validateRequestOptions(options, name) {
+  const candidate = object3(options);
+  if (candidate === void 0) throw new ValidationError(`${name} must be an object`);
+  if (candidate.includeLinkOuts !== void 0 && typeof candidate.includeLinkOuts !== "boolean") {
+    throw new ValidationError("includeLinkOuts must be a boolean");
+  }
+  if (candidate.signal !== void 0 && !isAbortSignal(candidate.signal)) {
+    throw new ValidationError("signal must be an AbortSignal");
+  }
+}
+function validateSummaryRequestOptions(options) {
+  const candidate = object3(options);
+  if (candidate === void 0) throw new ValidationError("summary request options must be an object");
+  if (candidate.includeLinkOuts !== void 0) {
+    throw new ValidationError("includeLinkOuts is not supported for summary requests");
+  }
+  if (candidate.signal !== void 0 && !isAbortSignal(candidate.signal)) {
+    throw new ValidationError("signal must be an AbortSignal");
+  }
+}
+function validateAdapterShapes(value) {
+  const options = object3(value);
+  if (options === void 0) throw new ValidationError("PubMedClient options are required");
+  if (options.cache !== void 0) {
+    const cache = object3(options.cache);
+    if (cache === void 0 || typeof cache.get !== "function" || typeof cache.set !== "function" || cache.delete !== void 0 && typeof cache.delete !== "function") {
+      throw new ValidationError("cache must provide get and set functions, and delete must be a function when provided");
+    }
+  }
+  if (options.rateLimitCoordinator !== void 0) {
+    const coordinator = object3(options.rateLimitCoordinator);
+    if (coordinator === void 0 || typeof coordinator.acquire !== "function" || coordinator.cooldown !== void 0 && typeof coordinator.cooldown !== "function") {
+      throw new ValidationError("rateLimitCoordinator must provide an acquire function, and cooldown must be a function when provided");
+    }
+  }
+  if (options.onEvent !== void 0 && typeof options.onEvent !== "function") {
+    throw new ValidationError("onEvent must be a function");
+  }
+}
+function validateQueryOptions(options) {
+  validateRequestOptions(options, "search options");
+  if (typeof options.query !== "string" || options.query.trim() === "") throw new ValidationError("query is required");
+  if (options.pageSize !== void 0) positiveInteger(options.pageSize, "pageSize", MAX_BATCH_SIZE);
+  if (options.sort !== void 0 && (typeof options.sort !== "string" || options.sort.trim() === "")) {
+    throw new ValidationError("sort must be a non-empty string");
+  }
+}
+function validatePmid(pmid) {
+  if (typeof pmid !== "string" || !/^[1-9][0-9]*$/.test(pmid)) throw new ValidationError("PMIDs must contain only digits and may not begin with zero");
+  return pmid;
+}
+function encodeCursor(cursor) {
+  return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
+}
+function decodeCursor(value) {
+  try {
+    const parsed = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+    const data = object3(parsed);
+    if (data?.v !== 1 || typeof data.webEnv !== "string" || data.webEnv === "" || typeof data.queryKey !== "string" || data.queryKey === "" || typeof data.total !== "number" || !Number.isSafeInteger(data.total) || data.total < 1 || typeof data.offset !== "number" || !Number.isSafeInteger(data.offset) || data.offset < 0 || data.offset >= data.total || typeof data.pageSize !== "number" || !Number.isSafeInteger(data.pageSize) || data.pageSize < 1 || data.pageSize > MAX_BATCH_SIZE || typeof data.issuedAt !== "number" || !Number.isSafeInteger(data.issuedAt) || data.issuedAt < 0 || data.issuedAt > Date.now() + CURSOR_FUTURE_SKEW_MS) throw new CursorInvalidError();
+    if (Date.now() - data.issuedAt > CURSOR_TTL_MS) throw new CursorExpiredError();
+    return {
+      v: 1,
+      webEnv: data.webEnv,
+      queryKey: data.queryKey,
+      total: data.total,
+      offset: data.offset,
+      pageSize: data.pageSize,
+      issuedAt: data.issuedAt
+    };
+  } catch (error) {
+    if (error instanceof CursorExpiredError || error instanceof CursorInvalidError) throw error;
+    throw new CursorInvalidError();
+  }
+}
+function stringLeaves(value) {
+  const found = [];
+  const pending = [value];
+  let visited = 0;
+  while (pending.length > 0 && found.length < 100 && visited < 1e3) {
+    const current = pending.pop();
+    visited += 1;
+    if (typeof current === "string") {
+      const normalized = current.trim();
+      if (normalized !== "") found.push(normalized);
+      continue;
+    }
+    if (Array.isArray(current)) {
+      for (const item of current) {
+        if (pending.length >= 1e3) break;
+        pending.push(item);
+      }
+      continue;
+    }
+    const record = object3(current);
+    if (record === void 0) continue;
+    for (const key in record) {
+      if (pending.length >= 1e3) break;
+      if (Object.prototype.hasOwnProperty.call(record, key)) pending.push(record[key]);
+    }
+  }
+  return found;
+}
+function searchErrorMessages(value) {
+  const root = object3(value);
+  const result = object3(root?.esearchresult);
+  return [root?.error, root?.ERROR, root?.errorlist, result?.error, result?.ERROR, result?.errorlist].flatMap(stringLeaves);
+}
+function isExpiredHistoryMessage(message) {
+  const historyReference = /(?:history|webenv|query(?:[\s_-]*key|\s*#))/i;
+  const unavailableReference = /(?:expired|invalid|unknown|missing|not\s+found|not\s+available|does\s+not\s+exist|cannot\s+find|could\s+not\s+find|unable\s+to\s+(?:find|obtain))/i;
+  return historyReference.test(message) && unavailableReference.test(message);
+}
+function parseSearchResponse(body, cursorContext = false) {
+  let value;
+  try {
+    value = JSON.parse(body);
+  } catch {
+    throw new InvalidResponseError("PubMed returned invalid search metadata");
+  }
+  if (cursorContext && searchErrorMessages(value).some(isExpiredHistoryMessage)) {
+    throw new CursorExpiredError();
+  }
+  const result = object3(object3(value)?.esearchresult);
+  const countText = result?.count;
+  const queryKeyValue = result?.querykey;
+  const rawIds = result?.idlist;
+  if (typeof countText !== "string" || !/^(?:0|[1-9][0-9]*)$/.test(countText) || !Array.isArray(rawIds) || rawIds.some((id) => typeof id !== "string" || !/^[1-9][0-9]*$/.test(id)) || typeof queryKeyValue !== "string" || !/^(?:0|[1-9][0-9]*)$/.test(queryKeyValue)) {
+    throw new InvalidResponseError("PubMed returned invalid search metadata");
+  }
+  const count = Number(countText);
+  if (!Number.isSafeInteger(count)) throw new InvalidResponseError("PubMed returned invalid search metadata");
+  const webEnv = typeof result?.webenv === "string" ? result.webenv : "";
+  const queryKey = queryKeyValue;
+  const ids = rawIds;
+  if (count > 0 && (webEnv === "" || !/^[1-9][0-9]*$/.test(queryKey) || ids.length === 0)) {
+    throw new InvalidResponseError("PubMed did not return complete search history metadata");
+  }
+  return { total: count, webEnv, queryKey, ids };
+}
+function validateSearchState(state, requestedIds, expectedTotal) {
+  const expectedIds = Math.min(requestedIds, state.total);
+  if (expectedTotal !== void 0 && state.total !== expectedTotal || state.ids.length !== expectedIds || new Set(state.ids).size !== state.ids.length) {
+    throw new InvalidResponseError("PubMed returned an incomplete search ID page");
+  }
+}
+function parseExpectedFetch(body, expectedPmids) {
+  const parsed = parsePubMedXml(body);
+  const expected = new Set(expectedPmids);
+  const seen = /* @__PURE__ */ new Set();
+  for (const record of parsed.records) {
+    if (record.pmid === void 0) {
+      if (record.kind !== "unknown") {
+        throw new InvalidResponseError("PubMed returned a recognized record without a PMID");
+      }
+      if (/^error(?:list)?$/i.test(record.recordType)) {
+        throw new InvalidResponseError("PubMed returned an error response instead of requested records");
+      }
+      continue;
+    }
+    if (!expected.has(record.pmid) || seen.has(record.pmid)) {
+      throw new InvalidResponseError("PubMed returned records that did not match the requested PMIDs");
+    }
+    seen.add(record.pmid);
+  }
+  return parsed;
+}
+function safeHttpLink(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:" ? url.toString() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseLinkOutResponse(xml) {
+  let parsed;
+  try {
+    parsed = linkParser.parse(xml);
+  } catch {
+    throw new InvalidResponseError("PubMed returned invalid LinkOut metadata");
+  }
+  const root = object3(object3(parsed)?.eLinkResult) ?? object3(object3(parsed)?.ELinkResult);
+  if (root === void 0) throw new InvalidResponseError("PubMed returned invalid LinkOut metadata");
+  const result = /* @__PURE__ */ new Map();
+  const idUrlLists = [
+    ...list2(root.IdUrlList),
+    ...list2(root.LinkSet).flatMap((linkSet) => list2(object3(linkSet)?.IdUrlList))
+  ];
+  for (const idUrlList of idUrlLists) {
+    for (const idSet of list2(object3(idUrlList)?.IdUrlSet)) {
+      const id = text2(object3(idSet)?.Id);
+      if (id === void 0) continue;
+      const links = result.get(id) ?? [];
+      for (const objectUrl of list2(object3(idSet)?.ObjUrl)) {
+        const node = object3(objectUrl);
+        const rawUrl = text2(node?.Url);
+        const url = rawUrl === void 0 ? void 0 : safeHttpLink(rawUrl);
+        if (url === void 0) continue;
+        const providerNode = object3(node?.Provider);
+        const name = text2(providerNode?.Name);
+        const abbreviation = text2(providerNode?.NameAbbr);
+        const providerId = text2(providerNode?.Id);
+        links.push({
+          url,
+          type: "linkout",
+          provenance: "ncbi-linkout",
+          ...(name ?? abbreviation ?? providerId) === void 0 ? {} : {
+            provider: {
+              ...name === void 0 ? {} : { name },
+              ...abbreviation === void 0 ? {} : { abbreviation },
+              ...providerId === void 0 ? {} : { id: providerId }
+            }
+          }
+        });
+      }
+      result.set(id, links);
+    }
+  }
+  return result;
+}
+function withLinks(record, extra) {
+  if (extra.length === 0) return record;
+  return { ...record, links: [...record.links, ...extra] };
+}
+var PubMedClient = class {
+  #transport;
+  #maxBatchSize;
+  #onEvent;
+  constructor(options) {
+    if (typeof options !== "object" || options === null) throw new ValidationError("PubMedClient options are required");
+    validateAdapterShapes(options);
+    if (typeof options.email !== "string" || options.email.trim() === "") throw new ValidationError("email is required");
+    if (typeof options.tool !== "string" || options.tool.trim() === "") throw new ValidationError("tool is required");
+    if (options.apiKey !== void 0 && (typeof options.apiKey !== "string" || options.apiKey.trim() === "")) {
+      throw new ValidationError("apiKey must be a non-empty string");
+    }
+    const timeoutMs = positiveInteger(options.timeoutMs ?? 3e4, "timeoutMs");
+    const maxAttempts = positiveInteger(options.maxAttempts ?? 4, "maxAttempts");
+    const maxResponseBytes = positiveInteger(options.maxResponseBytes ?? 25 * 1024 * 1024, "maxResponseBytes");
+    const maxQueuedRequests = positiveInteger(options.maxQueuedRequests ?? 1e3, "maxQueuedRequests");
+    this.#maxBatchSize = positiveInteger(options.maxBatchSize ?? MAX_BATCH_SIZE, "maxBatchSize", MAX_BATCH_SIZE);
+    const fetchImplementation = options.fetch ?? globalThis.fetch;
+    if (typeof fetchImplementation !== "function") throw new ValidationError("A Fetch API implementation is required");
+    this.#onEvent = options.onEvent;
+    this.#transport = new Transport({
+      email: options.email.trim(),
+      tool: options.tool.trim(),
+      fetch: fetchImplementation,
+      timeoutMs,
+      maxAttempts,
+      maxResponseBytes,
+      maxQueuedRequests,
+      ...options.apiKey === void 0 ? {} : { apiKey: options.apiKey },
+      ...options.cache === void 0 ? {} : { cache: options.cache },
+      ...options.rateLimitCoordinator === void 0 ? {} : { rateLimitCoordinator: options.rateLimitCoordinator },
+      ...options.onEvent === void 0 ? {} : { onEvent: options.onEvent }
+    });
+  }
+  async get(pmid, options = {}) {
+    validatePmid(pmid);
+    const batch = await this.getMany([pmid], options);
+    return batch.records.find((record) => record.pmid === pmid) ?? null;
+  }
+  async getMany(pmids, options = {}) {
+    if (!Array.isArray(pmids)) throw new ValidationError("pmids must be an array");
+    validateRequestOptions(options, "request options");
+    if (options.signal?.aborted === true) throw new AbortedError();
+    const input = pmids.map(validatePmid);
+    const unique = [...new Set(input)];
+    const received = [];
+    const warnings = [];
+    for (let offset = 0; offset < unique.length; offset += this.#maxBatchSize) {
+      const chunk = unique.slice(offset, offset + this.#maxBatchSize);
+      const parsed = await this.#transport.request(
+        "efetch",
+        { id: chunk.join(","), retmode: "xml" },
+        { key: "efetch-records-v1", decode: (body) => parseExpectedFetch(body, chunk) },
+        options.signal === void 0 ? {} : { signal: options.signal }
+      );
+      received.push(...parsed.records);
+      warnings.push(...parsed.warnings);
+      for (const warning of parsed.warnings) {
+        safeEvent(this.#onEvent, { type: "parse-warning", code: warning.code, ...warning.recordType === void 0 ? {} : { recordType: warning.recordType } });
+      }
+    }
+    const byPmid = /* @__PURE__ */ new Map();
+    const unknown = [];
+    for (const record of received) {
+      if (record.pmid === void 0) unknown.push(record);
+      else if (!byPmid.has(record.pmid)) byPmid.set(record.pmid, record);
+    }
+    let ordered = input.flatMap((pmid) => byPmid.get(pmid) ?? []);
+    if (unknown.length > 0) ordered = [...ordered, ...unknown];
+    if (options.includeLinkOuts === true && ordered.length > 0) ordered = await this.#enrich(ordered, options.signal);
+    return {
+      records: ordered,
+      missingPmids: input.filter((pmid) => !byPmid.has(pmid)),
+      warnings
+    };
+  }
+  async getSummary(pmid, options = {}) {
+    validatePmid(pmid);
+    const batch = await this.getManySummaries([pmid], options);
+    return batch.summaries[0] ?? null;
+  }
+  async getManySummaries(pmids, options = {}) {
+    if (!Array.isArray(pmids)) throw new ValidationError("pmids must be an array");
+    validateSummaryRequestOptions(options);
+    if (options.signal?.aborted === true) throw new AbortedError();
+    const input = pmids.map(validatePmid);
+    const unique = [...new Set(input)];
+    const received = [];
+    for (let offset = 0; offset < unique.length; offset += this.#maxBatchSize) {
+      const chunk = unique.slice(offset, offset + this.#maxBatchSize);
+      const summaries = await this.#transport.request(
+        "esummary",
+        { id: chunk.join(","), retmode: "json", version: "2.0" },
+        { key: "esummary-summaries-v1", decode: (body) => parseESummaryJson(body, chunk) },
+        options.signal === void 0 ? {} : { signal: options.signal }
+      );
+      received.push(...summaries);
+    }
+    const byPmid = new Map(received.map((summary) => [summary.pmid, summary]));
+    return {
+      summaries: input.flatMap((pmid) => byPmid.get(pmid) ?? []),
+      missingPmids: input.filter((pmid) => !byPmid.has(pmid))
+    };
+  }
+  async search(options) {
+    validateRequestOptions(options, "search options");
+    if ("cursor" in options) {
+      if (typeof options.cursor !== "string" || options.cursor === "") throw new ValidationError("cursor must be a non-empty string");
+      return (await this.#searchCursorPage(options.cursor, options.includeLinkOuts === true, options.signal)).batch;
+    }
+    validateQueryOptions(options);
+    return (await this.#searchQueryPage(options)).batch;
+  }
+  async *searchAll(options) {
+    validateRequestOptions(options, "searchAll options");
+    validateQueryOptions(options);
+    if (!Number.isSafeInteger(options.maxResults) || options.maxResults < 0) throw new ValidationError("maxResults must be a non-negative integer");
+    const requestedPageSize = positiveInteger(options.pageSize ?? DEFAULT_PAGE_SIZE, "pageSize", MAX_BATCH_SIZE);
+    if (options.maxResults === 0) return;
+    const pageSize = Math.min(requestedPageSize, options.maxResults);
+    const queryOptions = {
+      query: options.query,
+      pageSize,
+      ...options.sort === void 0 ? {} : { sort: options.sort },
+      ...options.includeLinkOuts === void 0 ? {} : { includeLinkOuts: options.includeLinkOuts },
+      ...options.signal === void 0 ? {} : { signal: options.signal }
+    };
+    const state = await this.#fetchInitialSearchState(queryOptions, pageSize);
+    const target = Math.min(options.maxResults, state.total);
+    if (target > SEARCH_WINDOW) throw new SearchLimitError();
+    let page = await this.#materializeInitialSearchPage(state, queryOptions, pageSize);
+    let processed = 0;
+    while (processed < target) {
+      if (page.expectedPmids.length === 0) throw new InvalidResponseError("PubMed search paging made no progress");
+      yield page.batch;
+      processed += page.expectedPmids.length;
+      if (processed >= target) return;
+      if (page.batch.nextCursor === null) throw new InvalidResponseError("PubMed search ended before the requested result count");
+      page = await this.#searchCursorPage(
+        page.batch.nextCursor,
+        options.includeLinkOuts === true,
+        options.signal,
+        target - processed
+      );
+    }
+  }
+  async #searchQueryPage(options) {
+    validateQueryOptions(options);
+    const pageSize = positiveInteger(options.pageSize ?? DEFAULT_PAGE_SIZE, "pageSize", MAX_BATCH_SIZE);
+    const state = await this.#fetchInitialSearchState(options, pageSize);
+    return this.#materializeInitialSearchPage(state, options, pageSize);
+  }
+  async #fetchInitialSearchState(options, pageSize) {
+    return this.#transport.request(
+      "esearch",
+      {
+        term: options.query,
+        retmode: "json",
+        usehistory: "y",
+        retstart: "0",
+        retmax: String(pageSize),
+        ...options.sort === void 0 ? {} : { sort: options.sort }
+      },
+      {
+        key: "esearch-initial-v1",
+        decode: (body) => {
+          const parsed = parseSearchResponse(body);
+          validateSearchState(parsed, pageSize);
+          return parsed;
+        }
+      },
+      { cache: false, ...options.signal === void 0 ? {} : { signal: options.signal } }
+    );
+  }
+  async #materializeInitialSearchPage(state, options, pageSize) {
+    if (state.total === 0) {
+      return {
+        batch: { records: [], missingPmids: [], warnings: [], total: 0, nextCursor: null },
+        expectedPmids: []
+      };
+    }
+    const batch = await this.getMany(state.ids, {
+      ...options.includeLinkOuts === void 0 ? {} : { includeLinkOuts: options.includeLinkOuts },
+      ...options.signal === void 0 ? {} : { signal: options.signal }
+    });
+    const offset = state.ids.length;
+    return {
+      batch: {
+        ...batch,
+        total: state.total,
+        nextCursor: offset < state.total ? encodeCursor({ v: 1, webEnv: state.webEnv, queryKey: state.queryKey, total: state.total, offset, pageSize, issuedAt: Date.now() }) : null
+      },
+      expectedPmids: state.ids
+    };
+  }
+  async #searchCursorPage(cursorValue, includeLinkOuts, signal, maxExpected) {
+    const cursor = decodeCursor(cursorValue);
+    if (cursor.offset >= SEARCH_WINDOW) throw new SearchLimitError();
+    const remainingWindow = SEARCH_WINDOW - cursor.offset;
+    const requested = maxExpected === void 0 ? cursor.pageSize : Math.min(cursor.pageSize, positiveInteger(maxExpected, "maxResults"));
+    const retmax = Math.min(requested, cursor.total - cursor.offset, remainingWindow);
+    const state = await this.#transport.request(
+      "esearch",
+      {
+        term: `#${cursor.queryKey}`,
+        WebEnv: cursor.webEnv,
+        query_key: cursor.queryKey,
+        retstart: String(cursor.offset),
+        retmax: String(retmax),
+        retmode: "json",
+        usehistory: "y"
+      },
+      {
+        key: `esearch-cursor-v1:${cursor.total}`,
+        decode: (body) => {
+          const parsed = parseSearchResponse(body, true);
+          validateSearchState(parsed, retmax, cursor.total);
+          return parsed;
+        }
+      },
+      { cache: false, ...signal === void 0 ? {} : { signal } }
+    );
+    const batch = await this.getMany(state.ids, { includeLinkOuts, ...signal === void 0 ? {} : { signal } });
+    const offset = cursor.offset + state.ids.length;
+    return {
+      batch: {
+        ...batch,
+        total: cursor.total,
+        nextCursor: offset < cursor.total ? encodeCursor({ ...cursor, offset }) : null
+      },
+      expectedPmids: state.ids
+    };
+  }
+  async #enrich(records, signal) {
+    const ids = [...new Set(records.flatMap((record) => record.pmid ?? []))];
+    const links = /* @__PURE__ */ new Map();
+    for (let offset = 0; offset < ids.length; offset += this.#maxBatchSize) {
+      const chunk = ids.slice(offset, offset + this.#maxBatchSize);
+      const parsed = await this.#transport.request(
+        "elink",
+        { id: chunk.join(","), cmd: "llinks", retmode: "xml" },
+        { key: "elink-linkouts-v1", decode: parseLinkOutResponse },
+        signal === void 0 ? {} : { signal }
+      );
+      for (const [id, found] of parsed) links.set(id, [...links.get(id) ?? [], ...found]);
+    }
+    return records.map((record) => record.pmid === void 0 ? record : withLinks(record, links.get(record.pmid) ?? []));
+  }
+};
+
+// src/cache.ts
+var encoder2 = new TextEncoder();
+var MemoryCache = class {
+  #entries = /* @__PURE__ */ new Map();
+  #maxEntries;
+  #maxBytes;
+  #ttlMs;
+  #totalBytes = 0;
+  constructor(options = {}) {
+    this.#maxEntries = options.maxEntries ?? 500;
+    this.#maxBytes = options.maxBytes ?? 25 * 1024 * 1024;
+    this.#ttlMs = options.ttlMs ?? 5 * 6e4;
+    if (!Number.isSafeInteger(this.#maxEntries) || this.#maxEntries <= 0) {
+      throw new ValidationError("Memory cache maxEntries must be a positive integer");
+    }
+    if (!Number.isSafeInteger(this.#maxBytes) || this.#maxBytes <= 0) {
+      throw new ValidationError("Memory cache maxBytes must be a positive integer");
+    }
+    if (!Number.isFinite(this.#ttlMs) || this.#ttlMs < 0) {
+      throw new ValidationError("Memory cache ttlMs must be a non-negative number");
+    }
+  }
+  async get(key) {
+    const entry = this.#entries.get(key);
+    if (entry === void 0) return void 0;
+    if (entry.expiresAt <= Date.now()) {
+      this.#remove(key);
+      return void 0;
+    }
+    this.#entries.delete(key);
+    this.#entries.set(key, entry);
+    return entry.value;
+  }
+  async set(key, value) {
+    this.#remove(key);
+    const bytes = encoder2.encode(key).byteLength + encoder2.encode(value).byteLength;
+    if (bytes > this.#maxBytes) return;
+    const now = Date.now();
+    for (const [cachedKey, entry] of this.#entries) {
+      if (entry.expiresAt <= now) this.#remove(cachedKey);
+    }
+    this.#entries.set(key, { value, expiresAt: now + this.#ttlMs, bytes });
+    this.#totalBytes += bytes;
+    while (this.#entries.size > this.#maxEntries || this.#totalBytes > this.#maxBytes) {
+      const oldest = this.#entries.keys().next();
+      if (oldest.done) break;
+      this.#remove(oldest.value);
+    }
+  }
+  async delete(key) {
+    this.#remove(key);
+  }
+  clear() {
+    this.#entries.clear();
+    this.#totalBytes = 0;
+  }
+  #remove(key) {
+    const entry = this.#entries.get(key);
+    if (entry === void 0) return;
+    this.#entries.delete(key);
+    this.#totalBytes -= entry.bytes;
+  }
+  get size() {
+    return this.#entries.size;
+  }
+};
+
+// src/citation.ts
+function object4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function values(value) {
+  return Array.isArray(value) ? value : [];
+}
+function cleanText2(value) {
+  if (typeof value !== "string" && typeof value !== "number") return void 0;
+  const normalized = String(value).replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/g, " ").replace(/\s+/g, " ").trim();
+  return normalized === "" ? void 0 : normalized;
+}
+function validPmid(value) {
+  const pmid = cleanText2(value);
+  return pmid !== void 0 && /^[1-9][0-9]*$/.test(pmid) ? pmid : void 0;
+}
+function safeUrl(value) {
+  const text3 = cleanText2(value);
+  if (text3 === void 0) return void 0;
+  try {
+    const url = new URL(text3);
+    return url.protocol === "http:" || url.protocol === "https:" ? url.toString() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function yearFrom(...candidates) {
+  for (const candidate of candidates) {
+    const value = cleanText2(candidate);
+    const year = value?.match(/(?:^|\D)((?:1[5-9]|20|21)[0-9]{2})(?:\D|$)/)?.[1];
+    if (year !== void 0) return year;
+  }
+  return void 0;
+}
+function identifierValue(identifiers3, ...types) {
+  const expected = new Set(types.map((type) => type.toLowerCase()));
+  for (const item of values(identifiers3)) {
+    const identifier = object4(item);
+    const type = cleanText2(identifier?.type);
+    const value = cleanText2(identifier?.value);
+    if (type !== void 0 && value !== void 0 && expected.has(type.toLowerCase())) return value;
+  }
+  return void 0;
+}
+function recordAuthors(value) {
+  return values(value).flatMap((item) => {
+    const author = object4(item);
+    if (author?.type === "collective") {
+      const name = cleanText2(author.name);
+      return name === void 0 ? [] : [{ ris: name, bibtex: name, collective: true }];
+    }
+    const lastName = cleanText2(author?.lastName);
+    const foreName = cleanText2(author?.foreName) ?? cleanText2(author?.initials);
+    const suffix = cleanText2(author?.suffix);
+    const risStructured = [lastName, foreName, suffix].filter((part) => part !== void 0 && part !== "").join(", ");
+    const bibtexStructured = [lastName, suffix, foreName].filter((part) => part !== void 0 && part !== "").join(", ");
+    const fullName = cleanText2(author?.fullName);
+    const ris = risStructured === "" ? fullName : risStructured;
+    const bibtex = bibtexStructured === "" ? fullName : bibtexStructured;
+    return ris === void 0 || bibtex === void 0 ? [] : [{ ris, bibtex, collective: false }];
+  });
+}
+function summaryBibTexName(name) {
+  if (name.includes(",")) return name;
+  const parts = name.split(" ");
+  const suffixPattern = /^(?:Jr\.?|Sr\.?|I{2,3}|IV)$/i;
+  const possibleSuffix = parts.at(-1);
+  const suffix = possibleSuffix !== void 0 && suffixPattern.test(possibleSuffix) ? possibleSuffix : void 0;
+  const initialsIndex = suffix === void 0 ? parts.length - 1 : parts.length - 2;
+  const initials = initialsIndex > 0 ? parts[initialsIndex] : void 0;
+  const familyName = initials === void 0 ? void 0 : parts.slice(0, initialsIndex).join(" ");
+  if (familyName === void 0 || familyName === "") return name;
+  return suffix === void 0 ? `${familyName}, ${initials}` : `${familyName}, ${suffix}, ${initials}`;
+}
+function summaryAuthors(value) {
+  return values(value).flatMap((item) => {
+    const author = object4(item);
+    const name = cleanText2(author?.name);
+    if (name === void 0) return [];
+    const authorType = cleanText2(author?.type)?.toLowerCase() ?? "";
+    const collective = authorType.includes("collective");
+    return [{ ris: name, bibtex: collective ? name : summaryBibTexName(name), collective }];
+  });
+}
+function recordYear(record, journal2) {
+  const dates2 = object4(record.dates);
+  const publicationDate = object4(journal2?.pubDate);
+  const electronic = object4(dates2?.electronic);
+  const print = object4(dates2?.print);
+  const completed = object4(dates2?.completed);
+  return yearFrom(
+    publicationDate?.year,
+    publicationDate?.medlineDate,
+    electronic?.year,
+    electronic?.medlineDate,
+    print?.year,
+    print?.medlineDate,
+    completed?.year,
+    completed?.medlineDate
+  );
+}
+function canonicalRecordUrl(record, pmid) {
+  for (const item of values(record.links)) {
+    const link = object4(item);
+    if (link?.type === "pubmed" && link.provenance === "canonical") {
+      const url = safeUrl(link.url);
+      if (url !== void 0) return url;
+    }
+  }
+  return pmid === void 0 ? void 0 : `https://pubmed.ncbi.nlm.nih.gov/${pmid}/`;
+}
+function mapArticle(record) {
+  const journal2 = object4(record.journal);
+  const pmid = validPmid(record.pmid) ?? validPmid(identifierValue(record.identifiers, "pubmed", "pmid"));
+  const doi = cleanText2(record.doi) ?? identifierValue(record.identifiers, "doi");
+  const issn = cleanText2(journal2?.issn);
+  const title = cleanText2(record.title);
+  const containerTitle = cleanText2(journal2?.title);
+  const containerAbbreviation = cleanText2(journal2?.isoAbbreviation);
+  const year = recordYear(record, journal2);
+  const volume = cleanText2(journal2?.volume);
+  const issue = cleanText2(journal2?.issue);
+  const pages = cleanText2(journal2?.pagination);
+  const url = canonicalRecordUrl(record, pmid);
+  return {
+    type: "article",
+    authors: recordAuthors(record.authors),
+    serialNumbers: issn === void 0 ? [] : [issn],
+    ...pmid === void 0 ? {} : { pmid },
+    ...doi === void 0 ? {} : { doi },
+    ...title === void 0 ? {} : { title },
+    ...containerTitle === void 0 ? {} : { containerTitle },
+    ...containerAbbreviation === void 0 ? {} : { containerAbbreviation },
+    ...year === void 0 ? {} : { year },
+    ...volume === void 0 ? {} : { volume },
+    ...issue === void 0 ? {} : { issue },
+    ...pages === void 0 ? {} : { pages },
+    ...url === void 0 ? {} : { url }
+  };
+}
+function mapBook(record) {
+  const book2 = object4(record.book);
+  const pmid = validPmid(record.pmid) ?? validPmid(identifierValue(record.identifiers, "pubmed", "pmid"));
+  const doi = cleanText2(record.doi) ?? identifierValue(record.identifiers, "doi");
+  const recordTitle = cleanText2(record.title);
+  const bookTitle = cleanText2(book2?.title);
+  const type = recordTitle === void 0 ? "book" : "chapter";
+  const title = recordTitle ?? bookTitle;
+  const containerTitle = type === "chapter" ? bookTitle : void 0;
+  const serialNumbers = values(book2?.isbn).flatMap((item) => cleanText2(item) ?? []);
+  const year = recordYear(record, void 0);
+  const publisher = cleanText2(book2?.publisher);
+  const publisherLocation = cleanText2(book2?.location);
+  const edition = cleanText2(book2?.edition);
+  const url = canonicalRecordUrl(record, pmid);
+  return {
+    type,
+    authors: recordAuthors(record.authors),
+    serialNumbers,
+    ...pmid === void 0 ? {} : { pmid },
+    ...doi === void 0 ? {} : { doi },
+    ...title === void 0 ? {} : { title },
+    ...containerTitle === void 0 ? {} : { containerTitle },
+    ...year === void 0 ? {} : { year },
+    ...publisher === void 0 ? {} : { publisher },
+    ...publisherLocation === void 0 ? {} : { publisherLocation },
+    ...edition === void 0 ? {} : { edition },
+    ...url === void 0 ? {} : { url }
+  };
+}
+function mapSummary2(summary) {
+  const journal2 = object4(summary.journal);
+  const book2 = object4(summary.book);
+  const summaryTitle = cleanText2(summary.title);
+  const bookContainer = cleanText2(book2?.title) ?? cleanText2(book2?.name);
+  const type = book2 === void 0 ? "article" : summaryTitle === void 0 ? "book" : "chapter";
+  const title = type === "book" ? bookContainer : summaryTitle;
+  const pmid = validPmid(summary.pmid) ?? validPmid(summary.uid);
+  const doi = cleanText2(summary.doi) ?? identifierValue(summary.identifiers, "doi");
+  const serialNumbers = type !== "article" ? values(summary.identifiers).flatMap((item) => {
+    const identifier = object4(item);
+    return cleanText2(identifier?.type)?.toLowerCase() === "isbn" ? cleanText2(identifier?.value) ?? [] : [];
+  }) : [cleanText2(journal2?.issn), cleanText2(journal2?.electronicIssn)].filter((value) => value !== void 0);
+  const availableUrl = safeUrl(summary.availableFromUrl);
+  const canonicalUrl = pmid === void 0 ? availableUrl : `https://pubmed.ncbi.nlm.nih.gov/${pmid}/`;
+  const journalTitle = cleanText2(journal2?.title);
+  const journalAbbreviation = cleanText2(journal2?.abbreviation);
+  const containerTitle = type === "chapter" ? bookContainer : type === "article" ? journalTitle : void 0;
+  const year = yearFrom(summary.publicationDate, summary.electronicPublicationDate, summary.sortPublicationDate);
+  const volume = cleanText2(journal2?.volume);
+  const issue = cleanText2(journal2?.issue);
+  const pages = cleanText2(journal2?.pages);
+  const articleNumber = cleanText2(summary.electronicLocationId);
+  const publisher = cleanText2(book2?.publisher) ?? cleanText2(summary.publisher);
+  const publisherLocation = cleanText2(book2?.location) ?? cleanText2(summary.publisherLocation);
+  const edition = cleanText2(book2?.edition) ?? cleanText2(summary.edition);
+  return {
+    type,
+    authors: summaryAuthors(summary.authors),
+    serialNumbers,
+    ...pmid === void 0 ? {} : { pmid },
+    ...doi === void 0 ? {} : { doi },
+    ...title === void 0 ? {} : { title },
+    ...containerTitle === void 0 ? {} : { containerTitle },
+    ...type === "article" && journalAbbreviation !== void 0 ? { containerAbbreviation: journalAbbreviation } : {},
+    ...year === void 0 ? {} : { year },
+    ...volume === void 0 ? {} : { volume },
+    ...issue === void 0 ? {} : { issue },
+    ...pages === void 0 ? {} : { pages },
+    ...articleNumber === void 0 ? {} : { articleNumber },
+    ...publisher === void 0 ? {} : { publisher },
+    ...publisherLocation === void 0 ? {} : { publisherLocation },
+    ...edition === void 0 ? {} : { edition },
+    ...canonicalUrl === void 0 ? {} : { url: canonicalUrl }
+  };
+}
+function citationData(source) {
+  const record = object4(source);
+  if (record?.kind === "article") return mapArticle(record);
+  if (record?.kind === "book") return mapBook(record);
+  if (record?.kind === "summary") return mapSummary2(record);
+  throw new ValidationError("citation source must be a PubMed article, book record, or summary");
+}
+function addRis(lines, tag, value) {
+  if (value !== void 0) lines.push(`${tag}  - ${value}`);
+}
+function pageParts(pages) {
+  if (pages === void 0) return {};
+  const match = pages.match(/^(.+?)[-–—](.+)$/);
+  return match?.[1] === void 0 || match[2] === void 0 ? { start: pages } : { start: match[1].trim(), end: match[2].trim() };
+}
+function formatRis(data) {
+  const risType = data.type === "article" ? "JOUR" : data.type === "chapter" ? "CHAP" : "BOOK";
+  const lines = [`TY  - ${risType}`];
+  addRis(lines, "TI", data.title);
+  for (const author of data.authors) addRis(lines, "AU", author.ris);
+  addRis(lines, data.type === "article" ? "JF" : "T2", data.containerTitle);
+  if (data.type === "article") addRis(lines, "JA", data.containerAbbreviation);
+  addRis(lines, "PY", data.year);
+  addRis(lines, "VL", data.volume);
+  addRis(lines, "IS", data.issue);
+  const pages = pageParts(data.pages);
+  addRis(lines, "SP", pages.start);
+  addRis(lines, "EP", pages.end);
+  addRis(lines, "C7", data.articleNumber);
+  addRis(lines, "ET", data.edition);
+  addRis(lines, "PB", data.publisher);
+  addRis(lines, "CY", data.publisherLocation);
+  for (const serialNumber of data.serialNumbers) addRis(lines, "SN", serialNumber);
+  addRis(lines, "DO", data.doi);
+  addRis(lines, "AN", data.pmid === void 0 ? void 0 : `PMID:${data.pmid}`);
+  addRis(lines, "UR", data.url);
+  lines.push("ER  -");
+  return lines.join("\n");
+}
+function escapeBibTex(value) {
+  let escaped = "";
+  for (const character of value) {
+    switch (character) {
+      case "\\":
+        escaped += "\\textbackslash{}";
+        break;
+      case "{":
+        escaped += "\\{";
+        break;
+      case "}":
+        escaped += "\\}";
+        break;
+      case "#":
+      case "$":
+      case "%":
+      case "&":
+      case "_":
+        escaped += `\\${character}`;
+        break;
+      case "~":
+        escaped += "\\textasciitilde{}";
+        break;
+      case "^":
+        escaped += "\\textasciicircum{}";
+        break;
+      default:
+        escaped += character;
+    }
+  }
+  return escaped;
+}
+function bibKey(data) {
+  if (data.pmid !== void 0) return `pubmed${data.pmid}`;
+  const basis = data.doi ?? data.title ?? data.containerTitle ?? "citation";
+  const slug = basis.normalize("NFKD").replace(/[^A-Za-z0-9]+/g, "").slice(0, 48);
+  return slug === "" ? "citation" : slug;
+}
+function addBib(fields, name, value) {
+  if (value !== void 0) fields.push([name, value]);
+}
+function bibTexAuthors(authors3) {
+  if (authors3.length === 0) return void 0;
+  return authors3.map((author) => {
+    const escaped = escapeBibTex(author.bibtex);
+    return author.collective ? `{${escaped}}` : escaped;
+  }).join(" and ");
+}
+function formatBibTex(data, key = bibKey(data)) {
+  const fields = [];
+  const renderedAuthors = bibTexAuthors(data.authors);
+  if (renderedAuthors !== void 0) fields.push(["author", renderedAuthors]);
+  addBib(fields, "title", data.title);
+  addBib(fields, data.type === "article" ? "journal" : "booktitle", data.containerTitle);
+  addBib(fields, "year", data.year);
+  addBib(fields, "volume", data.volume);
+  addBib(fields, "number", data.issue);
+  addBib(fields, "pages", data.pages?.replace(/[-–—]+/g, "--"));
+  addBib(fields, "eid", data.articleNumber);
+  addBib(fields, "edition", data.edition);
+  addBib(fields, "publisher", data.publisher);
+  addBib(fields, "address", data.publisherLocation);
+  addBib(fields, data.type === "article" ? "issn" : "isbn", data.serialNumbers.length === 0 ? void 0 : data.serialNumbers.join(", "));
+  addBib(fields, "doi", data.doi);
+  addBib(fields, "pmid", data.pmid);
+  addBib(fields, "url", data.url);
+  const rendered = fields.map(([name, value]) => `  ${name} = {${name === "author" ? value : escapeBibTex(value)}}`).join(",\n");
+  const entryType = data.type === "article" ? "article" : data.type === "chapter" ? "incollection" : "book";
+  return `@${entryType}{${key},${rendered === "" ? "" : `
+${rendered}`}
+}`;
+}
+function formatCitation(source, format) {
+  const data = citationData(source);
+  if (format === "ris") return formatRis(data);
+  if (format === "bibtex") return formatBibTex(data);
+  throw new ValidationError('citation format must be "ris" or "bibtex"');
+}
+function formatCitations(sources, format) {
+  if (!Array.isArray(sources)) throw new ValidationError("citation sources must be an array");
+  if (format !== "ris" && format !== "bibtex") throw new ValidationError('citation format must be "ris" or "bibtex"');
+  const data = sources.map(citationData);
+  if (format === "ris") return data.map(formatRis).join("\n\n");
+  const keyOccurrences = /* @__PURE__ */ new Map();
+  return data.map((citation) => {
+    const baseKey = bibKey(citation);
+    const occurrence = (keyOccurrences.get(baseKey) ?? 0) + 1;
+    keyOccurrences.set(baseKey, occurrence);
+    return formatBibTex(citation, occurrence === 1 ? baseKey : `${baseKey}-${occurrence}`);
+  }).join("\n\n");
+}
+export {
+  AbortedError,
+  CursorExpiredError,
+  CursorInvalidError,
+  HttpError,
+  InvalidResponseError,
+  MemoryCache,
+  NetworkError,
+  ParseError,
+  PubMedClient,
+  PubMedError,
+  QueueFullError,
+  RateLimitError,
+  ResponseTooLargeError,
+  SearchLimitError,
+  TimeoutError,
+  ValidationError,
+  formatCitation,
+  formatCitations,
+  parsePubMedXml
+};