search_paper 0.1.2

package/dist/index.js

@@ -0,0 +1,1365 @@
+// src/client.ts
+import { GhostClient } from "ghostfetch";
+function createClient(options) {
+  return new GhostClient({
+    browser: options?.browser ?? "Chrome_131",
+    autoSolveJsChallenge: true,
+    timeout: options?.timeout ?? 15e3,
+    ...options?.proxy && { proxy: options.proxy },
+    ...options?.proxyPool && {
+      proxyPool: options.proxyPool,
+      proxyRotation: "round-robin"
+    }
+  });
+}
+
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/utils/rate-limiter.ts
+var RateLimiter = class {
+  constructor(minIntervalMs, jitterMs = 0) {
+    this.minIntervalMs = minIntervalMs;
+    this.jitterMs = jitterMs;
+  }
+  lastRequest = 0;
+  async wait() {
+    const now = Date.now();
+    const elapsed = now - this.lastRequest;
+    const interval = this.minIntervalMs + Math.random() * this.jitterMs;
+    if (elapsed < interval) {
+      await sleep(interval - elapsed);
+    }
+    this.lastRequest = Date.now();
+  }
+};
+var AdaptiveRateLimiter = class {
+  constructor(baseIntervalMs, baseJitterMs = 0, maxIntervalMs = 12e4, backoffMultiplier = 3, cooldownAfter = 2, cooldownFactor = 0.7) {
+    this.baseIntervalMs = baseIntervalMs;
+    this.baseJitterMs = baseJitterMs;
+    this.maxIntervalMs = maxIntervalMs;
+    this.backoffMultiplier = backoffMultiplier;
+    this.cooldownAfter = cooldownAfter;
+    this.cooldownFactor = cooldownFactor;
+    this.currentIntervalMs = baseIntervalMs;
+  }
+  lastRequest = 0;
+  currentIntervalMs;
+  consecutiveSuccesses = 0;
+  consecutiveBlocks = 0;
+  /** 현재 적용 중인 인터벌 (ms) */
+  get interval() {
+    return this.currentIntervalMs;
+  }
+  /** 현재 차단 상태인지 (연속 차단 2회 이상이면 true) */
+  get isBlocked() {
+    return this.consecutiveBlocks >= 2;
+  }
+  async wait() {
+    const now = Date.now();
+    const elapsed = now - this.lastRequest;
+    const jitter = Math.random() * this.baseJitterMs;
+    const interval = this.currentIntervalMs + jitter;
+    if (elapsed < interval) {
+      await sleep(interval - elapsed);
+    }
+    this.lastRequest = Date.now();
+  }
+  /** 요청 성공 시 호출 → 점진적으로 딜레이 감소 */
+  success() {
+    this.consecutiveSuccesses++;
+    this.consecutiveBlocks = 0;
+    if (this.consecutiveSuccesses >= this.cooldownAfter && this.currentIntervalMs > this.baseIntervalMs) {
+      this.currentIntervalMs = Math.max(
+        this.baseIntervalMs,
+        Math.round(this.currentIntervalMs * this.cooldownFactor)
+      );
+      this.consecutiveSuccesses = 0;
+    }
+  }
+  /** 차단 감지 시 호출 → 딜레이를 지수적으로 증가 */
+  backoff() {
+    this.consecutiveSuccesses = 0;
+    this.consecutiveBlocks++;
+    this.currentIntervalMs = Math.min(
+      this.maxIntervalMs,
+      Math.round(this.currentIntervalMs * this.backoffMultiplier)
+    );
+  }
+};
+
+// src/utils/retry.ts
+import {
+  TimeoutError,
+  NetworkError,
+  ProxyError,
+  ChallengeError
+} from "ghostfetch";
+
+// src/utils/errors.ts
+var HttpError = class extends Error {
+  constructor(status, statusText) {
+    super(`HTTP ${status}: ${statusText}`);
+    this.status = status;
+    this.statusText = statusText;
+    this.name = "HttpError";
+  }
+};
+
+// src/utils/retry.ts
+async function withRetry(fn, options) {
+  const maxRetries = options?.maxRetries ?? 3;
+  const baseDelay = options?.baseDelayMs ?? 500;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (attempt === maxRetries || !isRetryable(err)) throw err;
+      const jitter = Math.random() * baseDelay * 0.5;
+      await sleep(baseDelay * 2 ** attempt + jitter);
+    }
+  }
+  throw new Error("unreachable");
+}
+function isRetryable(err) {
+  if (err instanceof TimeoutError) return true;
+  if (err instanceof NetworkError) return true;
+  if (err instanceof ProxyError) return true;
+  if (err instanceof ChallengeError) return false;
+  if (err instanceof HttpError) {
+    return err.status === 429 || err.status === 503;
+  }
+  return false;
+}
+
+// src/sources/semantic-scholar.ts
+var BASE_URL = "https://api.semanticscholar.org/graph/v1";
+var sharedRateLimiters = {
+  withKey: new RateLimiter(200, 100),
+  withoutKey: new RateLimiter(5e3, 1500)
+};
+var PAPER_FIELDS = [
+  "paperId",
+  "externalIds",
+  "url",
+  "title",
+  "abstract",
+  "venue",
+  "year",
+  "referenceCount",
+  "citationCount",
+  "isOpenAccess",
+  "openAccessPdf",
+  "authors.name",
+  "authors.authorId",
+  "authors.affiliations",
+  "journal",
+  "publicationDate",
+  "s2FieldsOfStudy"
+].join(",");
+var NESTED_PAPER_FIELDS = [
+  "paperId",
+  "externalIds",
+  "url",
+  "title",
+  "abstract",
+  "venue",
+  "year",
+  "referenceCount",
+  "citationCount",
+  "openAccessPdf",
+  "authors",
+  "journal",
+  "publicationDate",
+  "s2FieldsOfStudy"
+].join(",");
+function toPaper(raw) {
+  const authors = raw.authors.map((a, i) => ({
+    name: a.name,
+    affiliations: a.affiliations?.length ? a.affiliations : void 0,
+    scholarId: a.authorId ?? void 0,
+    isFirstAuthor: i === 0 ? true : void 0
+  }));
+  const journal = raw.journal?.name || raw.journal?.volume ? {
+    name: raw.journal.name || void 0,
+    volume: raw.journal.volume || void 0
+  } : void 0;
+  const keywords = raw.s2FieldsOfStudy?.length ? raw.s2FieldsOfStudy.map((f) => f.category) : void 0;
+  return {
+    title: raw.title,
+    authors,
+    abstract: raw.abstract ?? void 0,
+    year: raw.year ?? void 0,
+    publicationDate: raw.publicationDate ?? void 0,
+    venue: raw.venue || raw.journal?.name || void 0,
+    doi: raw.externalIds?.DOI ?? void 0,
+    url: raw.url,
+    pdfUrl: raw.openAccessPdf?.url || void 0,
+    citationCount: raw.citationCount ?? void 0,
+    source: "semantic_scholar",
+    sourceId: raw.paperId,
+    keywords,
+    journal
+  };
+}
+var SemanticScholarSource = class {
+  name = "semantic_scholar";
+  client;
+  apiKey;
+  rateLimiter;
+  constructor(client, options) {
+    this.client = client;
+    this.apiKey = options?.semanticScholarApiKey;
+    this.rateLimiter = this.apiKey ? sharedRateLimiters.withKey : sharedRateLimiters.withoutKey;
+  }
+  async search(query, options) {
+    const limit = Math.min(options?.limit ?? 10, 100);
+    const offset = options?.offset ?? 0;
+    const params = new URLSearchParams({
+      query,
+      fields: PAPER_FIELDS,
+      offset: String(offset),
+      limit: String(limit)
+    });
+    if (options?.year) {
+      const from = options.year.from ?? "";
+      const to = options.year.to ?? "";
+      if (from || to) {
+        params.set("year", `${from}-${to}`);
+      }
+    }
+    if (options?.sort === "citations") {
+      params.set("sort", "citationCount:desc");
+    } else if (options?.sort === "date") {
+      params.set("sort", "publicationDate:desc");
+    }
+    const data = await this.fetchApi(
+      `/paper/search?${params}`
+    );
+    if (!data) {
+      return {
+        query,
+        totalResults: 0,
+        papers: [],
+        source: "semantic_scholar"
+      };
+    }
+    return {
+      query,
+      totalResults: data.total,
+      papers: data.data.map(toPaper),
+      nextPageToken: data.next != null ? String(data.next) : void 0,
+      source: "semantic_scholar"
+    };
+  }
+  async getPaper(id) {
+    const data = await this.fetchApi(
+      `/paper/${encodeURIComponent(id)}?fields=${PAPER_FIELDS}`
+    );
+    return data ? toPaper(data) : null;
+  }
+  async getPapers(ids) {
+    if (ids.length === 0) return [];
+    const data = await this.fetchApi(
+      `/paper/batch?fields=${PAPER_FIELDS}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ ids })
+      }
+    );
+    if (!data) return ids.map(() => null);
+    return data.map((raw) => raw && raw.paperId ? toPaper(raw) : null);
+  }
+  async getCitations(id, options) {
+    const limit = Math.min(options?.limit ?? 10, 100);
+    const offset = options?.offset ?? 0;
+    const params = `fields=${NESTED_PAPER_FIELDS}&offset=${offset}&limit=${limit}`;
+    const data = await this.fetchApi(
+      `/paper/${encodeURIComponent(id)}/citations?${params}`
+    );
+    if (!data) {
+      return { query: id, papers: [], source: "semantic_scholar" };
+    }
+    return {
+      query: id,
+      papers: data.data.map((d) => d.citingPaper).filter((p) => p && p.paperId).map(toPaper),
+      nextPageToken: data.next != null ? String(data.next) : void 0,
+      source: "semantic_scholar"
+    };
+  }
+  async getReferences(id, options) {
+    const limit = Math.min(options?.limit ?? 10, 100);
+    const offset = options?.offset ?? 0;
+    const params = `fields=${NESTED_PAPER_FIELDS}&offset=${offset}&limit=${limit}`;
+    const data = await this.fetchApi(
+      `/paper/${encodeURIComponent(id)}/references?${params}`
+    );
+    if (!data) {
+      return { query: id, papers: [], source: "semantic_scholar" };
+    }
+    return {
+      query: id,
+      papers: data.data.map((d) => d.citedPaper).filter((p) => p && p.paperId).map(toPaper),
+      nextPageToken: data.next != null ? String(data.next) : void 0,
+      source: "semantic_scholar"
+    };
+  }
+  async fetchApi(path, init) {
+    const headers = { ...init?.headers };
+    if (this.apiKey) {
+      headers["x-api-key"] = this.apiKey;
+    }
+    return withRetry(async () => {
+      await this.rateLimiter.wait();
+      const res = await this.client.fetch(`${BASE_URL}${path}`, {
+        method: init?.method,
+        headers,
+        body: init?.body
+      });
+      if (!res.ok) {
+        if (res.status === 404) return null;
+        throw new HttpError(res.status, res.statusText);
+      }
+      return res.json();
+    }, { maxRetries: 5, baseDelayMs: 5e3 });
+  }
+};
+
+// src/parsers/scholar-html.ts
+import * as cheerio from "cheerio";
+function detectCaptcha($) {
+  return $("#gs_captcha_ccl").length > 0 || $("#recaptcha").length > 0 || $("form#captcha-form").length > 0;
+}
+function parseMetaText(text) {
+  const parts = text.split(" - ");
+  const authorsPart = parts[0] ?? "";
+  const authors = authorsPart.split(",").map((name) => name.trim()).filter((name) => name.length > 0 && name !== "\u2026").map((name) => ({ name }));
+  const venuePart = parts[1] ?? "";
+  const yearMatch = venuePart.match(/\b(19|20)\d{2}\b/);
+  const year = yearMatch ? Number(yearMatch[0]) : void 0;
+  const venue = venuePart.replace(/\b(19|20)\d{2}\b/, "").replace(/,\s*$/, "").trim() || void 0;
+  return { authors, year, venue };
+}
+function parseCitedBy(text) {
+  const match = text.match(/Cited by (\d+)/);
+  return match ? Number(match[1]) : void 0;
+}
+function parseScholarHtml(html) {
+  const $ = cheerio.load(html);
+  if (detectCaptcha($)) {
+    return { papers: [], isCaptcha: true };
+  }
+  const papers = [];
+  const items = $("div.gs_r.gs_or.gs_scl");
+  items.each((_, el) => {
+    const $el = $(el);
+    const titleEl = $el.find("h3.gs_rt a");
+    const title = titleEl.text().trim();
+    const url = titleEl.attr("href");
+    if (!title) return;
+    const metaText = $el.find("div.gs_a").text();
+    const meta = parseMetaText(metaText);
+    const abstract = $el.find("div.gs_rs").text().trim() || void 0;
+    const citedByText = $el.find("div.gs_fl a").filter((_2, a) => $(a).text().startsWith("Cited by")).first().text();
+    const citationCount = parseCitedBy(citedByText);
+    const pdfUrl = $el.find("div.gs_or_ggsm a").attr("href") || void 0;
+    papers.push({
+      title,
+      authors: meta.authors,
+      abstract,
+      year: meta.year,
+      venue: meta.venue,
+      url: url || "",
+      pdfUrl,
+      citationCount,
+      source: "google_scholar"
+    });
+  });
+  return { papers, isCaptcha: false };
+}
+
+// src/sources/google-scholar.ts
+var sharedRateLimiter = new AdaptiveRateLimiter(
+  2e3,
+  // baseInterval: 2초
+  3e3,
+  // jitter: 3초
+  12e4,
+  // max: 2분
+  3,
+  // CAPTCHA 시 3배 증가
+  2,
+  // 연속 2회 성공 시 감소
+  0.7
+  // 30%씩 감소
+);
+var MAX_CAPTCHA_RETRIES = 1;
+var GoogleScholarSource = class {
+  name = "google_scholar";
+  client;
+  rateLimiter;
+  constructor(client, rateLimiter) {
+    this.client = client;
+    this.rateLimiter = rateLimiter ?? sharedRateLimiter;
+  }
+  async search(query, options) {
+    const limit = Math.min(options?.limit ?? 10, 20);
+    const offset = options?.offset ?? 0;
+    const params = new URLSearchParams({
+      q: query,
+      start: String(offset),
+      num: String(limit),
+      hl: "en"
+    });
+    if (options?.year?.from) {
+      params.set("as_ylo", String(options.year.from));
+    }
+    if (options?.year?.to) {
+      params.set("as_yhi", String(options.year.to));
+    }
+    if (options?.sort === "date") {
+      params.set("scisbd", "1");
+    }
+    const url = `https://scholar.google.com/scholar?${params}`;
+    if (this.rateLimiter.isBlocked) {
+      return {
+        query,
+        papers: [],
+        source: "google_scholar",
+        errors: [{
+          source: "google_scholar",
+          message: "Google Scholar CAPTCHA detected",
+          code: "CAPTCHA"
+        }]
+      };
+    }
+    for (let captchaRetry = 0; captchaRetry <= MAX_CAPTCHA_RETRIES; captchaRetry++) {
+      await this.rateLimiter.wait();
+      const html = await withRetry(async () => {
+        const res = await this.client.fetch(url);
+        if (!res.ok) {
+          throw new HttpError(res.status, res.statusText);
+        }
+        return res.text();
+      }, { maxRetries: 2, baseDelayMs: 5e3 });
+      const { papers, isCaptcha } = parseScholarHtml(html);
+      if (isCaptcha) {
+        this.rateLimiter.backoff();
+        console.warn(
+          `[GoogleScholar] CAPTCHA \uAC10\uC9C0 (${captchaRetry + 1}/${MAX_CAPTCHA_RETRIES + 1}), \uB2E4\uC74C \uC694\uCCAD\uAE4C\uC9C0 ~${Math.round(this.rateLimiter.interval / 1e3)}\uCD08 \uB300\uAE30`
+        );
+        if (captchaRetry === MAX_CAPTCHA_RETRIES) {
+          return {
+            query,
+            papers: [],
+            source: "google_scholar",
+            errors: [{
+              source: "google_scholar",
+              message: "Google Scholar CAPTCHA detected",
+              code: "CAPTCHA"
+            }]
+          };
+        }
+        continue;
+      }
+      this.rateLimiter.success();
+      return {
+        query,
+        papers,
+        nextPageToken: papers.length >= limit ? String(offset + limit) : void 0,
+        source: "google_scholar"
+      };
+    }
+    return { query, papers: [], source: "google_scholar" };
+  }
+  async getPaper(id) {
+    const result = await this.search(`"${id}"`, { limit: 1 });
+    return result.papers[0] ?? null;
+  }
+};
+
+// src/parsers/arxiv-xml.ts
+import { XMLParser } from "fast-xml-parser";
+var parser = new XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  isArray: (name) => ["author", "category", "link"].includes(name)
+});
+function extractArxivId(entryId) {
+  const match = entryId.match(/abs\/(.+?)(?:v\d+)?$/);
+  return match?.[1] || void 0;
+}
+function extractDoi(entry) {
+  const doi = entry["arxiv:doi"];
+  if (!doi) return void 0;
+  return typeof doi === "string" ? doi : doi["#text"] ?? void 0;
+}
+function extractJournalRef(entry) {
+  const ref = entry["arxiv:journal_ref"];
+  if (!ref) return void 0;
+  return typeof ref === "string" ? ref : ref["#text"] ?? void 0;
+}
+function entryToPaper(entry) {
+  const authors = entry.author.map((a) => ({
+    name: a.name,
+    affiliations: a["arxiv:affiliation"] ? [].concat(a["arxiv:affiliation"]).map(
+      (aff) => typeof aff === "string" ? aff : aff["#text"] ?? String(aff)
+    ) : void 0
+  }));
+  const pdfLink = entry.link.find(
+    (l) => l["@_title"] === "pdf"
+  );
+  if (authors.length > 0) authors[0].isFirstAuthor = true;
+  return {
+    title: entry.title.replace(/\s+/g, " ").trim(),
+    authors,
+    abstract: entry.summary?.replace(/\s+/g, " ").trim() || void 0,
+    year: entry.published ? new Date(entry.published).getFullYear() : void 0,
+    publicationDate: entry.published ? entry.published.split("T")[0] : void 0,
+    url: entry.id,
+    pdfUrl: pdfLink?.["@_href"] || void 0,
+    doi: extractDoi(entry),
+    venue: extractJournalRef(entry),
+    source: "arxiv",
+    sourceId: extractArxivId(entry.id),
+    tags: entry.category?.map((c) => c["@_term"])
+  };
+}
+function parseArxivResponse(xml) {
+  const parsed = parser.parse(xml);
+  const feed = parsed.feed;
+  if (!feed) {
+    return { papers: [], totalResults: 0 };
+  }
+  const entries = feed.entry;
+  if (!entries) {
+    return { papers: [], totalResults: 0 };
+  }
+  const items = Array.isArray(entries) ? entries : [entries];
+  const papers = items.filter((entry) => entry.id && entry.title).map(entryToPaper);
+  const totalResults = Number(feed["opensearch:totalResults"]) || void 0;
+  return { papers, totalResults };
+}
+
+// src/parsers/ar5iv-html.ts
+import * as cheerio2 from "cheerio";
+var EXCLUDED_HEADINGS = /* @__PURE__ */ new Set([
+  "author contributions",
+  "funding",
+  "institutional review board statement",
+  "informed consent statement",
+  "data availability statement",
+  "conflicts of interest",
+  "references",
+  "acknowledgements",
+  "acknowledgments",
+  "article metrics"
+]);
+function parseAr5ivHtml(html, arxivId) {
+  const $ = cheerio2.load(html);
+  const authors = parseAuthors($);
+  const sections = parseSections($);
+  const figures = parseFigures($, arxivId);
+  const tables = parseTables($);
+  return { authors, sections, figures, tables };
+}
+function parseAuthors($) {
+  const authors = [];
+  const correspondingNames = /* @__PURE__ */ new Set();
+  $("span.ltx_creator.ltx_role_corresponding, div.ltx_creator.ltx_role_corresponding").each((_, el) => {
+    const name = cleanText($(el).find(".ltx_personname").text());
+    if (name) correspondingNames.add(name);
+  });
+  const creatorBlocks = $("span.ltx_creator.ltx_role_author, div.ltx_creator.ltx_role_author");
+  if (creatorBlocks.length > 0) {
+    creatorBlocks.each((_, el) => {
+      const block = $(el);
+      const nameEl = block.find(".ltx_personname");
+      const contactEl = block.find(".ltx_contact.ltx_role_affiliation");
+      const hasEmail = block.find(".ltx_contact.ltx_role_email").length > 0;
+      if (nameEl.length > 0) {
+        const name = cleanText(nameEl.text());
+        const affiliations = [];
+        contactEl.each((__, affEl) => {
+          const aff = cleanText($(affEl).text());
+          if (aff) affiliations.push(aff);
+        });
+        const isCorresponding = correspondingNames.has(name) || hasEmail || void 0;
+        if (name) {
+          authors.push({
+            name,
+            affiliations: affiliations.length > 0 ? affiliations : void 0,
+            isFirstAuthor: authors.length === 0 ? true : void 0,
+            isCorresponding: isCorresponding || void 0
+          });
+        }
+      }
+    });
+  }
+  if (authors.length === 0) {
+    const authorsDiv = $("div.ltx_authors, span.ltx_authors");
+    if (authorsDiv.length > 0) {
+      const rawText = authorsDiv.first().html() || "";
+      const authorEntries = parseInlineAuthors(rawText);
+      for (let i = 0; i < authorEntries.length; i++) {
+        const entry = authorEntries[i];
+        if (entry.name) {
+          authors.push({
+            name: entry.name,
+            affiliations: entry.affiliations.length > 0 ? entry.affiliations : void 0,
+            isFirstAuthor: i === 0 ? true : void 0
+          });
+        }
+      }
+    }
+  }
+  return authors;
+}
+function parseInlineAuthors(html) {
+  const $ = cheerio2.load(`<div>${html}</div>`);
+  const results = [];
+  const text = $("div").first().text();
+  const parts = text.split(/(?:\\\s*AND\s*|(?<!\w)&(?!\w@))/);
+  for (const part of parts) {
+    const lines = part.split("\n").map((l) => l.trim()).filter(Boolean);
+    if (lines.length === 0) continue;
+    let name = lines[0].replace(/[*†‡§¶∗]+/g, "").replace(/\d+/g, "").replace(/[,;]+$/, "").trim();
+    name = name.replace(/\S+@\S+/g, "").trim();
+    if (!name || name.length < 2) continue;
+    const affiliations = [];
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line && !line.includes("@") && !/^\d+$/.test(line) && line.length > 2) {
+        affiliations.push(line.replace(/[,;]+$/, "").trim());
+      }
+    }
+    results.push({ name, affiliations });
+  }
+  return results;
+}
+function parseSections($) {
+  const sections = [];
+  const sectionMap = {
+    ltx_section: 1,
+    ltx_subsection: 2,
+    ltx_subsubsection: 3,
+    ltx_appendix: 1
+  };
+  $("section.ltx_section, section.ltx_appendix").each((_, el) => {
+    const section = $(el);
+    const className = section.attr("class") || "";
+    let level = 1;
+    for (const [cls, lvl] of Object.entries(sectionMap)) {
+      if (className.includes(cls)) {
+        level = lvl;
+        break;
+      }
+    }
+    const headingEl = section.children("h2, h3, h4, h5, h6").first();
+    if (!headingEl.length) return;
+    const heading = cleanText(headingEl.text()).replace(/^[\d.]+\s*/, "").replace(/^Appendix\s+[A-Z]\s*/, "Appendix ").trim();
+    if (!heading) return;
+    if (EXCLUDED_HEADINGS.has(heading.toLowerCase())) return;
+    if (className.includes("ltx_bibliography")) return;
+    const contentParts = [];
+    section.find(".ltx_para, .ltx_paragraph").each((__, paraEl) => {
+      const $para = $(paraEl);
+      if ($para.closest("figure").length > 0) return;
+      const paraText = cleanText($para.text());
+      if (paraText) contentParts.push(paraText);
+    });
+    const isAppendix = className.includes("ltx_appendix");
+    const displayHeading = isAppendix && !heading.startsWith("Appendix") ? `Appendix: ${heading}` : heading;
+    sections.push({
+      heading: displayHeading,
+      level,
+      content: contentParts.length > 0 ? contentParts.join("\n\n") : void 0
+    });
+  });
+  return sections;
+}
+function parseFigures($, arxivId) {
+  const figures = [];
+  const baseUrl = `https://ar5iv.labs.arxiv.org`;
+  $("figure.ltx_figure").each((_, el) => {
+    const fig = $(el);
+    const captionEl = fig.find("figcaption");
+    const tagEl = captionEl.find(".ltx_tag.ltx_tag_figure");
+    const label = cleanText(tagEl.text()).replace(/:\s*$/, "").trim();
+    if (!label) return;
+    const fullCaption = cleanText(captionEl.text());
+    const caption = fullCaption.replace(label, "").replace(/^:\s*/, "").trim();
+    const imgEl = fig.find("img").first();
+    let filePath;
+    if (imgEl.length) {
+      const src = imgEl.attr("src") || "";
+      if (src && !src.startsWith("data:")) {
+        filePath = src.startsWith("http") ? src : `${baseUrl}${src}`;
+      }
+    }
+    figures.push({
+      label,
+      caption: caption || void 0,
+      filePath: filePath || void 0
+    });
+  });
+  return figures;
+}
+function parseTables($) {
+  const tables = [];
+  $("figure.ltx_table").each((_, el) => {
+    const tableFig = $(el);
+    const captionEl = tableFig.find("figcaption");
+    const tagEl = captionEl.find(".ltx_tag.ltx_tag_table");
+    const label = cleanText(tagEl.text()).replace(/:\s*$/, "").trim();
+    if (!label) return;
+    const fullCaption = cleanText(captionEl.text());
+    const caption = fullCaption.replace(label, "").replace(/^:\s*/, "").trim();
+    const tableEl = tableFig.find("table.ltx_tabular").first();
+    const headers = [];
+    const rows = [];
+    if (tableEl.length) {
+      const allRows = tableEl.find("tr");
+      let headerParsed = false;
+      allRows.each((__, rowEl) => {
+        const row = $(rowEl);
+        const cells = [];
+        const isHeader = row.find("th").length > 0 && !headerParsed;
+        row.find("td, th").each((___, cellEl) => {
+          cells.push(cleanText($(cellEl).text()));
+        });
+        if (cells.length === 0) return;
+        if (isHeader && !headerParsed) {
+          headers.push(...cells);
+          headerParsed = true;
+        } else {
+          rows.push(cells);
+        }
+      });
+    }
+    tables.push({
+      label,
+      caption: caption || void 0,
+      headers: headers.length > 0 ? headers : void 0,
+      rows: rows.length > 0 ? rows : void 0
+    });
+  });
+  return tables;
+}
+function cleanText(text) {
+  return text.replace(/\s+/g, " ").replace(/\n+/g, " ").trim();
+}
+
+// src/sources/arxiv.ts
+var sharedRateLimiter2 = new RateLimiter(3e3, 1e3);
+function buildSearchQuery(query) {
+  if (/^(ti|au|abs|co|jr|cat|rn|id|all):/.test(query)) {
+    return query;
+  }
+  return `all:${query}`;
+}
+function normalizeArxivId(id) {
+  return id.replace(/^arxiv:/i, "");
+}
+var ArxivSource = class {
+  name = "arxiv";
+  client;
+  rateLimiter;
+  constructor(client) {
+    this.client = client;
+    this.rateLimiter = sharedRateLimiter2;
+  }
+  async search(query, options) {
+    const limit = Math.min(options?.limit ?? 10, 2e3);
+    const offset = options?.offset ?? 0;
+    const params = new URLSearchParams({
+      search_query: buildSearchQuery(query),
+      start: String(offset),
+      max_results: String(limit)
+    });
+    if (options?.sort === "date") {
+      params.set("sortBy", "submittedDate");
+      params.set("sortOrder", "descending");
+    }
+    const url = `https://export.arxiv.org/api/query?${params}`;
+    const xml = await withRetry(async () => {
+      await this.rateLimiter.wait();
+      const res = await this.client.fetch(url);
+      if (!res.ok) {
+        throw new HttpError(res.status, res.statusText);
+      }
+      return res.text();
+    }, { maxRetries: 4, baseDelayMs: 3e3 });
+    const { papers, totalResults } = parseArxivResponse(xml);
+    return {
+      query,
+      totalResults,
+      papers,
+      nextPageToken: papers.length >= limit ? String(offset + limit) : void 0,
+      source: "arxiv"
+    };
+  }
+  async getPaper(id) {
+    const arxivId = normalizeArxivId(id);
+    const url = `https://export.arxiv.org/api/query?id_list=${encodeURIComponent(arxivId)}`;
+    const xml = await withRetry(async () => {
+      await this.rateLimiter.wait();
+      const res = await this.client.fetch(url);
+      if (!res.ok) {
+        throw new HttpError(res.status, res.statusText);
+      }
+      return res.text();
+    }, { maxRetries: 4, baseDelayMs: 3e3 });
+    const { papers } = parseArxivResponse(xml);
+    return papers[0] ?? null;
+  }
+  /**
+   * arXiv 논문의 전체 내용을 가져옴 (메타데이터 + ar5iv HTML 파싱)
+   * - API에서 기본 메타데이터 조회
+   * - ar5iv HTML에서 저자(소속 포함), 섹션, 그림, 표 파싱
+   */
+  async getFullPaper(id) {
+    const arxivId = normalizeArxivId(id);
+    const paper = await this.getPaper(arxivId);
+    if (!paper) return null;
+    try {
+      const htmlUrl = `https://ar5iv.labs.arxiv.org/html/${arxivId}`;
+      const html = await withRetry(async () => {
+        await this.rateLimiter.wait();
+        const res = await this.client.fetch(htmlUrl);
+        if (!res.ok) {
+          throw new HttpError(res.status, res.statusText);
+        }
+        return res.text();
+      }, { maxRetries: 3, baseDelayMs: 3e3 });
+      const parsed = parseAr5ivHtml(html, arxivId);
+      if (parsed.authors.length > 0) {
+        const hasAffiliations = parsed.authors.some((a) => a.affiliations?.length);
+        if (hasAffiliations) {
+          paper.authors = parsed.authors;
+        }
+      }
+      if (parsed.sections.length > 0) paper.sections = parsed.sections;
+      if (parsed.figures.length > 0) paper.figures = parsed.figures;
+      if (parsed.tables.length > 0) paper.tables = parsed.tables;
+    } catch (e) {
+      console.warn(`ar5iv HTML \uD30C\uC2F1 \uC2E4\uD328 (${arxivId}): ${e.message}`);
+    }
+    return paper;
+  }
+};
+
+// src/utils/url.ts
+function normalizeUrl(url) {
+  try {
+    const parsed = new URL(url);
+    parsed.protocol = "https:";
+    parsed.hostname = parsed.hostname.replace(/^www\./, "");
+    parsed.search = "";
+    parsed.hash = "";
+    let normalized = parsed.toString();
+    normalized = normalized.replace(/\/+$/, "");
+    return normalized;
+  } catch {
+    return url;
+  }
+}
+function normalizeTitle(title) {
+  return title.toLowerCase().replace(/[^a-z0-9\s]/g, "").replace(/\s+/g, " ").trim();
+}
+
+// src/utils/dedup.ts
+function deduplicatePapers(papers) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const paper of papers) {
+    let merged = false;
+    if (paper.doi) {
+      const doiKey = `doi:${paper.doi.toLowerCase()}`;
+      if (seen.has(doiKey)) {
+        mergePaper(seen.get(doiKey), paper);
+        merged = true;
+      } else {
+        seen.set(doiKey, paper);
+        merged = true;
+      }
+    }
+    if (!merged && paper.canonicalUrl) {
+      const urlKey = `url:${normalizeUrl(paper.canonicalUrl)}`;
+      if (seen.has(urlKey)) {
+        mergePaper(seen.get(urlKey), paper);
+        merged = true;
+      } else {
+        seen.set(urlKey, paper);
+        merged = true;
+      }
+    }
+    const titleKey = `title:${normalizeTitle(paper.title)}`;
+    if (!merged) {
+      if (seen.has(titleKey)) {
+        mergePaper(seen.get(titleKey), paper);
+      } else {
+        seen.set(titleKey, paper);
+      }
+    } else {
+      if (!seen.has(titleKey)) {
+        const existingPaper = paper.doi ? seen.get(`doi:${paper.doi.toLowerCase()}`) : paper.canonicalUrl ? seen.get(`url:${normalizeUrl(paper.canonicalUrl)}`) : void 0;
+        if (existingPaper) {
+          seen.set(titleKey, existingPaper);
+        }
+      }
+    }
+  }
+  const uniqueMap = /* @__PURE__ */ new Map();
+  for (const [, paper] of seen) {
+    uniqueMap.set(paper, true);
+  }
+  return [...uniqueMap.keys()];
+}
+function mergePaper(target, source) {
+  target.abstract ??= source.abstract;
+  target.doi ??= source.doi;
+  target.pdfUrl ??= source.pdfUrl;
+  target.venue ??= source.venue;
+  target.year ??= source.year;
+  target.sourceId ??= source.sourceId;
+  target.canonicalUrl ??= source.canonicalUrl;
+  target.tags ??= source.tags;
+  target.references ??= source.references;
+  target.impactFactor ??= source.impactFactor;
+  if (source.citationCount != null) {
+    target.citationCount = Math.max(target.citationCount ?? 0, source.citationCount);
+  }
+  if (source.authors.length > target.authors.length || source.authors.some((a) => a.scholarId || a.affiliations)) {
+    if (!target.authors.some((a) => a.scholarId || a.affiliations)) {
+      target.authors = source.authors;
+    }
+  }
+}
+
+// src/utils/canonical-url.ts
+async function resolveCanonicalUrls(client, papers) {
+  const targets = papers.filter(
+    (p) => !p.canonicalUrl && p.url && p.source !== "semantic_scholar"
+  );
+  if (targets.length === 0) return;
+  const CONCURRENCY = 5;
+  for (let i = 0; i < targets.length; i += CONCURRENCY) {
+    const batch = targets.slice(i, i + CONCURRENCY);
+    await Promise.allSettled(
+      batch.map(async (paper) => {
+        try {
+          const res = await client.fetch(paper.url, {
+            method: "GET",
+            redirect: "follow",
+            timeout: 5e3
+          });
+          paper.canonicalUrl = res.url;
+          await res.text();
+        } catch {
+        }
+      })
+    );
+  }
+}
+
+// src/data/impact-factors.ts
+var impactFactors = {
+  // === 의학 ===
+  "the lancet": 98.4,
+  "lancet": 98.4,
+  "new england journal of medicine": 158.5,
+  "the new england journal of medicine": 158.5,
+  "nejm": 158.5,
+  "jama": 63.1,
+  "bmj": 93.6,
+  "nature medicine": 82.9,
+  "lancet oncology": 41.6,
+  "the lancet oncology": 41.6,
+  "lancet neurology": 46.5,
+  "lancet infectious diseases": 36.4,
+  "lancet psychiatry": 30.8,
+  "annals of internal medicine": 39.2,
+  "circulation": 35.5,
+  "european heart journal": 35.3,
+  "journal of clinical oncology": 45.3,
+  "gastroenterology": 25.7,
+  "gut": 24.5,
+  "hepatology": 14,
+  "journal of hepatology": 25.7,
+  "diabetes care": 14.8,
+  "annals of oncology": 32,
+  // === 종합 과학 ===
+  "nature": 64.8,
+  "science": 56.9,
+  "cell": 45.5,
+  "proceedings of the national academy of sciences": 11.1,
+  "pnas": 11.1,
+  "nature communications": 16.6,
+  "science advances": 13.6,
+  "scientific reports": 4.6,
+  "plos one": 3.7,
+  "plos biology": 9.8,
+  "elife": 7.7,
+  // === 생명과학 ===
+  "nature biotechnology": 46.9,
+  "nature genetics": 31.7,
+  "nature methods": 48,
+  "nature neuroscience": 25,
+  "nature cell biology": 21.3,
+  "nature immunology": 27.7,
+  "nature structural & molecular biology": 12.5,
+  "nature chemical biology": 12.9,
+  "nature microbiology": 20.5,
+  "molecular cell": 14.5,
+  "genes & development": 10.5,
+  "cell stem cell": 19.8,
+  "cell metabolism": 27.7,
+  "cell reports": 8.8,
+  "current biology": 9.2,
+  "developmental cell": 10.7,
+  "neuron": 16.2,
+  "immunity": 32.4,
+  "journal of experimental medicine": 15.3,
+  "genome research": 7,
+  "genome biology": 12.3,
+  "nucleic acids research": 14.9,
+  "bioinformatics": 5.8,
+  "molecular biology and evolution": 10.7,
+  "plant cell": 11.6,
+  // === 화학 ===
+  "chemical reviews": 62.1,
+  "nature chemistry": 23.5,
+  "journal of the american chemical society": 15,
+  "angewandte chemie international edition": 16.6,
+  "chemical society reviews": 46.2,
+  "nature catalysis": 37.8,
+  "acs nano": 15.8,
+  "nano letters": 10.8,
+  "chemistry of materials": 7.2,
+  "journal of physical chemistry letters": 5.7,
+  "analytical chemistry": 7.4,
+  // === 물리학 ===
+  "nature physics": 19.6,
+  "physical review letters": 8.6,
+  "reviews of modern physics": 54,
+  "physical review x": 12.5,
+  "physical review d": 5,
+  "physical review b": 3.7,
+  "astrophysical journal": 5.3,
+  "monthly notices of the royal astronomical society": 4.8,
+  "astronomy & astrophysics": 6.5,
+  // === 컴퓨터과학 (저널) ===
+  "ieee transactions on pattern analysis and machine intelligence": 20.8,
+  "ieee tpami": 20.8,
+  "international journal of computer vision": 11.6,
+  "ijcv": 11.6,
+  "journal of machine learning research": 6,
+  "jmlr": 6,
+  "artificial intelligence": 5.1,
+  "ieee transactions on neural networks and learning systems": 10.4,
+  "ieee transactions on image processing": 10.6,
+  "ieee transactions on information forensics and security": 6.8,
+  "ieee transactions on software engineering": 7.4,
+  "acm computing surveys": 16.6,
+  "ieee transactions on knowledge and data engineering": 8.9,
+  "ieee transactions on cybernetics": 11.8,
+  "pattern recognition": 8,
+  "information sciences": 8.1,
+  "expert systems with applications": 8.5,
+  "knowledge-based systems": 8.8,
+  "neural networks": 7.8,
+  // === 컴퓨터과학 (학회 — IF 없음, null) ===
+  "neurips": null,
+  "nips": null,
+  "icml": null,
+  "iclr": null,
+  "cvpr": null,
+  "iccv": null,
+  "eccv": null,
+  "aaai": null,
+  "ijcai": null,
+  "acl": null,
+  "emnlp": null,
+  "naacl": null,
+  "sigir": null,
+  "kdd": null,
+  "www": null,
+  "chi": null,
+  "uist": null,
+  "osdi": null,
+  "sosp": null,
+  "sigmod": null,
+  "vldb": null,
+  "icse": null,
+  "fse": null,
+  "pldi": null,
+  "popl": null,
+  "stoc": null,
+  "focs": null,
+  "isca": null,
+  "micro": null,
+  "hpca": null,
+  "asplos": null,
+  "sc": null,
+  "siggraph": null,
+  "ccs": null,
+  "sp": null,
+  "usenix security": null,
+  "ndss": null,
+  // === 공학 ===
+  "nature energy": 49.7,
+  "nature electronics": 33.7,
+  "nature materials": 37.2,
+  "advanced materials": 27.4,
+  "energy & environmental science": 32.5,
+  "joule": 38.6,
+  "advanced energy materials": 24.4,
+  "advanced functional materials": 18.5,
+  "acs energy letters": 19.3,
+  "nano energy": 16.8,
+  // === 환경/지구과학 ===
+  "nature climate change": 28.3,
+  "nature geoscience": 18.3,
+  "nature sustainability": 25.7,
+  "nature ecology & evolution": 16,
+  "global change biology": 11.6,
+  "environmental science & technology": 11.4,
+  // === 심리학/인지과학 ===
+  "nature human behaviour": 21.4,
+  "psychological bulletin": 22.4,
+  "annual review of psychology": 23.6,
+  "psychological science": 10.2,
+  "trends in cognitive sciences": 16.7,
+  // === 사회과학/경제 ===
+  "quarterly journal of economics": 11.1,
+  "american economic review": 10.5,
+  "econometrica": 6.5,
+  "journal of political economy": 9.1,
+  "review of economic studies": 7.8,
+  "journal of finance": 8.9,
+  "review of financial studies": 7.2
+};
+
+// src/utils/impact-factor.ts
+function getImpactFactor(venue) {
+  if (!venue) return void 0;
+  const normalized = venue.toLowerCase().trim();
+  if (!normalized) return void 0;
+  if (normalized in impactFactors) {
+    return impactFactors[normalized] ?? void 0;
+  }
+  let bestMatch;
+  for (const [key, value] of Object.entries(impactFactors)) {
+    if (normalized.includes(key) || key.includes(normalized)) {
+      if (!bestMatch || key.length > bestMatch.key.length) {
+        bestMatch = { key, value };
+      }
+    }
+  }
+  if (bestMatch) {
+    return bestMatch.value ?? void 0;
+  }
+  return void 0;
+}
+
+// src/search.ts
+async function searchPapers(query, options) {
+  const client = createClient(options?.client);
+  const sources = resolveSources(client, options?.sources, options?.client);
+  const limit = options?.limit ?? 10;
+  try {
+    const results = await Promise.allSettled(
+      sources.map((src) => src.search(query, { ...options, limit }))
+    );
+    const allPapers = [];
+    const errors = [];
+    results.forEach((result, index) => {
+      if (result.status === "fulfilled") {
+        allPapers.push(...result.value.papers);
+        if (result.value.errors) errors.push(...result.value.errors);
+      } else {
+        const err = toSourceError(result.reason);
+        err.source = sources[index].name;
+        errors.push(err);
+      }
+    });
+    await resolveCanonicalUrls(client, allPapers);
+    applyImpactFactors(allPapers);
+    const unique = deduplicatePapers(allPapers);
+    const sorted = sortPapers(unique, options?.sort);
+    return {
+      query,
+      totalResults: unique.length,
+      papers: sorted.slice(0, limit),
+      source: sources[0]?.name ?? "semantic_scholar",
+      errors: errors.length > 0 ? errors : void 0
+    };
+  } finally {
+    await client.destroy();
+  }
+}
+function resolveSources(client, sourceTypes, clientOptions) {
+  const types = sourceTypes ?? ["semantic_scholar", "google_scholar", "arxiv"];
+  return types.map((type) => {
+    switch (type) {
+      case "semantic_scholar":
+        return new SemanticScholarSource(client, clientOptions);
+      case "google_scholar":
+        return new GoogleScholarSource(client);
+      case "arxiv":
+        return new ArxivSource(client);
+      default:
+        throw new Error(`Unknown source type: ${type}`);
+    }
+  });
+}
+function toSourceError(err) {
+  if (err instanceof HttpError) {
+    const code = err.status === 429 ? "RATE_LIMITED" : err.status === 503 ? "TIMEOUT" : "UNKNOWN";
+    return {
+      source: "semantic_scholar",
+      message: err.message,
+      code
+    };
+  }
+  const name = err?.name ?? "";
+  if (name === "TimeoutError") {
+    return { source: "semantic_scholar", message: String(err), code: "TIMEOUT" };
+  }
+  if (name === "NetworkError" || name === "ProxyError") {
+    return { source: "semantic_scholar", message: String(err), code: "NETWORK_ERROR" };
+  }
+  if (name === "ChallengeError") {
+    return { source: "semantic_scholar", message: String(err), code: "CAPTCHA" };
+  }
+  return {
+    source: "semantic_scholar",
+    message: err instanceof Error ? err.message : String(err),
+    code: "UNKNOWN"
+  };
+}
+function applyImpactFactors(papers) {
+  for (const paper of papers) {
+    if (paper.impactFactor == null && paper.venue) {
+      paper.impactFactor = getImpactFactor(paper.venue);
+    }
+  }
+}
+function sortPapers(papers, sort) {
+  if (sort === "date") {
+    return papers.sort((a, b) => (b.year ?? 0) - (a.year ?? 0));
+  }
+  if (sort === "citations") {
+    return papers.sort((a, b) => (b.citationCount ?? 0) - (a.citationCount ?? 0));
+  }
+  return papers.sort((a, b) => {
+    const ifDiff = (b.impactFactor ?? -1) - (a.impactFactor ?? -1);
+    if (ifDiff !== 0) return ifDiff;
+    return (b.citationCount ?? 0) - (a.citationCount ?? 0);
+  });
+}
+
+// src/get-paper.ts
+async function getPaper(doi, options) {
+  const client = createClient(options?.client);
+  try {
+    const source = new SemanticScholarSource(client, options?.client);
+    return await source.getPaper(`DOI:${doi}`);
+  } finally {
+    await client.destroy();
+  }
+}
+
+// src/get-full-paper.ts
+async function getFullPaper(id, options) {
+  const client = createClient(options?.client);
+  try {
+    const s2 = new SemanticScholarSource(client, options?.client);
+    const arxiv = new ArxivSource(client);
+    const isArxivId = /^\d{4}\.\d{4,5}(v\d+)?$/.test(id) || /^arxiv:/i.test(id);
+    const arxivId = isArxivId ? id.replace(/^arxiv:/i, "") : void 0;
+    const s2Query = isArxivId ? `ARXIV:${arxivId}` : `DOI:${id}`;
+    let s2Paper = null;
+    try {
+      s2Paper = await s2.getPaper(s2Query);
+    } catch {
+    }
+    let fullPaper = null;
+    if (arxivId) {
+      try {
+        fullPaper = await arxiv.getFullPaper(arxivId);
+      } catch {
+      }
+    }
+    if (!s2Paper && !fullPaper) return null;
+    if (s2Paper && fullPaper) {
+      return mergePapers(s2Paper, fullPaper);
+    }
+    return s2Paper ?? fullPaper;
+  } finally {
+    await client.destroy();
+  }
+}
+function mergePapers(s2, arxiv) {
+  return {
+    ...s2,
+    // arXiv에서 소속 정보가 있으면 저자 정보 보강
+    authors: mergeAuthors(s2.authors, arxiv.authors),
+    // 본문 구조는 arXiv에서
+    sections: arxiv.sections ?? s2.sections,
+    figures: arxiv.figures ?? s2.figures,
+    tables: arxiv.tables ?? s2.tables,
+    // S2에 없는 필드는 arXiv에서 보완
+    abstract: s2.abstract ?? arxiv.abstract,
+    pdfUrl: s2.pdfUrl ?? arxiv.pdfUrl,
+    tags: s2.tags ?? arxiv.tags
+  };
+}
+function mergeAuthors(s2Authors, arxivAuthors) {
+  if (!arxivAuthors.length) return s2Authors;
+  if (!s2Authors.length) return arxivAuthors;
+  const hasArxivAffiliations = arxivAuthors.some((a) => a.affiliations?.length);
+  if (!hasArxivAffiliations) return s2Authors;
+  return s2Authors.map((s2a, i) => {
+    const arxivMatch = arxivAuthors[i];
+    const found = arxivMatch && namesMatch(s2a.name, arxivMatch.name) ? arxivMatch : arxivAuthors.find((a) => namesMatch(s2a.name, a.name));
+    if (found) {
+      return {
+        ...s2a,
+        affiliations: s2a.affiliations ?? found.affiliations,
+        isFirstAuthor: found.isFirstAuthor || s2a.isFirstAuthor || (i === 0 ? true : void 0),
+        isCorresponding: found.isCorresponding || s2a.isCorresponding || void 0
+      };
+    }
+    return {
+      ...s2a,
+      isFirstAuthor: s2a.isFirstAuthor || (i === 0 ? true : void 0)
+    };
+  });
+}
+function namesMatch(a, b) {
+  const normalize = (n) => n.toLowerCase().replace(/[^a-z\s]/g, "").trim();
+  const na = normalize(a);
+  const nb = normalize(b);
+  if (na === nb) return true;
+  const lastA = na.split(" ").pop() || "";
+  const lastB = nb.split(" ").pop() || "";
+  return lastA === lastB && lastA.length > 1;
+}
+export {
+  AdaptiveRateLimiter,
+  ArxivSource,
+  GoogleScholarSource,
+  HttpError,
+  RateLimiter,
+  SemanticScholarSource,
+  createClient,
+  deduplicatePapers,
+  getFullPaper,
+  getPaper,
+  searchPapers,
+  withRetry
+};