komado 0.1.0

package/dist/render/detect.js

@@ -0,0 +1,86 @@
+import { execFileSync } from "node:child_process";
+let cached = null;
+function detectCapabilities() {
+  if (cached) return cached;
+  const env = process.env;
+  const term = env.TERM || "";
+  const termProgram = env.TERM_PROGRAM || "";
+  const kitty = !!env.KITTY_WINDOW_ID || term.includes("kitty") || termProgram === "ghostty" || termProgram === "WezTerm";
+  const sixel = /sixel/i.test(env.KOMADO_CAPS || "") || term === "foot" || term.includes("foot") || term.includes("mlterm");
+  const truecolor = env.COLORTERM === "truecolor" || env.COLORTERM === "24bit";
+  let chafa = false;
+  let chafaVersion = null;
+  try {
+    const out = execFileSync("chafa", ["--version"], {
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString();
+    chafa = true;
+    chafaVersion = (out.match(/version\s+([\d.]+)/i) || [])[1] || "unknown";
+  } catch {
+  }
+  cached = { term, termProgram, kitty, sixel, truecolor, chafa, chafaVersion };
+  return cached;
+}
+function pickInlineBackend(config, caps = detectCapabilities()) {
+  const pref = config?.renderer || "auto";
+  if (pref === "halfblock") return "halfblock";
+  if (pref === "chafa") return caps.chafa ? "chafa-symbols" : "halfblock";
+  return caps.chafa ? "chafa-symbols" : "halfblock";
+}
+const RENDERER_CYCLE = ["auto", "halfblock", "chafa"];
+async function probeTerminal({ timeoutMs = 350 } = {}) {
+  const { stdin, stdout } = process;
+  if (!stdout.isTTY || !stdin.isTTY) {
+    return { queried: false, sixel: false, kitty: false, cellW: null, cellH: null };
+  }
+  return new Promise((resolve) => {
+    let buf = "";
+    const prevRaw = stdin.isRaw;
+    const onData = (d) => {
+      buf += d.toString("latin1");
+    };
+    try {
+      stdin.setRawMode(true);
+    } catch {
+    }
+    stdin.resume();
+    stdin.on("data", onData);
+    stdout.write("\x1B_Gi=31,s=1,v=1,a=q,t=d,f=24;AAAA\x1B\\\x1B[16t\x1B[14t\x1B[18t\x1B[c");
+    setTimeout(() => {
+      stdin.removeListener("data", onData);
+      try {
+        stdin.setRawMode(prevRaw);
+      } catch {
+      }
+      stdin.pause();
+      const kitty = /\x1b_G[^\x1b]*;OK/.test(buf);
+      const da = buf.match(/\x1b\[\?([0-9;]+)c/);
+      const cell = buf.match(/\x1b\[6;(\d+);(\d+)t/);
+      const areaPx = buf.match(/\x1b\[4;(\d+);(\d+)t/);
+      const areaCh = buf.match(/\x1b\[8;(\d+);(\d+)t/);
+      const sixel = da ? da[1].split(";").includes("4") : false;
+      let cellW = null;
+      let cellH = null;
+      if (cell) {
+        cellH = Number(cell[1]);
+        cellW = Number(cell[2]);
+      } else if (areaPx && areaCh) {
+        const cols = Number(areaCh[2]);
+        const rows = Number(areaCh[1]);
+        if (cols > 0 && rows > 0) {
+          cellW = Number(areaPx[2]) / cols;
+          cellH = Number(areaPx[1]) / rows;
+        }
+      }
+      if (!(cellW > 2 && cellW < 64)) cellW = null;
+      if (!(cellH > 2 && cellH < 96)) cellH = null;
+      resolve({ queried: true, sixel, kitty, cellW, cellH });
+    }, timeoutMs);
+  });
+}
+export {
+  RENDERER_CYCLE,
+  detectCapabilities,
+  pickInlineBackend,
+  probeTerminal
+};

package/dist/render/halfblock.js

@@ -0,0 +1,42 @@
+import sharp from "sharp";
+const ESC = "\x1B";
+const RESET = `${ESC}[0m`;
+async function renderHalfBlock(buffer, { cols = 80 } = {}) {
+  const targetWidth = Math.max(1, Math.min(Math.floor(cols), 400));
+  const { data, info } = await sharp(buffer).resize({ width: targetWidth, fit: "inside", withoutEnlargement: false }).flatten({ background: "#ffffff" }).raw().toBuffer({ resolveWithObject: true });
+  const { width, height, channels } = info;
+  const px = (x, y) => {
+    const i = (y * width + x) * channels;
+    if (channels === 1) {
+      const v = data[i];
+      return [v, v, v];
+    }
+    return [data[i], data[i + 1], data[i + 2]];
+  };
+  const lines = [];
+  for (let y = 0; y < height; y += 2) {
+    let line = "";
+    let lastFg = null;
+    let lastBg = null;
+    for (let x = 0; x < width; x++) {
+      const [tr, tg, tb] = px(x, y);
+      const [br, bg, bb] = y + 1 < height ? px(x, y + 1) : [tr, tg, tb];
+      const fg = `${tr};${tg};${tb}`;
+      const bgc = `${br};${bg};${bb}`;
+      if (fg !== lastFg) {
+        line += `${ESC}[38;2;${fg}m`;
+        lastFg = fg;
+      }
+      if (bgc !== lastBg) {
+        line += `${ESC}[48;2;${bgc}m`;
+        lastBg = bgc;
+      }
+      line += "\u2580";
+    }
+    lines.push(line + RESET);
+  }
+  return { lines, cols: width, rows: lines.length };
+}
+export {
+  renderHalfBlock
+};

package/dist/render/image.js

@@ -0,0 +1,23 @@
+import sharp from "sharp";
+import { renderHalfBlock } from "./halfblock.js";
+import { renderChafaSymbols } from "./chafa.js";
+import { logger } from "../lib/logger.js";
+async function imageSize(buffer) {
+  const { width = 1, height = 1 } = await sharp(buffer).metadata();
+  return { width, height };
+}
+async function renderInline(buffer, { cols = 80, backend = "halfblock" } = {}) {
+  if (backend === "chafa-symbols") {
+    try {
+      return await renderChafaSymbols(buffer, { cols });
+    } catch (err) {
+      logger.warn("chafa render failed, falling back to half-block", err);
+      return renderHalfBlock(buffer, { cols });
+    }
+  }
+  return renderHalfBlock(buffer, { cols });
+}
+export {
+  imageSize,
+  renderInline
+};

package/dist/render/sixel.js

@@ -0,0 +1,88 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import sharp from "sharp";
+import { withTempImage } from "./chafa.js";
+const execFileAsync = promisify(execFile);
+const DEFAULT_CELL_W = 10;
+const DEFAULT_CELL_H = 20;
+async function encodePixels(buffer, { format = "sixel" } = {}) {
+  const { stdout } = await withTempImage(
+    buffer,
+    (file) => execFileAsync(
+      "chafa",
+      ["--format", format, "--exact-size", "on", "--font-ratio", "1/1", "--animate", "off", file],
+      { maxBuffer: 256 * 1024 * 1024, encoding: "buffer" }
+    )
+  );
+  return stdout;
+}
+async function scalePage(buffer, { cols, cellW }) {
+  const viewW = Math.max(1, Math.round(cols * (cellW || DEFAULT_CELL_W)));
+  const scaled = await sharp(buffer).resize({ width: viewW }).png().toBuffer();
+  const meta = await sharp(scaled).metadata();
+  return { buffer: scaled, width: meta.width || viewW, height: meta.height || 0 };
+}
+async function prepareImage(buffer, { mode, cols, rows, scroll = 0, cellW, cellH, scaled = null }) {
+  const ch = cellH || DEFAULT_CELL_H;
+  const viewW = Math.max(1, Math.round(cols * (cellW || DEFAULT_CELL_W)));
+  const viewH = Math.max(1, Math.round(rows * ch));
+  if (mode === "fit") {
+    const out2 = await sharp(buffer).resize({ width: viewW, height: viewH, fit: "inside", withoutEnlargement: false }).png().toBuffer();
+    const meta = await sharp(out2).metadata();
+    return { buffer: out2, maxScroll: 0, scroll: 0, imageRows: Math.round((meta.height || viewH) / ch) };
+  }
+  const page = scaled || await scalePage(buffer, { cols, cellW });
+  const scaledH = page.height || viewH;
+  const maxScrollPx = Math.max(0, scaledH - viewH);
+  const maxScroll = Math.ceil(maxScrollPx / ch);
+  const clamped = Math.max(0, Math.min(scroll, maxScroll));
+  const top = Math.min(maxScrollPx, clamped * ch);
+  const cropH = Math.max(1, Math.min(viewH, scaledH - top));
+  const out = await sharp(page.buffer).extract({ left: 0, top: Math.round(top), width: page.width, height: Math.round(cropH) }).png().toBuffer();
+  return { buffer: out, maxScroll, scroll: clamped, imageRows: Math.round(cropH / ch) };
+}
+const BAND_PX = 6;
+function parseSixelPage(raw) {
+  const dcsStart = raw.indexOf("\x1BP");
+  if (dcsStart < 0) throw new Error("no sixel DCS found in encoder output");
+  const stEnd = raw.indexOf("\x1B\\", dcsStart);
+  const payload = raw.slice(dcsStart, stEnd < 0 ? void 0 : stEnd);
+  const qi = payload.indexOf("q");
+  const intro = qi >= 0 ? payload.slice(0, qi + 1) : "\x1BPq";
+  let rest = payload.slice(intro.length);
+  const rasterM = rest.match(/^"(\d+);(\d+);(\d+);(\d+)/);
+  const raster = rasterM ? { pan: rasterM[1], pad: rasterM[2], ph: rasterM[3] } : { pan: "1", pad: "1", ph: "0" };
+  if (rasterM) rest = rest.slice(rasterM[0].length);
+  const palette = rest.match(/^((?:#\d+;2;\d+;\d+;\d+)*)/)?.[1] ?? "";
+  const rawBands = rest.slice(palette.length).split("-");
+  while (rawBands.length && rawBands[rawBands.length - 1] === "") rawBands.pop();
+  let carry = "0";
+  const bands = rawBands.map((b) => {
+    const fixed = b.startsWith("#") ? b : `#${carry}${b}`;
+    const sels = fixed.match(/#(\d+)/g);
+    if (sels) carry = sels[sels.length - 1].slice(1);
+    return fixed;
+  });
+  return { intro, raster, palette, bands, height: bands.length * BAND_PX };
+}
+async function encodeSixelPage(buffer) {
+  const raw = (await encodePixels(buffer, { format: "sixel" })).toString("latin1");
+  return parseSixelPage(raw);
+}
+function sliceSixelPage(page, { startBand, numBands }) {
+  const total = page.bands.length;
+  const k = Math.max(1, Math.min(numBands, total));
+  const start = Math.max(0, Math.min(startBand, total - k));
+  const body = page.bands.slice(start, start + k).join("-");
+  const r = page.raster;
+  const str = `${page.intro}"${r.pan};${r.pad};${r.ph};${k * BAND_PX}${page.palette}${body}\x1B\\`;
+  return { sixel: Buffer.from(str, "latin1"), startBand: start, bands: total };
+}
+export {
+  encodePixels,
+  encodeSixelPage,
+  parseSixelPage,
+  prepareImage,
+  scalePage,
+  sliceSixelPage
+};

package/dist/sixel-reader.js

@@ -0,0 +1,309 @@
+import { getSource } from "./sources/index.js";
+import { setProgress } from "./state/store.js";
+import { chapterLabel } from "./domain/shape.js";
+import { encodePixels, prepareImage, scalePage, encodeSixelPage, sliceSixelPage } from "./render/sixel.js";
+import { logger } from "./lib/logger.js";
+const ESC = "\x1B";
+const SYNC_BEGIN = Buffer.from(`${ESC}[?2026h`, "latin1");
+const SYNC_END = Buffer.from(`${ESC}[?2026l`, "latin1");
+async function runViewer({ sourceId, manga, chapters, chapterIndex, startPage = 0, caps = {} }) {
+  const source = getSource(sourceId);
+  const { stdin, stdout } = process;
+  const format = caps.kitty ? "kitty" : "sixel";
+  let ci = chapterIndex;
+  let pi = startPage;
+  let scroll = 0;
+  let fitWidth = true;
+  let pages = null;
+  let maxScroll = 0;
+  const cellH = caps.cellH || 20;
+  const gcd = (a, b) => b ? gcd(b, a % b) : a;
+  const slotBands = cellH / gcd(6, cellH);
+  const slotCells = 6 / gcd(6, cellH);
+  const deltaScroll = format === "sixel" && process.env.KOMADO_SCROLL_DELTA === "1";
+  const scrollStep = deltaScroll ? slotCells : 2;
+  let shownTop = null;
+  let shownSig = null;
+  let rawKey = null;
+  let rawBuf = null;
+  let scaledKey = null;
+  let scaledBuf = null;
+  let sixelKey = null;
+  let sixelPg = null;
+  let inputSeq = 0;
+  let drawing = false;
+  let pending = false;
+  let pendingFullClear = false;
+  const size = () => ({
+    cols: Math.max(20, stdout.columns || 80),
+    rows: Math.max(6, stdout.rows || 24)
+  });
+  async function ensurePages() {
+    if (pages) return;
+    pages = await source.getPages(chapters[ci].id);
+    pi = Math.max(0, Math.min(pi, pages.length - 1));
+  }
+  async function pageBuffer() {
+    const key = `${ci}:${pi}`;
+    if (rawKey === key && rawBuf) return rawBuf;
+    rawBuf = await source.loadPageBuffer(pages[pi]);
+    rawKey = key;
+    return rawBuf;
+  }
+  async function scaledPage(cols) {
+    const key = `${ci}:${pi}:${cols}:${caps.cellW || ""}`;
+    if (scaledKey === key && scaledBuf) return scaledBuf;
+    scaledBuf = await scalePage(await pageBuffer(), { cols, cellW: caps.cellW });
+    scaledKey = key;
+    return scaledBuf;
+  }
+  async function sixelPageCached(cols) {
+    const key = `${ci}:${pi}:${cols}:${caps.cellW || ""}`;
+    if (sixelKey === key && sixelPg) return sixelPg;
+    const scaled = await scaledPage(cols);
+    sixelPg = await encodeSixelPage(scaled.buffer);
+    sixelKey = key;
+    return sixelPg;
+  }
+  function statusBar() {
+    const { cols } = size();
+    const left = `${manga.title} \xB7 ${chapterLabel(chapters[ci])} \xB7 ${pi + 1}/${pages ? pages.length : "?"}${fitWidth ? "" : " \xB7 fit"}`;
+    const right = "\u2190\u2192 page \xB7 \u2191\u2193 pan \xB7 N/P ch \xB7 f fit \xB7 q back";
+    const gap = Math.max(1, cols - left.length - right.length - 2);
+    return ` ${left}${" ".repeat(gap)}${right} `.slice(0, cols);
+  }
+  async function draw({ fullClear = false } = {}) {
+    const seq = inputSeq;
+    const { cols, rows } = size();
+    const imgRows = rows - 1;
+    try {
+      await ensurePages();
+      if (!pages.length) throw new Error("This chapter has no hosted pages.");
+      let frame = null;
+      let imageRows = imgRows;
+      let mScroll = 0;
+      let sScroll = scroll;
+      if (fitWidth && format === "sixel") {
+        const page = await sixelPageCached(cols);
+        const viewBands = Math.max(1, Math.floor(imgRows * cellH / 6));
+        const maxStart = Math.max(0, page.bands.length - viewBands);
+        let topBand = Math.round(scroll * cellH / 6);
+        if (deltaScroll) topBand = Math.round(topBand / slotBands) * slotBands;
+        topBand = Math.max(0, Math.min(topBand, maxStart));
+        imageRows = Math.round(viewBands * 6 / cellH);
+        mScroll = maxStart * 6 / cellH;
+        sScroll = topBand * 6 / cellH;
+        const geomSig = `${ci}:${pi}:${cols}:${imgRows}`;
+        const reuse = !fullClear && shownTop !== null && shownSig === geomSig;
+        const delta = reuse ? topBand - shownTop : 0;
+        if (reuse && delta === 0) {
+          frame = null;
+        } else if (deltaScroll && reuse && delta !== 0 && Math.abs(delta) % slotBands === 0 && Math.abs(delta) < viewBands) {
+          frame = buildDeltaFrame(page, { from: shownTop, to: topBand, viewBands, imgRows, rows });
+        } else {
+          const win = sliceSixelPage(page, { startBand: topBand, numBands: viewBands }).sixel;
+          frame = composeFull(win, { fullClear, imageRows, imgRows, rows });
+        }
+        shownTop = topBand;
+        shownSig = geomSig;
+      } else {
+        shownTop = null;
+        let prepared;
+        if (fitWidth) {
+          const page = await scaledPage(cols);
+          prepared = await prepareImage(null, {
+            mode: "width",
+            cols,
+            rows: imgRows,
+            scroll,
+            cellW: caps.cellW,
+            cellH: caps.cellH,
+            scaled: page
+          });
+        } else {
+          prepared = await prepareImage(await pageBuffer(), {
+            mode: "fit",
+            cols,
+            rows: imgRows,
+            cellW: caps.cellW,
+            cellH: caps.cellH
+          });
+        }
+        imageRows = prepared.imageRows;
+        mScroll = prepared.maxScroll;
+        sScroll = prepared.scroll;
+        const sig = `f:${ci}:${pi}:${sScroll}:${cols}:${imgRows}`;
+        if (fullClear || sig !== shownSig) {
+          const buf = await encodePixels(prepared.buffer, { format });
+          frame = composeFull(buf, { fullClear: fullClear || !fitWidth, imageRows, imgRows, rows });
+          shownSig = sig;
+        }
+      }
+      if (seq === inputSeq) {
+        maxScroll = mScroll;
+        scroll = Math.max(0, Math.min(sScroll, mScroll));
+      }
+      if (frame) stdout.write(Buffer.concat([SYNC_BEGIN, frame, SYNC_END]));
+      setProgress(manga.key, {
+        source: sourceId,
+        mangaId: manga.id,
+        mangaTitle: manga.title,
+        chapterId: chapters[ci].id,
+        chapterNumber: chapters[ci].number,
+        page: pi
+      });
+      if (pi === pages.length - 1 && source.syncChapterRead) {
+        source.syncChapterRead(manga.id, chapters[ci].id);
+      }
+    } catch (err) {
+      logger.warn("viewer draw failed", err);
+      stdout.write(`${ESC}[2J${ESC}[H${ESC}[0m`);
+      stdout.write(`Error: ${err.message}\r
+\r
+N/P chapter \xB7 q back\r
+`);
+    }
+  }
+  function composeFull(sixelBuf, { fullClear, imageRows, imgRows, rows }) {
+    const prefix = fullClear ? `${ESC}[2J${ESC}[H` : `${ESC}[H`;
+    let suffix = imageRows < imgRows ? `${ESC}[${imageRows + 1};1H${ESC}[0J` : "";
+    suffix += `${ESC}[${rows};1H${ESC}[7m${statusBar()}${ESC}[0m`;
+    return Buffer.concat([Buffer.from(prefix, "latin1"), sixelBuf, Buffer.from(suffix, "latin1")]);
+  }
+  function buildDeltaFrame(page, { from, to, viewBands, imgRows, rows }) {
+    const delta = to - from;
+    const dc = Math.round(Math.abs(delta) * 6 / cellH);
+    const region = `${ESC}[1;${imgRows}r`;
+    const reset = `${ESC}[r`;
+    const status = `${ESC}[${rows};1H${ESC}[7m${statusBar()}${ESC}[0m`;
+    let head;
+    let strip;
+    if (delta > 0) {
+      head = `${region}${ESC}[${imgRows};1H${"\n".repeat(dc)}${reset}${ESC}[${imgRows - dc + 1};1H`;
+      strip = sliceSixelPage(page, { startBand: from + viewBands, numBands: delta }).sixel;
+    } else {
+      head = `${region}${ESC}[1;1H${`${ESC}M`.repeat(dc)}${reset}${ESC}[1;1H`;
+      strip = sliceSixelPage(page, { startBand: to, numBands: -delta }).sixel;
+    }
+    return Buffer.concat([Buffer.from(head, "latin1"), strip, Buffer.from(status, "latin1")]);
+  }
+  function schedule({ fullClear = false } = {}) {
+    if (fullClear) pendingFullClear = true;
+    if (drawing) {
+      pending = true;
+      return;
+    }
+    drawing = true;
+    (async () => {
+      try {
+        do {
+          pending = false;
+          const fc = pendingFullClear;
+          pendingFullClear = false;
+          await draw({ fullClear: fc });
+        } while (pending);
+      } finally {
+        drawing = false;
+      }
+    })();
+  }
+  function changeChapter(delta) {
+    const next = ci + delta;
+    if (next < 0 || next >= chapters.length) return false;
+    ci = next;
+    pi = 0;
+    scroll = 0;
+    shownTop = null;
+    pages = null;
+    return true;
+  }
+  function nextPage() {
+    if (pages && pi < pages.length - 1) {
+      pi += 1;
+      scroll = 0;
+      shownTop = null;
+    } else changeChapter(1);
+  }
+  function prevPage() {
+    if (pi > 0) {
+      pi -= 1;
+      scroll = 0;
+      shownTop = null;
+    } else changeChapter(-1);
+  }
+  const prevRaw = stdin.isRaw;
+  let onKey;
+  const keepAlive = setInterval(() => {
+  }, 1 << 30);
+  const onResize = () => {
+    inputSeq += 1;
+    schedule({ fullClear: true });
+  };
+  try {
+    await draw({ fullClear: true });
+    stdout.on("resize", onResize);
+    await new Promise((resolve) => {
+      onKey = (data) => {
+        const k = data.toString("latin1");
+        const pageStep = Math.max(1, size().rows - 2);
+        if (k === "q" || k === ESC) {
+          resolve();
+          return;
+        }
+        if (k === "n" || k === " ") {
+          if (fitWidth && scroll < maxScroll) scroll = Math.min(maxScroll, scroll + pageStep);
+          else nextPage();
+        } else if (k === "p") {
+          if (fitWidth && scroll > 0) scroll = Math.max(0, scroll - pageStep);
+          else prevPage();
+        } else if (k === "d" || k === `${ESC}[C`) {
+          nextPage();
+        } else if (k === "a" || k === `${ESC}[D`) {
+          prevPage();
+        } else if (k === "j" || k === `${ESC}[B`) {
+          scroll = Math.min(maxScroll, scroll + scrollStep);
+        } else if (k === "k" || k === `${ESC}[A`) {
+          scroll = Math.max(0, scroll - scrollStep);
+        } else if (k === "N") {
+          changeChapter(1);
+        } else if (k === "P") {
+          changeChapter(-1);
+        } else if (k === "f") {
+          fitWidth = !fitWidth;
+          scroll = 0;
+          shownTop = null;
+          shownSig = null;
+        } else if (k === "g") {
+          scroll = 0;
+        } else if (k === "G") {
+          scroll = maxScroll;
+        } else {
+          return;
+        }
+        inputSeq += 1;
+        schedule();
+      };
+      stdin.removeAllListeners("data");
+      try {
+        stdin.setRawMode(true);
+      } catch {
+      }
+      stdin.resume();
+      stdin.ref?.();
+      stdin.on("data", onKey);
+    });
+  } finally {
+    clearInterval(keepAlive);
+    stdout.removeListener("resize", onResize);
+    if (onKey) stdin.removeListener("data", onKey);
+    try {
+      stdin.setRawMode(prevRaw);
+    } catch {
+    }
+    stdout.write(`${ESC}[2J${ESC}[H${ESC}[0m`);
+  }
+  return { name: "manga", params: { sourceId, manga } };
+}
+export {
+  runViewer
+};

package/dist/sources/index.js

@@ -0,0 +1,17 @@
+import * as mangadex from "./mangadex/index.js";
+import * as local from "./local/index.js";
+const sources = { mangadex, local };
+function getSource(sourceId) {
+  const source = sources[sourceId];
+  if (!source) throw new Error(`Unknown source: ${sourceId}`);
+  return source;
+}
+const SOURCES = sources;
+const REMOTE_SOURCES = Object.values(sources).filter((s) => s.remote);
+const LOCAL_SOURCES = Object.values(sources).filter((s) => !s.remote);
+export {
+  LOCAL_SOURCES,
+  REMOTE_SOURCES,
+  SOURCES,
+  getSource
+};

package/dist/sources/local/archive.js

@@ -0,0 +1,68 @@
+import AdmZip from "adm-zip";
+import { readFile } from "node:fs/promises";
+import { naturalSort } from "../../lib/natsort.js";
+const IMAGE_RE = /\.(jpe?g|png|gif|webp|bmp|avif)$/i;
+const isArchive = (name) => /\.(cbz|zip|cbr|rar)$/i.test(name);
+const isRar = (name) => /\.(cbr|rar)$/i.test(name);
+const zipCache = /* @__PURE__ */ new Map();
+function openZip(filePath) {
+  let zip = zipCache.get(filePath);
+  if (!zip) {
+    zip = new AdmZip(filePath);
+    zipCache.set(filePath, zip);
+    if (zipCache.size > 8) zipCache.delete(zipCache.keys().next().value);
+  }
+  return zip;
+}
+function listZipImages(filePath) {
+  return naturalSort(
+    openZip(filePath).getEntries().filter((e) => !e.isDirectory && IMAGE_RE.test(e.entryName)).map((e) => e.entryName)
+  );
+}
+function readZipEntry(filePath, entryName) {
+  const entry = openZip(filePath).getEntry(entryName);
+  if (!entry) throw new Error(`Entry not found in archive: ${entryName}`);
+  return entry.getData();
+}
+let unrarPromise = null;
+const getUnrar = () => unrarPromise ??= import("node-unrar-js");
+const rarCache = /* @__PURE__ */ new Map();
+async function openRar(filePath) {
+  let extractor = rarCache.get(filePath);
+  if (!extractor) {
+    const { createExtractorFromData } = await getUnrar();
+    const buf = await readFile(filePath);
+    extractor = await createExtractorFromData({
+      data: buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)
+    });
+    rarCache.set(filePath, extractor);
+    if (rarCache.size > 4) rarCache.delete(rarCache.keys().next().value);
+  }
+  return extractor;
+}
+async function listRarImages(filePath) {
+  const extractor = await openRar(filePath);
+  const names = [];
+  for (const header of extractor.getFileList().fileHeaders) {
+    if (!header.flags.directory && IMAGE_RE.test(header.name)) names.push(header.name);
+  }
+  return naturalSort(names);
+}
+async function readRarEntry(filePath, entryName) {
+  const extractor = await openRar(filePath);
+  const [file] = [...extractor.extract({ files: [entryName] }).files];
+  if (!file?.extraction) throw new Error(`Failed to extract from RAR: ${entryName}`);
+  return Buffer.from(file.extraction);
+}
+async function listArchiveImages(filePath) {
+  return isRar(filePath) ? listRarImages(filePath) : listZipImages(filePath);
+}
+async function readArchiveEntry(filePath, entryName) {
+  return isRar(filePath) ? readRarEntry(filePath, entryName) : readZipEntry(filePath, entryName);
+}
+export {
+  isArchive,
+  isRar,
+  listArchiveImages,
+  readArchiveEntry
+};