multporn-api-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1792 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/http.ts
+import { setTimeout as sleep } from "timers/promises";
+var defaultRetryPolicy = {
+  retries: 2,
+  factor: 2,
+  minDelayMs: 300,
+  maxDelayMs: 3e3,
+  retryOn: (status) => {
+    if (status == null) return true;
+    return status >= 500 && status <= 599;
+  }
+};
+var HttpError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "HttpError";
+  }
+};
+var HttpClient = class {
+  baseURL;
+  headers;
+  timeoutMs;
+  retry;
+  userAgent;
+  constructor(opts) {
+    this.baseURL = opts.baseURL.replace(/\/+$/, "");
+    this.headers = opts.headers ?? {};
+    this.timeoutMs = opts.timeoutMs ?? 15e3;
+    this.retry = { ...defaultRetryPolicy, ...opts.retry ?? {} };
+    this.userAgent = opts.userAgent ?? "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118 Safari/537.36";
+  }
+  buildURL(pathOrUrl) {
+    try {
+      return new URL(pathOrUrl).toString();
+    } catch {
+      return new URL(pathOrUrl.replace(/^\//, ""), this.baseURL + "/").toString();
+    }
+  }
+  async getHtml(pathOrUrl, attempt = 0) {
+    const url = this.buildURL(pathOrUrl);
+    const ctrl = new AbortController();
+    const id = setTimeout(() => ctrl.abort(), this.timeoutMs);
+    try {
+      const res = await fetch(url, {
+        method: "GET",
+        headers: {
+          "User-Agent": this.userAgent,
+          Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+          ...this.headers
+        },
+        signal: ctrl.signal
+      });
+      clearTimeout(id);
+      if (!res.ok) {
+        if (this.retry.retryOn(res.status) && attempt < this.retry.retries) {
+          const delay = Math.min(
+            this.retry.maxDelayMs,
+            this.retry.minDelayMs * this.retry.factor ** attempt
+          );
+          await sleep(delay);
+          return this.getHtml(pathOrUrl, attempt + 1);
+        }
+        throw new HttpError(`HTTP ${res.status}`, res.status);
+      }
+      return await res.text();
+    } catch (e) {
+      clearTimeout(id);
+      if (attempt < this.retry.retries) {
+        const delay = Math.min(
+          this.retry.maxDelayMs,
+          this.retry.minDelayMs * this.retry.factor ** attempt
+        );
+        await sleep(delay);
+        return this.getHtml(pathOrUrl, attempt + 1);
+      }
+      if (e?.name == "AbortError") throw new HttpError("Request timeout");
+      throw new HttpError(e?.message ?? "Network error");
+    }
+  }
+  async getJson(pathOrUrl, attempt = 0) {
+    const url = this.buildURL(pathOrUrl);
+    const ctrl = new AbortController();
+    const id = setTimeout(() => ctrl.abort(), this.timeoutMs);
+    try {
+      const res = await fetch(url, {
+        method: "GET",
+        headers: {
+          "User-Agent": this.userAgent,
+          Accept: "application/json,text/plain;q=0.9,*/*;q=0.8",
+          ...this.headers
+        },
+        signal: ctrl.signal
+      });
+      clearTimeout(id);
+      if (!res.ok) {
+        if (this.retry.retryOn(res.status) && attempt < this.retry.retries) {
+          const delay = Math.min(
+            this.retry.maxDelayMs,
+            this.retry.minDelayMs * this.retry.factor ** attempt
+          );
+          await sleep(delay);
+          return this.getJson(pathOrUrl, attempt + 1);
+        }
+        throw new HttpError(`HTTP ${res.status}`, res.status);
+      }
+      return await res.json();
+    } catch (e) {
+      clearTimeout(id);
+      if (attempt < this.retry.retries) {
+        const delay = Math.min(
+          this.retry.maxDelayMs,
+          this.retry.minDelayMs * this.retry.factor ** attempt
+        );
+        await sleep(delay);
+        return this.getJson(pathOrUrl, attempt + 1);
+      }
+      if (e?.name == "AbortError") throw new HttpError("Request timeout");
+      throw new HttpError(e?.message ?? "Network error");
+    }
+  }
+  async postForm(pathOrUrl, form, attempt = 0) {
+    const url = this.buildURL(pathOrUrl);
+    const ctrl = new AbortController();
+    const id = setTimeout(() => ctrl.abort(), this.timeoutMs);
+    const usp = new URLSearchParams();
+    for (const [k, v] of Object.entries(form)) {
+      if (Array.isArray(v)) {
+        for (const item of v) usp.append(k, item);
+      } else if (v != null) {
+        usp.append(k, v);
+      }
+    }
+    const body = usp.toString();
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          "User-Agent": this.userAgent,
+          "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+          "X-Requested-With": "XMLHttpRequest",
+          Accept: "application/json, text/javascript, */*; q=0.01",
+          ...this.headers
+        },
+        body,
+        signal: ctrl.signal
+      });
+      clearTimeout(id);
+      if (!res.ok) {
+        if (this.retry.retryOn(res.status) && attempt < this.retry.retries) {
+          const delay = Math.min(
+            this.retry.maxDelayMs,
+            this.retry.minDelayMs * this.retry.factor ** attempt
+          );
+          await sleep(delay);
+          return this.postForm(pathOrUrl, form, attempt + 1);
+        }
+        throw new HttpError(`HTTP ${res.status}`, res.status);
+      }
+      const ct = res.headers.get("content-type") || "";
+      if (ct.includes("application/json") || ct.includes("text/javascript")) {
+        return await res.json();
+      }
+      const text = await res.text();
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    } catch (e) {
+      clearTimeout(id);
+      if (attempt < this.retry.retries) {
+        const delay = Math.min(
+          this.retry.maxDelayMs,
+          this.retry.minDelayMs * this.retry.factor ** attempt
+        );
+        await sleep(delay);
+        return this.postForm(pathOrUrl, form, attempt + 1);
+      }
+      if (e?.name == "AbortError") throw new HttpError("Request timeout");
+      throw new HttpError(e?.message ?? "Network error");
+    }
+  }
+};
+
+// src/api/alphabet.ts
+var alphabet_exports = {};
+__export(alphabet_exports, {
+  alphabetItems: () => alphabetItems,
+  alphabetLetters: () => alphabetLetters
+});
+
+// src/parsers/alphabet.ts
+import * as cheerio2 from "cheerio";
+
+// src/utils.ts
+function toAbsolute(baseURL, href) {
+  if (!href) return void 0;
+  try {
+    return new URL(href).toString();
+  } catch {
+    if (href.startsWith("//")) {
+      const base = new URL(baseURL);
+      return `${base.protocol}${href}`;
+    }
+    return new URL(href.replace(/^\//, ""), baseURL.replace(/\/+$/, "") + "/").toString();
+  }
+}
+function uniq(arr) {
+  return Array.from(new Set(arr));
+}
+function absUrl(base, href) {
+  if (!href) return null;
+  try {
+    return new URL(href, base).toString();
+  } catch {
+    return null;
+  }
+}
+function normSpace(s) {
+  return (s ?? "").replace(/\s+/g, " ").trim();
+}
+function parseNumberLike(s) {
+  if (!s) return void 0;
+  const m = String(s).replace(/[^\d.,]/g, "").replace(",", ".");
+  const n = parseFloat(m);
+  return Number.isFinite(n) ? n : void 0;
+}
+function parseIntLike(s) {
+  if (!s) return void 0;
+  const n = parseInt(String(s).replace(/[^\d]/g, ""), 10);
+  return Number.isFinite(n) ? n : void 0;
+}
+function guessKindFromPath(path) {
+  const p = path.split("?")[0].split("#")[0];
+  if (p.includes("/hentai_manga/") || p.includes("/munga/")) return "manga";
+  if (p.includes("/comics/")) return "comics";
+  if (p.includes("/pictures/")) return "pictures";
+  if (p.includes("/humor/")) return "humor";
+  if (p.includes("/video/")) return "video";
+  if (p.includes("/games/")) return "game";
+  return "other";
+}
+function guessAlphabetSectionFromPath(path) {
+  const slug = String(path || "").trim().replace(/^\//, "").split("/")[0]?.toLowerCase();
+  const map = {
+    comics: "alphabetical_order_comics",
+    manga: "alphabetical_order_manga",
+    pictures: "alphabetical_order_pipictures",
+    porn_gifs: "alphabetical_order_gif",
+    characters: "alphabetical_order_characters",
+    category_comic: "alphabetical_order_category_comic",
+    authors_comics: "alphabetical_order_authors_comics",
+    authors_hentai: "alphabetical_order_authors_hentai",
+    pipictures: "alphabetical_order_pipictures"
+  };
+  return map[slug] || (slug ? `alphabetical_order_${slug}` : "alphabetical_order");
+}
+
+// src/parsers/pagination.ts
+import * as cheerio from "cheerio";
+function pageIndexFromParam(raw) {
+  if (!raw) return null;
+  const decoded = decodeURIComponent(String(raw));
+  const parts = decoded.split(",").map((s) => parseInt(s.trim(), 10)).filter((n) => Number.isFinite(n));
+  if (!parts.length) return null;
+  return Math.max(...parts);
+}
+function pageIndexFromHref(href) {
+  if (!href) return null;
+  try {
+    const u = new URL(href, "https://example.com");
+    return pageIndexFromParam(u.searchParams.get("page"));
+  } catch {
+    const m = href.match(/[?&]page=([^&#]+)/i);
+    return m ? pageIndexFromParam(m[1]) : null;
+  }
+}
+function extractTotalPages(html) {
+  const $ = cheerio.load(html);
+  const root = $(
+    "ul.pager, nav.pagination, .pagination, .item-list .pager, #content .pager"
+  ).first();
+  if (!root.length) return 1;
+  const lastHref = root.find('li.pager-last a[href], a[rel="last"], a[title*="Last"], a[title*="\u041F\u043E\u0441\u043B\u0435\u0434\u043D\u044F\u044F"]').attr("href") || void 0;
+  if (lastHref) {
+    const idx = pageIndexFromHref(lastHref);
+    if (idx != null) return Math.max(1, idx + 1);
+  }
+  let maxPages = 0;
+  root.find("a[href]").each((_, a) => {
+    const href = String($(a).attr("href") || "");
+    const idx = pageIndexFromHref(href);
+    if (idx != null) maxPages = Math.max(maxPages, idx + 1);
+  });
+  root.find("a, li, span").each((_, el) => {
+    const n = Number(($(el).text() || "").trim());
+    if (Number.isFinite(n)) maxPages = Math.max(maxPages, n);
+  });
+  return Math.max(1, maxPages || 1);
+}
+
+// src/parsers/alphabet.ts
+function parseAlphabetLetters(html, baseURL) {
+  const $ = cheerio2.load(html);
+  const letters = [];
+  $(".views-summary a[href]").each((_, a) => {
+    const el = $(a);
+    const raw = normSpace(el.text());
+    if (!raw) return;
+    const count = parseIntLike(raw);
+    const label = raw.replace(/\(\s*\d+\s*\)\s*$/, "").trim() || raw;
+    const hrefRel = el.attr("href") || "";
+    const href = toAbsolute(baseURL, hrefRel) || "";
+    const lastSeg = decodeURIComponent((hrefRel.split("/").filter(Boolean).pop() || "").trim());
+    if (!label || !href) return;
+    letters.push({
+      label,
+      value: lastSeg || label,
+      href,
+      count: typeof count === "number" ? count : void 0,
+      active: el.hasClass("active") || /(^|\s)active(\s|$)/.test(el.attr("class") || "")
+    });
+  });
+  const uniq3 = /* @__PURE__ */ new Map();
+  for (const l of letters) if (!uniq3.has(l.value)) uniq3.set(l.value, l);
+  return Array.from(uniq3.values());
+}
+function parseAlphabetInline(html, baseURL) {
+  const $ = cheerio2.load(html);
+  const containers = [];
+  containers.push(...$(".view-glossary-comics").toArray());
+  if (containers.length === 0) containers.push(...$(".view-glossary").toArray());
+  if (containers.length === 0) {
+    const anyNodes = $(".view").has(".views-summary a").toArray();
+    const onlyElements = anyNodes.filter((n) => n?.type === "tag");
+    containers.push(...onlyElements);
+  }
+  if (containers.length === 0) return null;
+  const grouped = /* @__PURE__ */ new Map();
+  for (const cont of containers) {
+    const $cont = $(cont);
+    $cont.find(".views-summary a[href]").each((__, a) => {
+      const el = $(a);
+      const raw = normSpace(el.text());
+      if (!raw) return;
+      const count = parseIntLike(raw);
+      const label = raw.replace(/\(\s*\d+\s*\)\s*$/, "").trim() || raw;
+      const hrefRel = el.attr("href") || "";
+      const hrefAbs = toAbsolute(baseURL, hrefRel);
+      if (!hrefAbs) return;
+      let section = "";
+      try {
+        const p = new URL(hrefAbs).pathname;
+        const m = p.match(/^\/([^/]+)/);
+        section = m ? m[1] : "";
+      } catch {
+      }
+      const value = decodeURIComponent((hrefRel.split("/").filter(Boolean).pop() || "").trim()) || label;
+      const entry = {
+        label,
+        value,
+        href: hrefAbs,
+        count: typeof count === "number" ? count : void 0,
+        active: el.hasClass("active") || /(^|\s)active(\s|$)/.test(el.attr("class") || "")
+      };
+      const arr = grouped.get(section) ?? [];
+      if (!arr.some((x) => x.value === entry.value)) arr.push(entry);
+      grouped.set(section, arr);
+    });
+  }
+  if (!grouped.size) return null;
+  let chosen = null;
+  for (const [sec, letters] of grouped.entries()) {
+    if (letters.some((l) => l.active)) {
+      chosen = { section: sec, letters };
+      break;
+    }
+  }
+  if (!chosen) {
+    let bestSec = "";
+    let bestArr = [];
+    for (const [sec, letters] of grouped.entries()) {
+      if (letters.length > bestArr.length) {
+        bestSec = sec;
+        bestArr = letters;
+      }
+    }
+    chosen = { section: bestSec, letters: bestArr };
+  }
+  if (!chosen) {
+    const [sec, letters] = grouped.entries().next().value;
+    chosen = { section: sec, letters };
+  }
+  chosen.letters.sort((a, b) => a.label.localeCompare(b.label, "en"));
+  if (!looksLikeAlphabet(chosen.letters)) return null;
+  return { section: chosen.section, letters: chosen.letters };
+}
+function looksLikeAlphabet(letters) {
+  const short = letters.filter((l) => /^[A-Z#]$/i.test(l.label.trim())).length;
+  return letters.length >= 10 && short >= 10;
+}
+function pickFromSrcset(srcset) {
+  if (!srcset) return;
+  const first = srcset.split(",")[0]?.trim();
+  if (!first) return;
+  const url = first.split(/\s+/)[0];
+  return url || void 0;
+}
+function pickFromStyle(style) {
+  if (!style) return;
+  const m = style.match(/url\((['"]?)(.*?)\1\)/i);
+  return m?.[2] || void 0;
+}
+function pickThumbUrl(scope, baseURL) {
+  const candidates = [
+    ".views-field-field-comg-preview img",
+    ".views-field-field-cat-preview img",
+    ".views-field-field-category-preview img",
+    ".views-field-field-man-preview-1 img",
+    ".views-field-field-man-preview img",
+    ".views-field-field-author-preview img",
+    ".views-field-field-authors-pre img",
+    ".views-field-field-gif-pre-1 img",
+    ".views-field-field-gif-preview img",
+    ".views-field-field-gif-pre img",
+    ".views-field-field-gif img",
+    ".views-field-field-preview img",
+    ".views-field-field-image img",
+    ".views-field-field-avatar img",
+    ".field-content a > img",
+    ".field-content img",
+    "a > img",
+    "img"
+  ];
+  for (const sel of candidates) {
+    const img = scope.find(sel).first();
+    if (img.length) {
+      const ds = img.attr("data-src") || img.attr("data-original");
+      const ss = pickFromSrcset(img.attr("srcset") || "");
+      const src = ds || ss || img.attr("src");
+      const abs = toAbsolute(baseURL, src || "");
+      if (abs) return abs;
+    }
+  }
+  const srcset = pickFromSrcset(scope.find("picture source").first().attr("srcset") || "");
+  if (srcset) {
+    const abs = toAbsolute(baseURL, srcset);
+    if (abs) return abs;
+  }
+  const bg = pickFromStyle(
+    scope.attr("style") || scope.find('[style*="background-image"]').first().attr("style")
+  );
+  if (bg) {
+    const abs = toAbsolute(baseURL, bg);
+    if (abs) return abs;
+  }
+  return void 0;
+}
+function parseAlphabetListing(html, baseURL, page) {
+  const $ = cheerio2.load(html);
+  const items = [];
+  $("table.views-view-grid td").each((_, td) => {
+    const scope = $(td);
+    const a = scope.find(
+      ".views-field-title a[href], .views-field-name a[href], strong a[href], h5 a[href], a[href]"
+    ).first();
+    const href = a.attr("href") || "";
+    const url = toAbsolute(baseURL, href);
+    const title = (a.text() || scope.find(".views-field-title .field-content").text() || scope.find(".views-field-name .field-content").text() || scope.find("strong").first().text() || scope.find("h5").first().text() || "").trim();
+    const thumb = pickThumbUrl(scope, baseURL);
+    if (url && title) items.push({ title, url, thumb });
+  });
+  if (items.length === 0) {
+    $(".view .view-content .views-row").each((_, row) => {
+      const el = $(row);
+      const a = el.find(
+        ".views-field-title a[href], .views-field-name a[href], strong a[href], h5 a[href], a[href]"
+      ).first();
+      const href = a.attr("href") || "";
+      const url = toAbsolute(baseURL, href);
+      const title = (a.text() || el.find(".views-field-title .field-content").text() || el.find(".views-field-name .field-content").text() || el.find("strong").first().text() || el.find("h5").first().text() || "").trim();
+      const thumb = pickThumbUrl(el, baseURL);
+      if (url && title) items.push({ title, url, thumb });
+    });
+  }
+  const totalPages = extractTotalPages(html);
+  const hasNext = page + 1 < totalPages;
+  return { items, page, hasNext, totalPages };
+}
+
+// src/api/alphabet.ts
+var ALPHA_CFG = {
+  comics: { hubPath: "/comic", alphaPrefix: "/alphabetical_order_comics" },
+  category_comic: { hubPath: "/category_comic", alphaPrefix: "/category_comic/alphabetical" },
+  characters: { hubPath: "/characters", alphaPrefix: "/alphabetical_order_characters" },
+  authors_comics: { hubPath: "/authors_comics", alphaPrefix: "/alphabetical_order_authors" },
+  pipictures: { hubPath: "/pipictures", alphaPrefix: "/alphabetical_order_pictures" },
+  porn_gifs: { hubPath: "/porn_gifs", alphaPrefix: "/alphabetical_order_gif" },
+  manga: { hubPath: "/munga", alphaPrefix: "/alphabetical_order_manga" },
+  authors_hentai: { hubPath: "/authors_hentai", alphaPrefix: "/authors_hentai/alphabetical" }
+};
+async function alphabetLetters(http, baseURL, section) {
+  const cfg = ALPHA_CFG[section];
+  const hub = cfg.hubPath;
+  const html = await http.getHtml(hub);
+  return parseAlphabetLetters(html, baseURL);
+}
+async function alphabetItems(http, baseURL, section, letter, page = 0) {
+  const cfg = ALPHA_CFG[section];
+  const letterSeg = encodeURIComponent(letter);
+  const html = await http.getHtml(`${cfg.alphaPrefix}/${letterSeg}?page=${page}`);
+  return parseAlphabetListing(html, baseURL, page);
+}
+
+// src/api/listings.ts
+var listings_exports = {};
+__export(listings_exports, {
+  latest: () => latest,
+  listByPath: () => listByPath
+});
+
+// src/parsers/listing.ts
+import * as cheerio3 from "cheerio";
+
+// src/parsers/sorting.ts
+function parseExposedSorting(html, baseURL) {
+  const vfIdx = html.search(/<div[^>]+class=["'][^"']*view-filters[^"']*["'][^>]*>/i);
+  if (vfIdx < 0) return void 0;
+  const formStart = html.indexOf("<form", vfIdx);
+  if (formStart < 0) return void 0;
+  const formEnd = html.indexOf("</form>", formStart);
+  if (formEnd < 0) return void 0;
+  const formHtml = html.slice(formStart, formEnd + 7);
+  const actionMatch = /<form[^>]*\baction=["']([^"']+)["'][^>]*>/i.exec(formHtml);
+  if (!actionMatch) return void 0;
+  const abs = toAbsolute(baseURL, actionMatch[1] || "");
+  if (!abs) return void 0;
+  let actionPath = "/";
+  try {
+    actionPath = new URL(abs).pathname || "/";
+  } catch {
+    actionPath = "/";
+  }
+  const labels = /* @__PURE__ */ new Map();
+  const reLabel = /<label[^>]*\bfor=["']([^"']+)["'][^>]*>([\s\S]*?)<\/label>/gi;
+  let lm;
+  while (lm = reLabel.exec(formHtml)) {
+    const id = lm[1];
+    const raw = (lm[2] || "").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+    if (id && raw) labels.set(id, raw);
+  }
+  const selects = [];
+  const reSelect = /<select\b([^>]*)>([\s\S]*?)<\/select>/gi;
+  let sm;
+  while (sm = reSelect.exec(formHtml)) {
+    const attrs = sm[1] || "";
+    const inner = sm[2] || "";
+    const name = /(?:^|\s)name=["']([^"']+)["']/i.exec(attrs)?.[1];
+    if (!name) continue;
+    const idAttr = /(?:^|\s)id=["']([^"']+)["']/i.exec(attrs)?.[1];
+    const label = idAttr ? labels.get(idAttr) : void 0;
+    const options = [];
+    const reOpt = /<option\b([^>]*)>([\s\S]*?)<\/option>/gi;
+    let om;
+    while (om = reOpt.exec(inner)) {
+      const oattrs = om[1] || "";
+      const text = (om[2] || "").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+      const val = /(?:^|\s)value=["']([^"']*)["']/i.exec(oattrs)?.[1] ?? text;
+      const selected = /\bselected\b/i.test(oattrs) || /\bselected=["']selected["']/i.test(oattrs);
+      options.push({ value: val, label: text || val, selected });
+    }
+    selects.push({ name, label, options });
+  }
+  if (!selects.length) return void 0;
+  const appliedParams = {};
+  for (const s of selects) {
+    const selected = s.options.find((o) => o.selected);
+    if (selected && selected.value !== void 0) {
+      appliedParams[s.name] = String(selected.value);
+    }
+  }
+  return { actionPath, selects, appliedParams };
+}
+
+// src/parsers/listing.ts
+function pickFromSrcset2(srcset) {
+  if (!srcset) return;
+  const first = srcset.split(",")[0]?.trim();
+  if (!first) return;
+  const url = first.split(/\s+/)[0];
+  return url || void 0;
+}
+function pickFromStyle2(style) {
+  if (!style) return;
+  const m = style.match(/url\((['"]?)(.*?)\1\)/i);
+  return m?.[2] || void 0;
+}
+function pickThumb($scope, baseURL) {
+  const cands = [
+    ".views-field-field-preview img",
+    ".views-field-field-image img",
+    ".views-field-field-avatar img",
+    ".views-field-field-cat-preview img",
+    ".views-field-field-category-preview img",
+    ".views-field-field-comg-preview img",
+    ".views-field-field-gif-preview img",
+    ".views-field-field-gif-pre img",
+    ".views-field-field-gif img",
+    ".views-field-field-files img",
+    "img"
+  ];
+  for (const sel of cands) {
+    const img = $scope.find(sel).first();
+    if (img.length) {
+      const ds = img.attr("data-src") || img.attr("data-original");
+      const ss = pickFromSrcset2(img.attr("srcset") || "");
+      const src = ds || ss || img.attr("src");
+      const abs = toAbsolute(baseURL, src || "");
+      if (abs) return abs;
+    }
+  }
+  const srcset = pickFromSrcset2($scope.find("picture source").first().attr("srcset") || "");
+  if (srcset) return toAbsolute(baseURL, srcset);
+  const bg = pickFromStyle2(
+    $scope.attr("style") || $scope.find('[style*="background-image"]').first().attr("style")
+  );
+  if (bg) return toAbsolute(baseURL, bg);
+  return void 0;
+}
+function findTitleLink($scope) {
+  const sel = $scope.find(".views-field-title a[href]").first().length ? ".views-field-title a[href]" : $scope.find(".views-field-name a[href]").first().length ? ".views-field-name a[href]" : $scope.find(".views-field-nothing-1 h3 a[href]").first().length ? ".views-field-nothing-1 h3 a[href]" : $scope.find("strong a[href]").first().length ? "strong a[href]" : $scope.find("h5 a[href]").first().length ? "h5 a[href]" : "a[href]";
+  return $scope.find(sel).first();
+}
+function textFrom($el) {
+  return ($el.text() || "").replace(/\s+/g, " ").trim();
+}
+function isPager($a) {
+  return !!$a.closest("ul.pager, .pager, nav.pagination").length;
+}
+function cardRoot($a) {
+  const r = $a.closest("li, .views-row, td, .node, .views-col, .view-content > div, tr").first();
+  return r.length ? r : $a.parent();
+}
+function parseHubListing(html, baseURL, page) {
+  const $ = cheerio3.load(html);
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  const views = $(".view");
+  const scopes = views.length ? views.toArray() : [$("body").get(0)];
+  for (const v of scopes) {
+    const $view = $(v);
+    const $root = $view.find(".view-content").length ? $view.find(".view-content") : $view;
+    $root.find("table.views-table tbody tr").each((_, tr) => {
+      const $tr = $(tr);
+      let a = $tr.find(".views-field-nothing-1 h3 a[href]").first();
+      if (!a.length) {
+        const cand = $tr.find("a[href]").first();
+        if (cand.length && !isPager(cand)) a = cand;
+      }
+      const href = a.attr("href") || "";
+      const url = toAbsolute(baseURL, href);
+      if (!url || seen.has(url)) return;
+      const title = textFrom($tr.find(".views-field-nothing-1 h3").first()) || textFrom(a) || a.attr("title") || "";
+      if (!title.trim()) return;
+      const thumbCell = $tr.find(".views-field-field-files").first();
+      const thumb = pickThumb(thumbCell, baseURL) || pickThumb($tr, baseURL);
+      items.push({ title: title.trim(), url, thumb });
+      seen.add(url);
+    });
+    $root.find("table.views-view-grid td").each((_, td) => {
+      const $td = $(td);
+      const a = findTitleLink($td);
+      const href = a.attr("href") || "";
+      const url = toAbsolute(baseURL, href);
+      if (!url || seen.has(url)) return;
+      const title = textFrom(a) || textFrom($td.find(".views-field-title .field-content")) || textFrom($td.find(".views-field-name .field-content")) || a.attr("title") || "";
+      const thumb = pickThumb($td, baseURL);
+      if (title) {
+        items.push({ title, url, thumb });
+        seen.add(url);
+      }
+    });
+    $root.find(".views-row, .node, li").each((_, row) => {
+      const $row = $(row);
+      const a = findTitleLink($row);
+      const href = a.attr("href") || "";
+      const url = toAbsolute(baseURL, href);
+      if (!url || seen.has(url)) return;
+      const title = textFrom(a) || textFrom($row.find(".views-field-title .field-content")) || textFrom($row.find(".views-field-name .field-content")) || a.attr("title") || "";
+      const thumb = pickThumb($row, baseURL);
+      if (title) {
+        items.push({ title, url, thumb });
+        seen.add(url);
+      }
+    });
+    $root.find("a[href] img").each((_, imgEl) => {
+      const $a = $(imgEl).closest("a[href]");
+      if (isPager($a)) return;
+      const url = toAbsolute(baseURL, $a.attr("href") || "");
+      if (!url || seen.has(url)) return;
+      const $card = cardRoot($a);
+      const title = textFrom($card.find(".views-field-title .field-content").first()) || textFrom($card.find(".views-field-name .field-content").first()) || textFrom($card.find(".views-field-nothing-1 h3").first()) || $a.attr("title") || $(imgEl).attr("alt") || "";
+      if (!title.trim()) return;
+      const thumb = pickThumb($card, baseURL) || pickThumb($a, baseURL) || toAbsolute(baseURL, $(imgEl).attr("src") || "");
+      items.push({ title: title.trim(), url, thumb });
+      seen.add(url);
+    });
+  }
+  const totalPages = extractTotalPages(html);
+  const hasNext = page + 1 < totalPages;
+  const alphabet = parseAlphabetInline(html, baseURL) || void 0;
+  const sorting = parseExposedSorting(html, baseURL);
+  return {
+    items,
+    page,
+    hasNext,
+    totalPages,
+    pageSize: void 0,
+    alphabet,
+    sorting
+  };
+}
+
+// src/api/listings.ts
+function buildUrl(baseURL, path, params) {
+  const url = new URL(path.startsWith("/") ? path : `/${path}`, baseURL);
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      if (v === void 0) continue;
+      if (typeof v === "boolean") url.searchParams.set(k, v ? "1" : "0");
+      else url.searchParams.set(k, String(v));
+    }
+  }
+  return url.pathname + (url.search ? url.search : "");
+}
+function normalizeCharactersPath(path) {
+  const clean = path.startsWith("/") ? path : `/${path}`;
+  if (/^\/alphabetical_order_characters\/?$/i.test(clean)) return "/characters";
+  return clean;
+}
+function sniffPagePrefixFromHtml(html) {
+  const m = html.match(
+    /<ul[^>]*class=["'][^"']*pager[^"']*["'][\s\S]*?\bhref=["'][^"']*?\bpage=([^"&]+)["'][\s\S]*?<\/ul>/i
+  ) || html.match(/\bpage=([^"&]+)/i);
+  if (!m) return null;
+  try {
+    const decoded = decodeURIComponent(m[1]);
+    if (decoded.includes(",")) {
+      const parts = decoded.split(",").map((s) => s.trim());
+      if (parts.length > 1) return parts.slice(0, -1).join(",") + ",";
+    }
+  } catch {
+  }
+  return null;
+}
+function buildPageParam(htmlWithPager, page) {
+  const prefix = sniffPagePrefixFromHtml(htmlWithPager);
+  return prefix ? `${prefix}${page}` : String(page);
+}
+function getAppliedFromHtml(html, baseURL) {
+  const sorting = parseExposedSorting(html, baseURL);
+  return sorting?.appliedParams ?? {};
+}
+async function latest(http, baseURL, page = 0, params) {
+  const url0 = buildUrl(baseURL, "/new", { ...params ?? {}, page: 0 });
+  const html0 = await http.getHtml(url0);
+  if (page === 0) {
+    return parseHubListing(html0, baseURL, 0);
+  }
+  const applied = params ? {} : getAppliedFromHtml(html0, baseURL);
+  const pageParam = buildPageParam(html0, page);
+  const html = await http.getHtml(
+    buildUrl(baseURL, "/new", { ...applied, ...params ?? {}, page: pageParam })
+  );
+  return parseHubListing(html, baseURL, page);
+}
+async function listByPath(http, baseURL, path, page = 0, opts) {
+  const clean = path.startsWith("/") ? path : `/${path}`;
+  const commonParams = { ...opts ?? {} };
+  delete commonParams.letter;
+  if (opts?.letter) {
+    const entryHtml = await http.getHtml(buildUrl(baseURL, clean, commonParams));
+    const alphabet = parseAlphabetInline(entryHtml, baseURL);
+    const wanted = String(opts.letter).toUpperCase();
+    let letterUrl;
+    if (alphabet) {
+      const match = alphabet.letters.find((l) => (l.value || "").toUpperCase() === wanted) || alphabet.letters.find((l) => (l.label || "").toUpperCase() === wanted);
+      letterUrl = match?.href || `/${alphabet.section}/${encodeURIComponent(wanted)}`;
+    } else {
+      const section = guessAlphabetSectionFromPath(clean);
+      letterUrl = `/${section}/${encodeURIComponent(wanted)}`;
+    }
+    const url0 = buildUrl(baseURL, letterUrl, { ...commonParams, page: 0 });
+    const html02 = await http.getHtml(url0);
+    const res0 = parseAlphabetListing(html02, baseURL, 0);
+    if (alphabet) res0.alphabet = alphabet;
+    if (page === 0) {
+      return res0;
+    }
+    const applied2 = Object.keys(commonParams).length ? {} : getAppliedFromHtml(html02, baseURL);
+    const pageParam2 = buildPageParam(html02, page);
+    const html2 = await http.getHtml(
+      buildUrl(baseURL, letterUrl, { ...applied2, ...commonParams, page: pageParam2 })
+    );
+    const res = parseAlphabetListing(html2, baseURL, page);
+    if (alphabet) res.alphabet = alphabet;
+    return res;
+  }
+  const effective = normalizeCharactersPath(clean);
+  const html0 = await http.getHtml(buildUrl(baseURL, effective, { ...commonParams, page: 0 }));
+  const parsed0 = parseHubListing(html0, baseURL, 0);
+  if (effective !== clean && !parsed0.alphabet) {
+    try {
+      const entryHtml = await http.getHtml(buildUrl(baseURL, clean, commonParams));
+      const alpha = parseAlphabetInline(entryHtml, baseURL);
+      if (alpha) parsed0.alphabet = alpha;
+    } catch {
+    }
+  }
+  if (page === 0) {
+    return parsed0;
+  }
+  const applied = Object.keys(commonParams).length ? {} : parsed0.sorting?.appliedParams ?? getAppliedFromHtml(html0, baseURL);
+  const pageParam = buildPageParam(html0, page);
+  const html = await http.getHtml(
+    buildUrl(baseURL, effective, { ...applied, ...commonParams, page: pageParam })
+  );
+  const parsed = parseHubListing(html, baseURL, page);
+  if (effective !== clean && !parsed.alphabet) {
+    try {
+      const entryHtml = await http.getHtml(buildUrl(baseURL, clean, commonParams));
+      const alpha = parseAlphabetInline(entryHtml, baseURL);
+      if (alpha) parsed.alphabet = alpha;
+    } catch {
+    }
+  }
+  return parsed;
+}
+
+// src/api/posts.ts
+var posts_exports = {};
+__export(posts_exports, {
+  getPost: () => getPost
+});
+
+// src/parsers/post.ts
+import * as cheerio4 from "cheerio";
+function parsePost(html, baseURL, url) {
+  const $ = cheerio4.load(html);
+  const title = $("h1").first().text().trim() || $(".page-title, .node-title, .title").first().text().trim() || url;
+  const container = $("#content, .content, article, .node, .field-items").first();
+  const imgs = [];
+  container.find("img").each((_, img) => {
+    const el = $(img);
+    const src = el.attr("data-src") || el.attr("src");
+    const abs = toAbsolute(baseURL, src || "");
+    if (abs) imgs.push(abs);
+  });
+  const images = uniq(imgs);
+  const tags = [];
+  $('.tags a, a[rel="tag"], .field-name-field-tags a').each((_, a) => {
+    const t = $(a).text().trim();
+    if (t) tags.push(t);
+  });
+  const author = $(".author a").first().text().trim() || $(".submitted .username").first().text().trim() || null;
+  return { title, url, images, tags: uniq(tags), author };
+}
+
+// src/api/posts.ts
+async function getPost(http, baseURL, urlOrSlug) {
+  const html = await http.getHtml(urlOrSlug);
+  const absolute = (() => {
+    try {
+      return new URL(urlOrSlug).toString();
+    } catch {
+      return new URL(urlOrSlug.replace(/^\//, ""), baseURL + "/").toString();
+    }
+  })();
+  return parsePost(html, baseURL, absolute);
+}
+
+// src/api/search.ts
+var search_exports = {};
+__export(search_exports, {
+  search: () => search
+});
+
+// src/parsers/search.ts
+import * as cheerio5 from "cheerio";
+function parseSearch(html, baseURL, page) {
+  const $ = cheerio5.load(html);
+  const items = [];
+  const view = $(".view").filter((_, el) => {
+    const cls = $(el).attr("class") || "";
+    return /view-id-search/.test(cls) && /view-display-id-page/.test(cls) && $(el).find(".view-content").length > 0;
+  }).first();
+  const rows = view.find(".view-content .views-row");
+  rows.each((_, el) => {
+    const row = $(el);
+    const a = row.find(".views-field-title a[href]").first().length ? row.find(".views-field-title a[href]").first() : row.find("a[href]").first();
+    const href = a.attr("href") || "";
+    const url = toAbsolute(baseURL, href);
+    const title = (a.text() || row.find(".views-field-title .field-content").text() || "").trim();
+    const pickImg = row.find(".views-field-field-preview img").first().length ? row.find(".views-field-field-preview img").first() : row.find(".views-field-field-image img").first().length ? row.find(".views-field-field-image img").first() : row.find(".views-field-field-fl-prev img").first().length ? row.find(".views-field-field-fl-prev img").first() : row.find(".views-field-field-album-preview img").first().length ? row.find(".views-field-field-album-preview img").first() : row.find(".views-field-field-vd-preciew img").first().length ? row.find(".views-field-field-vd-preciew img").first() : row.find(".views-field-field-gif-pre img").first().length ? row.find(".views-field-field-gif-pre img").first() : row.find(".views-field-field-avatar img").first().length ? row.find(".views-field-field-avatar img").first() : row.find("img").first();
+    let thumb = pickImg.attr("data-src") || pickImg.attr("src") || void 0;
+    thumb = toAbsolute(baseURL, thumb);
+    if (url && title) items.push({ title, url, thumb });
+  });
+  const totalPages = extractTotalPages(html);
+  const hasNext = page + 1 < totalPages;
+  if (items.length === 0) {
+    return { items: [], page, hasNext: false, totalPages: 1 };
+  }
+  return { items, page, hasNext, totalPages };
+}
+
+// src/parsers/ajax.ts
+import * as cheerio6 from "cheerio";
+function extractViewsContextForSearch(html) {
+  const $ = cheerio6.load(html);
+  const view = $(".view").filter((_, el) => {
+    const cls2 = $(el).attr("class") || "";
+    return /view-id-search/.test(cls2) && /view-display-id-page/.test(cls2);
+  }).first();
+  const cls = view.attr("class") || "";
+  const view_name = cls.match(/view-id-([^\s]+)/)?.[1] || "search";
+  const view_display_id = cls.match(/view-display-id-([^\s]+)/)?.[1] || "page";
+  const domFromClass = cls.match(/view-dom-id-([^\s]+)/)?.[1] || "";
+  const domFromId = (view.attr("id") || "").replace(/^view-dom-id-/, "");
+  const view_dom_id = domFromClass || domFromId || "view-dom-id-1";
+  const ajax_html_id = $('[id^="views-exposed-form"]').attr("id") || view.attr("id") || void 0;
+  return { view_name, view_display_id, view_dom_id, ajax_html_id };
+}
+function extractHtmlFromDrupalAjax(payload, wantDomId) {
+  if (Array.isArray(payload)) {
+    for (const cmd of payload) {
+      const c = cmd;
+      const sel = String(c?.selector || "");
+      const data = c?.data;
+      if ((c?.command === "insert" || c?.command === "replaceWith") && typeof data === "string" && data.trim() && (!wantDomId || sel.includes(wantDomId) || sel.includes("view-content")))
+        return data;
+    }
+    const concat = payload.map((x) => typeof x?.data === "string" ? x.data : "").join("");
+    return concat.trim() ? concat : null;
+  }
+  const disp = payload?.display;
+  return typeof disp === "string" ? disp : null;
+}
+
+// src/api/search.ts
+async function search(http, baseURL, query, page = 0) {
+  const q = encodeURIComponent(query);
+  const html1 = await http.getHtml(`/search?search_api_views_fulltext=${q}&page=${page}`);
+  const parsed1 = parseSearch(html1, baseURL, page);
+  if (parsed1.items.length > 0) return parsed1;
+  const firstHtml = await http.getHtml(`/search?search_api_views_fulltext=${q}`);
+  const ctx = extractViewsContextForSearch(firstHtml);
+  const ajaxUrl = `/views/ajax?search_api_views_fulltext=${q}&undefined=Search&_wrapper_format=drupal_ajax`;
+  const payload = {
+    view_name: ctx.view_name || "search",
+    view_display_id: ctx.view_display_id || "page",
+    view_args: "",
+    view_path: "search",
+    view_base_path: "search",
+    view_dom_id: ctx.view_dom_id,
+    pager_element: "0",
+    page: String(page)
+  };
+  if (ctx.ajax_html_id) payload["ajax_html_ids[]"] = [ctx.ajax_html_id];
+  const json = await http.postForm(ajaxUrl, payload);
+  const html2 = extractHtmlFromDrupalAjax(json, ctx.view_dom_id) || "";
+  return parseSearch(html2, baseURL, page);
+}
+
+// src/api/updates.ts
+var updates_exports = {};
+__export(updates_exports, {
+  updates: () => updates,
+  updatesShortcuts: () => updatesShortcuts
+});
+
+// src/parsers/viewDisplay.ts
+import * as cheerio7 from "cheerio";
+function parseViewDisplay(viewName, html, baseURL) {
+  const $ = cheerio7.load(html);
+  const items = [];
+  const pickThumb2 = (scope) => {
+    const img = scope.find(".views-field-field-preview img").first().length ? scope.find(".views-field-field-preview img").first() : scope.find(".views-field-field-image img").first().length ? scope.find(".views-field-field-image img").first() : scope.find(".views-field-field-avatar img").first().length ? scope.find(".views-field-field-avatar img").first() : scope.find("img").first();
+    let thumb = img.attr("data-src") || img.attr("src") || void 0;
+    return toAbsolute(baseURL, thumb);
+  };
+  const liList = $("ul.jcarousel li");
+  liList.each((_, li) => {
+    const scope = $(li);
+    const a = scope.find(".views-field-title a[href]").first().length ? scope.find(".views-field-title a[href]").first() : scope.find(".views-field-name a[href]").first();
+    const href = a.attr("href") || "";
+    const url = toAbsolute(baseURL, href);
+    const title = (a.text() || scope.find(".views-field-title .field-content").text() || scope.find(".views-field-name .field-content").text() || "").trim();
+    const thumb = pickThumb2(scope);
+    if (url && title) items.push({ title, url, thumb });
+  });
+  return items;
+}
+
+// src/api/updates.ts
+var VIEW_PRESETS = {
+  random_top_comics: { view_display_id: "block", jcarousel_dom_id: 7 },
+  top_random_characters: { view_display_id: "block", jcarousel_dom_id: 8 }
+};
+function uniq2(arr) {
+  return Array.from(new Set(arr));
+}
+async function updates(http, baseURL, params = {}) {
+  const viewName = params.view_name ?? "new_mini";
+  const preset = VIEW_PRESETS[viewName] || {};
+  const first = Number(params.first ?? 0);
+  const last = Number(params.last ?? 8);
+  const basePayload = {
+    js: "1",
+    first: String(first),
+    last: String(last),
+    view_args: params.view_args ?? "",
+    view_path: params.view_path ?? "node",
+    view_base_path: params.view_base_path ?? "",
+    view_name: viewName
+  };
+  const displayCandidates = uniq2([
+    params.view_display_id ?? preset.view_display_id ?? "block_1",
+    "block",
+    "block_2",
+    "block_3",
+    "page",
+    "default"
+  ]).filter(Boolean);
+  const origDom = Number(params.jcarousel_dom_id ?? preset.jcarousel_dom_id ?? 1);
+  const domCandidates = uniq2([
+    origDom,
+    origDom - 1,
+    origDom + 1,
+    ...Array.from({ length: 10 }, (_, i) => i + 1)
+  ]).filter((n) => Number.isFinite(n) && n > 0);
+  let displayHtml = "";
+  for (const view_display_id of displayCandidates) {
+    for (const jcarousel_dom_id of domCandidates) {
+      try {
+        const qs = new URLSearchParams({
+          ...basePayload,
+          view_display_id: String(view_display_id),
+          jcarousel_dom_id: String(jcarousel_dom_id)
+        }).toString();
+        const data = await http.getJson(`/jcarousel/ajax/views?${qs}`);
+        const html = data?.display?.trim() ?? "";
+        if (html) {
+          displayHtml = html;
+          displayCandidates.length = 0;
+          break;
+        }
+      } catch {
+      }
+    }
+  }
+  if (!displayHtml) {
+    return { items: [], first, last, html: "", viewName };
+  }
+  const items = parseViewDisplay(viewName, displayHtml, baseURL);
+  return { items, first, last, html: displayHtml, viewName };
+}
+var updatesShortcuts = {
+  newMini: (http, baseURL, p) => updates(http, baseURL, { ...p ?? {}, view_name: "new_mini" }),
+  userUploadFront: (http, baseURL, p) => updates(http, baseURL, { ...p ?? {}, view_name: "user_upload_front" }),
+  updatedManga: (http, baseURL, p) => updates(http, baseURL, { ...p ?? {}, view_name: "updated_manga" }),
+  updatedMangaPromoted: (http, baseURL, p) => updates(http, baseURL, { ...p ?? {}, view_name: "updated_manga_promoted" }),
+  updatedGames: (http, baseURL, p) => updates(http, baseURL, { ...p ?? {}, view_name: "updated_games" }),
+  randomTopComics: (http, baseURL, p) => updates(http, baseURL, { ...p ?? {}, view_name: "random_top_comics" }),
+  topRandomCharacters: (http, baseURL, p) => updates(http, baseURL, { ...p ?? {}, view_name: "top_random_characters" })
+};
+
+// src/parsers/viewer.ts
+var viewer_exports = {};
+__export(viewer_exports, {
+  buildJuiceboxXmlUrl: () => buildJuiceboxXmlUrl,
+  default: () => viewer_default,
+  parseInlineJuiceboxFromHtml: () => parseInlineJuiceboxFromHtml,
+  parseJuiceboxXml: () => parseJuiceboxXml,
+  parseViewer: () => parseViewer,
+  parseViewerMeta: () => parseViewerMeta
+});
+function decodeHtml(s) {
+  return s.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#039;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">");
+}
+function textBetween(html, openRe, close) {
+  const m = openRe.exec(html);
+  if (!m) return null;
+  const i = m.index + m[0].length;
+  const j = html.indexOf(close, i);
+  if (j < 0) return null;
+  return html.slice(i, j);
+}
+function stripTags(s) {
+  return s.replace(/<[^>]*>/g, "");
+}
+function collectLinks(blockHtml, baseURL) {
+  const out = [];
+  const re = /<a\s+[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+  let m;
+  while (m = re.exec(blockHtml)) {
+    const url = absUrl(baseURL, m[1]) ?? "";
+    const title = normSpace(decodeHtml(stripTags(m[2])));
+    if (url && title) out.push({ url, title });
+  }
+  return out;
+}
+function findFieldNodeAndSys(html) {
+  const re = /id="field--node--(\d+)--([a-z0-9_-]+)--full"/i;
+  const m = re.exec(html);
+  if (m) {
+    const nodeId = parseInt(m[1], 10);
+    const fieldSys = m[2].replace(/-/g, "_");
+    if (Number.isFinite(nodeId)) return { nodeId, fieldSys };
+  }
+  const re2 = /\/juicebox\/xml\/field\/node\/(\d+)\/([a-z0-9_]+)\/full/gi;
+  const m2 = re2.exec(html);
+  if (m2) {
+    const nodeId = parseInt(m2[1], 10);
+    const fieldSys = m2[2];
+    if (Number.isFinite(nodeId)) return { nodeId, fieldSys };
+  }
+  return null;
+}
+function buildJuiceboxXmlUrl(baseURL, nodeId, fieldSys) {
+  const root = baseURL.replace(/\/+$/, "");
+  return `${root}/juicebox/xml/field/node/${nodeId}/${fieldSys}/full`;
+}
+function parseJuiceboxXml(xml) {
+  const images = [];
+  const reImg = /<image\b([^>]+)>/gi;
+  let m;
+  while (m = reImg.exec(xml)) {
+    const attrs = m[1];
+    const map = {};
+    let am;
+    const reAttr = /([a-zA-Z0-9_-]+)\s*=\s*"([^"]*)"/g;
+    while (am = reAttr.exec(attrs)) map[am[1]] = am[2];
+    const original = map["linkURL"] || map["imageURL"] || map["largeImageURL"] || map["smallImageURL"] || "";
+    if (!original) continue;
+    images.push({
+      original,
+      large: map["largeImageURL"],
+      medium: map["imageURL"] || map["smallImageURL"],
+      small: map["smallImageURL"],
+      thumb: map["thumbURL"]
+    });
+  }
+  return images;
+}
+function parseInlineJuiceboxFromHtml(html) {
+  const out = [];
+  const reMed = /<img[^>]+src="([^"]+\/styles\/juicebox_(?:medium|small|large)\/[^"]+)"[^>]*>/gi;
+  const seen = /* @__PURE__ */ new Set();
+  let m;
+  while (m = reMed.exec(html)) {
+    const url = m[1];
+    if (seen.has(url)) continue;
+    seen.add(url);
+    out.push({ original: url, medium: url });
+  }
+  return out;
+}
+function parseBreadcrumbs(html, baseURL) {
+  const block = textBetween(html, /<div[^>]+class="breadcrumb"[^>]*>/i, "</div>");
+  return block ? collectLinks(block, baseURL) : [];
+}
+function findLabeledFieldBlock(html, labelStartsWith) {
+  const esc = labelStartsWith.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(
+    `<(?:h3|div)[^>]*class="[^"]*field-label[^"]*"[^>]*>\\s*${esc}\\s*:?\\s*<\\/[^>]+>`,
+    "i"
+  );
+  const idx = html.search(re);
+  if (idx < 0) return null;
+  const open = html.lastIndexOf("<div", idx);
+  let depth = 0;
+  for (let i = open; i < html.length; i++) {
+    if (html.startsWith("<div", i)) depth++;
+    if (html.startsWith("</div>", i)) {
+      depth--;
+      if (depth === 0) {
+        return html.slice(open, i + 6);
+      }
+    }
+  }
+  return null;
+}
+function parseLabeledField(html, labelStartsWith) {
+  return findLabeledFieldBlock(html, labelStartsWith);
+}
+function parsePlainValuesFromLabeledField(html, label) {
+  const block = findLabeledFieldBlock(html, label);
+  if (!block) return [];
+  const text = normSpace(decodeHtml(stripTags(block))).replace(new RegExp(`^${label}\\s*:?\\s*`, "i"), "").trim();
+  if (!text) return [];
+  return text.split(/\s*[,;]\s*/).filter(Boolean);
+}
+function parseTitle(html) {
+  const h1 = textBetween(html, /<h1[^>]*id="page-title"[^>]*>/i, "</h1>");
+  if (h1) return normSpace(decodeHtml(stripTags(h1)));
+  const m = /<meta[^>]+property="og:title"[^>]+content="([^"]+)"/i.exec(html);
+  if (m) return normSpace(decodeHtml(m[1]));
+  return "";
+}
+function parseVotesAndRating(html) {
+  const block = /<div[^>]*class="[^"]*\bfivestar-summary\b[^"]*"[^>]*>([\s\S]*?)<\/div>/i.exec(html)?.[1] || /<div[^>]*class="[^"]*\bfivestar-average[^"]*"[^>]*>([\s\S]*?)<\/div>/i.exec(html)?.[1] || "";
+  if (block) {
+    const mAvg = /class="average-rating"[^>]*>[\s\S]*?Average[^:]*:\s*(?:<span[^>]*>)?([\d.,]+)(?:<\/span>)?/i.exec(
+      block
+    );
+    const mVotes = /class="total-votes"[^>]*>\s*\(\s*(?:<span[^>]*>)?(\d+)(?:<\/span>)?\s+votes?\s*\)/i.exec(
+      block
+    );
+    const rating = mAvg ? parseNumberLike(mAvg[1]) : void 0;
+    const votes = mVotes ? parseIntLike(mVotes[1]) : void 0;
+    if (rating != null || votes != null) return { rating, votes };
+  }
+  const m1 = /Average\s*:\s*(?:<span[^>]*>)?([\d.,]+)(?:<\/span>)?[\s\S]*?\(\s*(?:<span[^>]*>)?(\d+)(?:<\/span>)?\s*votes?\s*\)/i.exec(
+    html
+  );
+  if (m1) {
+    return {
+      rating: parseNumberLike(m1[1]),
+      votes: parseIntLike(m1[2])
+    };
+  }
+  const m2 = /Average[^<>\d]*([\d.,]+)/i.exec(html);
+  const m3 = /\((\d+)\s+votes?\)/i.exec(html);
+  if (m2 || m3) {
+    const rating = m2 ? parseNumberLike(m2[1]) : void 0;
+    const votes = m3 ? parseIntLike(m3[1]) : void 0;
+    return { rating, votes };
+  }
+  return {};
+}
+function parseViews(html) {
+  const patterns = [
+    /<li[^>]*class="statistics_counter[^"]*"[^>]*>\s*<span>\s*([\d\s.,]+)\s+views\s*<\/span>/i,
+    />\s*([\d\s.,]+)\s+views\s*<\/(?:span|div|li|h\d)>/i,
+    />\s*Views\s*[:\-]?\s*<\/?(?:span|strong|b)?[^>]*>\s*([\d\s.,]+)\s*</i,
+    /\bViews\s*[:\-]?\s*([\d\s.,]+)/i
+  ];
+  for (const rx of patterns) {
+    const m = rx.exec(html);
+    if (m && m[1]) return parseIntLike(m[1]);
+  }
+  return void 0;
+}
+function parseLinksFromLabeledField(html, baseURL, label) {
+  const block = parseLabeledField(html, label);
+  return block ? collectLinks(block, baseURL) : [];
+}
+function parseRelated(html, baseURL) {
+  const pieces = [];
+  const re = /<div[^>]+class="view[^"]*down[^"]*random[^"]*hentai[^"]*manga[^"]*"[^>]*>([\s\S]*?)<\/div>\s*<\/div>/gi;
+  let m;
+  while (m = re.exec(html)) pieces.push(m[1]);
+  return uniq(pieces.flatMap((p) => collectLinks(p, baseURL)));
+}
+function parseUploader(html, baseURL) {
+  const m = /<footer[^>]*class="[^"]*\bsubmitted\b[^"]*"[^>]*>([\s\S]*?)<\/footer>/i.exec(html);
+  if (!m) return void 0;
+  const block = m[1];
+  const a = /Uploaded\s+by\s*<a[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>\s*on\s*([^<]+)/i.exec(
+    block
+  );
+  const img = /<div[^>]*class="user-picture"[^>]*>[\s\S]*?<img[^>]*src="([^"]+)"/i.exec(block);
+  const out = {};
+  if (a) {
+    out.url = absUrl(baseURL, a[1]) ?? "";
+    out.name = normSpace(decodeHtml(stripTags(a[2])));
+    out.dateText = normSpace(decodeHtml(a[3]));
+  }
+  if (img) out.avatar = absUrl(baseURL, img[1]) ?? "";
+  return out;
+}
+function parseViewerMeta(html, baseURL, absoluteUrl) {
+  const title = parseTitle(html);
+  const breadcrumbs = parseBreadcrumbs(html, baseURL);
+  let authors = parseLinksFromLabeledField(html, baseURL, "Author");
+  if (authors.length === 0) {
+    const altLinks = parseLinksFromLabeledField(html, baseURL, "Artist's name");
+    if (altLinks.length) authors = altLinks;
+    if (authors.length === 0) {
+      const altPlain = parsePlainValuesFromLabeledField(html, "Artist's name");
+      if (altPlain.length) {
+        authors = altPlain.map((t) => ({ title: t, url: "" }));
+      }
+    }
+  }
+  let sections = parseLinksFromLabeledField(html, baseURL, "Section");
+  if (sections.length === 0) {
+    const sPlain = parsePlainValuesFromLabeledField(html, "Section");
+    if (sPlain.length) sections = sPlain.map((t) => ({ title: t, url: "" }));
+  }
+  let tags = parseLinksFromLabeledField(html, baseURL, "Tags");
+  if (tags.length === 0) {
+    const block = /<div[^>]*class="[^"]*field-name-field-category[^"]*"[^>]*>([\s\S]*?)<\/div>/i.exec(html);
+    if (block) tags = collectLinks(block[1], baseURL);
+  }
+  const characters = parseLinksFromLabeledField(html, baseURL, "Characters");
+  const userTags = parseLinksFromLabeledField(html, baseURL, "User tags");
+  const { rating, votes } = parseVotesAndRating(html);
+  const views = parseViews(html);
+  const kind = guessKindFromPath(absoluteUrl);
+  const field = findFieldNodeAndSys(html);
+  const uploader = parseUploader(html, baseURL);
+  const meta = {
+    nodeId: field?.nodeId ?? null,
+    fieldSys: field?.fieldSys ?? null,
+    title,
+    kind,
+    breadcrumbs,
+    authors,
+    sections,
+    tags,
+    characters,
+    userTags,
+    rating,
+    votes,
+    views,
+    related: parseRelated(html, baseURL)
+  };
+  if (uploader) {
+    meta.uploader = uploader;
+  }
+  return { meta, nodeId: meta.nodeId, fieldSys: meta.fieldSys };
+}
+function findCanonicalUrl(html, baseURL) {
+  const m1 = /<link[^>]+rel=["']canonical["'][^>]+href=["']([^"']+)["']/i.exec(html);
+  if (m1?.[1]) return absUrl(baseURL, m1[1]) ?? baseURL.replace(/\/+$/, "");
+  const m2 = /<meta[^>]+property=["']og:url["'][^>]+content=["']([^"']+)["']/i.exec(html);
+  if (m2?.[1]) return absUrl(baseURL, m2[1]) ?? baseURL.replace(/\/+$/, "");
+  return baseURL.replace(/\/+$/, "");
+}
+var EXCLUDE_URL_PATTERNS = [
+  /\/styles\/avatars\//i,
+  /\/user_avatars\//i,
+  /\/default_images\//i,
+  /\/styles\/taxonomy_(?:comics|manga)\//i,
+  /\/com_preview\//i,
+  /\/promo\//i
+];
+function isExcludedUrl(u) {
+  const s = String(u);
+  return EXCLUDE_URL_PATTERNS.some((re) => re.test(s));
+}
+function stripExcludedBlocks(html) {
+  const patterns = [
+    /<div[^>]+id="comments"[^>]*>[\s\S]*?<\/div>/gi,
+    /<section[^>]+id="comments"[^>]*>[\s\S]*?<\/section>/gi,
+    /<div[^>]+class="[^"]*\bcomments?\b[^"]*"[^>]*>[\s\S]*?<\/div>/gi,
+    /<div[^>]+class="[^"]*\bcomment\b[^"]*"[^>]*>[\s\S]*?<\/div>/gi,
+    /<ul[^>]+class="[^"]*\bcomment\b[^"]*"[^>]*>[\s\S]*?<\/ul>/gi,
+    /<div[^>]+class="[^"]*\brelated\b[^"]*"[^>]*>[\s\S]*?<\/div>/gi,
+    /<div[^>]+class="[^"]*\bmore\b[^"]*"[^>]*>[\s\S]*?<\/div>/gi,
+    /<div[^>]+class="[^"]*\bmore-comics\b[^"]*"[^>]*>[\s\S]*?<\/div>/gi,
+    /<div[^>]+class="[^"]*\bpane-related\b[^"]*"[^>]*>[\s\S]*?<\/div>/gi,
+    /<aside[\s\S]*?<\/aside>/gi,
+    /<div[^>]+class="[^"]*\bsidebar\b[^"]*"[^>]*>[\s\S]*?<\/div>/gi,
+    /<div[^>]+class="[^"]*\bnode-footer\b[^"]*"[^>]*>[\s\S]*?<\/div>/gi,
+    /<div[^>]+class="[^"]*\bpane-views\b[^"]*"[^>]*>[\s\S]*?<\/div>/gi,
+    /<div[^>]+class="[^"]*\bpane-taxonomy\b[^"]*"[^>]*>[\s\S]*?<\/div>/gi
+  ];
+  let cleaned = html;
+  for (const re of patterns) cleaned = cleaned.replace(re, "");
+  return cleaned;
+}
+function collectImgSrcs(html) {
+  const out = [];
+  const re = /<img[^>]+src=["']([^"']+)["'][^>]*>/gi;
+  let m;
+  while (m = re.exec(html)) out.push(m[1]);
+  return out;
+}
+function collectContentImages(html) {
+  const cleaned = stripExcludedBlocks(html);
+  return collectImgSrcs(cleaned).filter((u) => !!u && !isExcludedUrl(u));
+}
+function parseViewer(html, baseURL) {
+  const absoluteUrl = findCanonicalUrl(html, baseURL);
+  const { meta } = parseViewerMeta(html, baseURL, absoluteUrl);
+  const inline = parseInlineJuiceboxFromHtml(html).map((im) => {
+    const original = toAbsolute(baseURL, im.original || "") || "";
+    return {
+      original,
+      large: im.large ? toAbsolute(baseURL, im.large) || void 0 : void 0,
+      medium: im.medium ? toAbsolute(baseURL, im.medium) || void 0 : void 0,
+      small: im.small ? toAbsolute(baseURL, im.small) || void 0 : void 0,
+      thumb: im.thumb ? toAbsolute(baseURL, im.thumb) || void 0 : void 0
+    };
+  }).filter((im) => !!im.original);
+  let fallback = [];
+  if (inline.length === 0) {
+    const srcs = collectContentImages(html).map((u) => toAbsolute(baseURL, u) || "").filter((u) => !!u);
+    const seen = /* @__PURE__ */ new Set();
+    fallback = srcs.filter((u) => {
+      if (!u || seen.has(u)) return false;
+      seen.add(u);
+      return true;
+    }).map((u) => ({ original: u }));
+  }
+  const all = [...inline, ...fallback];
+  const byOriginal = /* @__PURE__ */ new Map();
+  for (const im of all) {
+    const key = im.original || "";
+    if (key && !byOriginal.has(key)) byOriginal.set(key, im);
+  }
+  return { meta, images: Array.from(byOriginal.values()) };
+}
+var viewer_default = parseViewer;
+
+// src/parsers/video.ts
+var ABS_URL = /^https?:\/\//i;
+function absolutize(u, base) {
+  if (!u) return "";
+  if (ABS_URL.test(u)) return u;
+  if (u.startsWith("//")) return "https:" + u;
+  if (u.startsWith("/")) return base.replace(/\/+$/, "") + u;
+  return u;
+}
+function parseVideoFromHtml(html, baseURL) {
+  if (!html || !/node-video|class=["']video-js|<video/i.test(html)) return null;
+  const posterMatch = html.match(/<video[^>]*\sposter=["']([^"']+)["']/i) || html.match(/class=["']video-js[^"']*["'][^>]*\sposter=["']([^"']+)["']/i);
+  const poster = posterMatch ? absolutize(posterMatch[1], baseURL) : void 0;
+  const sources = [];
+  const mainVideo = html.match(/<video[^>]*\ssrc=["']([^"']+)["'][^>]*>/i);
+  if (mainVideo) sources.push({ url: absolutize(mainVideo[1], baseURL) });
+  const re = /<source[^>]*\ssrc=["']([^"']+)["'][^>]*?(?:\stype=["']([^"']+)["'])?[^>]*>/gi;
+  for (let m; m = re.exec(html); ) {
+    sources.push({ url: absolutize(m[1], baseURL), type: m[2] });
+  }
+  if (!sources.length) return null;
+  return { poster, sources };
+}
+
+// src/api/viewer.ts
+var ABS_URL2 = /^https?:\/\//i;
+function absolutize2(u, base) {
+  if (!u) return "";
+  if (ABS_URL2.test(u)) return u;
+  if (u.startsWith("//")) return "https:" + u;
+  if (u.startsWith("/")) return base.replace(/\/+$/, "") + u;
+  return base.replace(/\/+$/, "") + "/" + u.replace(/^\/+/, "");
+}
+function buildViewerUrl(base, urlOrSlug) {
+  if (ABS_URL2.test(urlOrSlug)) return urlOrSlug;
+  if (urlOrSlug.startsWith("/")) return base.replace(/\/+$/, "") + urlOrSlug;
+  return base.replace(/\/+$/, "") + "/" + urlOrSlug.replace(/^\/+/, "");
+}
+async function fetchHtml(http, url) {
+  const anyHttp = http;
+  if (typeof anyHttp.getText === "function") return anyHttp.getText(url);
+  if (typeof anyHttp.get === "function") return anyHttp.get(url);
+  if (typeof anyHttp.text === "function") return anyHttp.text(url);
+  if (typeof anyHttp.fetch === "function") {
+    const r = await anyHttp.fetch(url);
+    if (typeof r === "string") return r;
+    if (r && typeof r.text === "function") return await r.text();
+  }
+  if (typeof fetch === "function") {
+    const r = await fetch(url);
+    return await r.text();
+  }
+  throw new Error("HttpClient: no getText/get/text/fetch available");
+}
+function proxyImgMaybe(u, opts) {
+  if (!u) return "";
+  return opts?.proxyImage ? opts.proxyImage(u) : u;
+}
+function proxyVidMaybe(u, opts) {
+  if (!u) return "";
+  const proxyVideo = opts?.proxyVideo;
+  return proxyVideo ? proxyVideo(u) : proxyImgMaybe(u, opts);
+}
+function tryParseRichMeta(html, baseURL, absoluteUrl) {
+  const anyParsers = viewer_exports;
+  if (typeof anyParsers.parseViewerMeta === "function") {
+    try {
+      const { meta } = anyParsers.parseViewerMeta(html, baseURL, absoluteUrl);
+      if (!meta.title) {
+        const t = extractMeta(html, baseURL).title;
+        if (t) meta.title = t;
+      }
+      return meta;
+    } catch {
+    }
+  }
+  return extractMeta(html, baseURL);
+}
+function parseImagesWithBackoff(html, baseURL) {
+  const anyParsers = viewer_exports;
+  const candidate = anyParsers.parseViewer ?? anyParsers.default;
+  if (typeof candidate === "function") {
+    return candidate(html, baseURL);
+  }
+  const images = [];
+  const re = /<img[^>]+src=["']([^"']+)["'][^>]*>/gi;
+  let m;
+  while (m = re.exec(html)) {
+    const original = absolutize2(m[1], baseURL);
+    if (!original) continue;
+    images.push({ original, medium: original });
+  }
+  const meta = extractMeta(html, baseURL);
+  return { meta, images };
+}
+function hasViewerClues(html) {
+  const hasJuicebox = /juicebox/i.test(html) || /\/juicebox\/xml\/field\/node\/\d+\/[a-z0-9_]+\/full/i.test(html);
+  const hasFieldNode = /id=["']field--node--\d+--[a-z0-9_-]+--full["']/i.test(html);
+  const hasJbStyles = /styles\/juicebox_(?:large|medium|small)\//i.test(html);
+  const hasNodeBody = /<body[^>]+class=["'][^"']*\bnode\b[^"']*["']/i.test(html);
+  const hasGalleryField = /field-name-(?:field_)?(?:pictures|images|image|post_pictures)\b/i.test(
+    html
+  );
+  return hasJuicebox || hasFieldNode || hasJbStyles || hasNodeBody || hasGalleryField;
+}
+var ViewerAPI = {
+  async resolveViewer(http, baseURL, urlOrSlug, opts = {}) {
+    const url = buildViewerUrl(baseURL, urlOrSlug);
+    const html = await fetchHtml(http, url);
+    const parsedVideo = parseVideoFromHtml(html, baseURL);
+    if (parsedVideo && parsedVideo.sources?.length) {
+      const meta = tryParseRichMeta(html, baseURL, url);
+      return {
+        kind: "video",
+        meta,
+        video: {
+          poster: parsedVideo.poster ? proxyImgMaybe(parsedVideo.poster, opts) : void 0,
+          sources: parsedVideo.sources.map((s) => ({
+            ...s,
+            proxied: proxyVidMaybe(s.url, opts)
+          }))
+        }
+      };
+    }
+    if (hasViewerClues(html)) {
+      const imgRes = parseImagesWithBackoff(html, baseURL);
+      const images = (imgRes.images || []).map((im) => {
+        const preferred = im.original || im.large || im.medium || im.small || im.thumb || "";
+        return { ...im, proxied: proxyImgMaybe(preferred, opts) };
+      });
+      return {
+        kind: "images",
+        meta: imgRes.meta,
+        images
+      };
+    }
+    return { kind: "other", meta: extractMeta(html, baseURL) };
+  },
+  async resolveSmart(http, baseURL, urlOrSlug, opts = {}) {
+    const url = buildViewerUrl(baseURL, urlOrSlug);
+    const u = new URL(url);
+    const path = u.pathname;
+    const html = await fetchHtml(http, url);
+    const parsedVideo = parseVideoFromHtml(html, baseURL);
+    if (parsedVideo && parsedVideo.sources?.length) {
+      const meta = tryParseRichMeta(html, baseURL, url);
+      const viewer = {
+        kind: "video",
+        meta,
+        video: {
+          poster: parsedVideo.poster ? proxyImgMaybe(parsedVideo.poster, opts) : void 0,
+          sources: parsedVideo.sources.map((s) => ({
+            ...s,
+            proxied: proxyVidMaybe(s.url, opts)
+          }))
+        }
+      };
+      let recommendations;
+      try {
+        const recPage = parseHubListing(html, baseURL, 0);
+        if (recPage?.items?.length) {
+          recommendations = recPage.items.map((it) => ({
+            ...it,
+            proxiedThumb: it.thumb ? proxyImgMaybe(it.thumb, opts) : void 0
+          }));
+        }
+      } catch {
+      }
+      const data = { absoluteUrl: url, path, viewer };
+      data.recommendations = recommendations;
+      return { route: "viewer", data };
+    }
+    if (hasViewerClues(html)) {
+      const { meta, images } = parseImagesWithBackoff(html, baseURL);
+      const mapped = (images || []).map((im) => {
+        const preferred = im.original || im.large || im.medium || im.small || im.thumb || "";
+        return { ...im, proxied: proxyImgMaybe(preferred, opts) };
+      });
+      const viewer = { kind: "images", meta, images: mapped };
+      let recommendations;
+      try {
+        const recPage = parseHubListing(html, baseURL, 0);
+        if (recPage?.items?.length) {
+          recommendations = recPage.items.map((it) => ({
+            ...it,
+            proxiedThumb: it.thumb ? proxyImgMaybe(it.thumb, opts) : void 0
+          }));
+        }
+      } catch {
+      }
+      const data = { absoluteUrl: url, path, viewer };
+      data.recommendations = recommendations;
+      return { route: "viewer", data };
+    }
+    const page = await listings_exports.listByPath(http, baseURL, path, 0);
+    return { route: "listing", data: { ...page, absoluteUrl: url, path } };
+  }
+};
+function extractText(html, re) {
+  const m = html.match(re);
+  return m ? m[1].replace(/<[^>]*>/g, "").trim() : "";
+}
+function grabLinksByLabel(html, baseURL, label) {
+  const esc = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const reLbl = new RegExp(
+    `<(?:h3|div)[^>]*class=["'][^"']*field-label[^"']*["'][^>]*>\\s*${esc}\\s*:?\\s*<\\/[^>]+>`,
+    "i"
+  );
+  const idx = html.search(reLbl);
+  if (idx < 0) return [];
+  const open = html.lastIndexOf("<div", idx);
+  const close = html.indexOf("</div>", idx);
+  if (open < 0 || close < 0) return [];
+  const block = html.slice(open, close + 6);
+  const out = [];
+  const reA = /<a[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi;
+  for (let m; m = reA.exec(block); ) {
+    out.push({
+      title: m[2].replace(/<[^>]*>/g, "").trim(),
+      url: absolutize2(m[1], baseURL)
+    });
+  }
+  return out;
+}
+function grabLinks(html, blockRe, baseURL) {
+  const alt = `(?:${blockRe.source})`;
+  const reDiv = new RegExp(
+    `<div[^>]*class=["'][^"']*\\bfield\\b[^"']*\\b${alt}\\b[^"']*["'][^>]*>([\\s\\S]*?)<\\/div>`,
+    "i"
+  );
+  const m = reDiv.exec(html);
+  if (!m) return [];
+  const block = m[1];
+  const arr = [];
+  const reA = /<a[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi;
+  for (let x; x = reA.exec(block); ) {
+    arr.push({
+      title: x[2].replace(/<[^>]*>/g, "").trim(),
+      url: absolutize2(x[1], baseURL)
+    });
+  }
+  return arr;
+}
+function extractMeta(html, baseURL) {
+  const title = extractText(html, /<h1[^>]*id=["']page-title["'][^>]*>([\s\S]*?)<\/h1>/i) || extractText(html, /<title>([\s\S]*?)<\/title>/i);
+  const breadcrumbs = [];
+  const reCrumb = /<span[^>]*typeof=["']v:Breadcrumb["'][^>]*>[\s\S]*?<a[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>[\s\S]*?<\/span>/gi;
+  for (let m; m = reCrumb.exec(html); ) {
+    breadcrumbs.push({
+      title: m[2].replace(/<[^>]*>/g, "").trim(),
+      url: absolutize2(m[1], baseURL)
+    });
+  }
+  let authors = grabLinks(
+    html,
+    /field-name-field-vd-authors|field-name-field-authors|field-name-field-au/i,
+    baseURL
+  ) || [];
+  if (authors.length === 0) {
+    authors = grabLinksByLabel(html, baseURL, "Author");
+  }
+  const sections = grabLinks(
+    html,
+    /field-name-field-vd-group|field-name-field-group|field-name-field-sections/i,
+    baseURL
+  );
+  const tags = grabLinks(html, /field-name-field-(?:vd-)?tags|field-name-field-category/i, baseURL) || [];
+  const meta = {
+    title,
+    breadcrumbs,
+    authors,
+    sections,
+    tags,
+    nodeId: "",
+    fieldSys: {},
+    kind: "viewer"
+  };
+  return meta;
+}
+
+// src/multporn.ts
+var MultpornClient = class {
+  http;
+  baseURL;
+  constructor(opts = {}) {
+    this.baseURL = (opts.baseURL ?? "https://multporn.net").replace(/\/+$/, "");
+    this.http = new HttpClient({ ...opts, baseURL: this.baseURL });
+  }
+  latest(page = 0, params) {
+    return listings_exports.latest(this.http, this.baseURL, page, params);
+  }
+  listByPath(path, page = 0, params) {
+    return listings_exports.listByPath(this.http, this.baseURL, path, page, params);
+  }
+  search(query, page = 0) {
+    return search_exports.search(this.http, this.baseURL, query, page);
+  }
+  getPost(urlOrSlug) {
+    return posts_exports.getPost(this.http, this.baseURL, urlOrSlug);
+  }
+  resolve(urlOrSlug, opts = {}) {
+    return ViewerAPI.resolveViewer(this.http, this.baseURL, urlOrSlug, opts);
+  }
+  resolveSmart(urlOrSlug, opts = {}) {
+    return ViewerAPI.resolveSmart(this.http, this.baseURL, urlOrSlug, opts);
+  }
+  updates(params = {}) {
+    return updates_exports.updates(this.http, this.baseURL, params);
+  }
+  viewUpdates(viewName, params) {
+    return this.updates({ ...params ?? {}, view_name: viewName });
+  }
+  updatesNewMini(p) {
+    return updates_exports.updates(this.http, this.baseURL, { ...p ?? {}, view_name: "new_mini" });
+  }
+  userUploadFront(p) {
+    return updates_exports.updates(this.http, this.baseURL, {
+      ...p ?? {},
+      view_name: "user_upload_front"
+    });
+  }
+  updatedManga(p) {
+    return updates_exports.updates(this.http, this.baseURL, {
+      ...p ?? {},
+      view_name: "updated_manga"
+    });
+  }
+  updatedMangaPromoted(p) {
+    return updates_exports.updates(this.http, this.baseURL, {
+      ...p ?? {},
+      view_name: "updated_manga_promoted"
+    });
+  }
+  updatedGames(p) {
+    return updates_exports.updates(this.http, this.baseURL, {
+      ...p ?? {},
+      view_name: "updated_games"
+    });
+  }
+  randomTopComics(p) {
+    return updates_exports.updates(this.http, this.baseURL, {
+      ...p ?? {},
+      view_name: "random_top_comics"
+    });
+  }
+  topRandomCharacters(p) {
+    return updates_exports.updates(this.http, this.baseURL, {
+      ...p ?? {},
+      view_name: "top_random_characters"
+    });
+  }
+  alphabetLetters(section) {
+    return alphabet_exports.alphabetLetters(this.http, this.baseURL, section);
+  }
+  alphabet(section, letter, page = 0) {
+    return alphabet_exports.alphabetItems(this.http, this.baseURL, section, letter, page);
+  }
+};
+export {
+  HttpClient,
+  HttpError,
+  MultpornClient,
+  defaultRetryPolicy,
+  parseHubListing as parseListing,
+  parsePost
+};
+//# sourceMappingURL=index.js.map