coomer-downloader 3.2.0 → 3.4.0

package/dist/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S node --no-warnings=ExperimentalWarning
 
 // src/index.ts
 import process2 from "node:process";
@@ -7,20 +7,45 @@ import process2 from "node:process";
 import * as cheerio from "cheerio";
 import { fetch } from "undici";
 
-// src/utils/file.ts
+// src/services/file.ts
 import os from "node:os";
 import path from "node:path";
 
-// src/utils/filters.ts
-function isImage(name) {
-  return /\.(jpg|jpeg|png|gif|bmp|tiff|webp|avif)$/i.test(name);
-}
-function isVideo(name) {
-  return /\.(mp4|m4v|avi|mov|mkv|webm|flv|wmv|mpeg|mpg|3gp)$/i.test(name);
+// src/logger/index.ts
+import pino from "pino";
+var logger = pino(
+  {
+    level: "debug"
+  },
+  pino.destination({
+    dest: "./debug.log",
+    append: false,
+    sync: true
+  })
+);
+var logger_default = logger;
+
+// src/utils/duplicates.ts
+function collectUniquesAndDuplicatesBy(xs, k) {
+  const seen = /* @__PURE__ */ new Set();
+  return xs.reduce(
+    (acc, item) => {
+      if (seen.has(item[k])) {
+        acc.duplicates.push(item);
+      } else {
+        seen.add(item[k]);
+        acc.uniques.push(item);
+      }
+      return acc;
+    },
+    { uniques: [], duplicates: [] }
+  );
 }
-function testMediaType(name, type) {
-  return type === "all" ? true : type === "image" ? isImage(name) : isVideo(name);
+function removeDuplicatesBy(xs, k) {
+  return [...new Map(xs.map((x) => [x[k], x])).values()];
 }
+
+// src/utils/filters.ts
 function includesAllWords(str, words) {
   if (!words.length) return true;
   return words.every((w) => str.includes(w));
@@ -35,10 +60,62 @@ function parseQuery(query) {
 function filterString(text, include, exclude) {
   return includesAllWords(text, parseQuery(include)) && includesNoWords(text, parseQuery(exclude));
 }
+function parseSizeValue(s) {
+  if (!s) return NaN;
+  const m = s.match(/^([0-9]+(?:\.[0-9]+)?)(b|kb|mb|gb)?$/i);
+  if (!m) return NaN;
+  const val = parseFloat(m[1]);
+  const unit = (m[2] || "b").toLowerCase();
+  const mult = unit === "kb" ? 1024 : unit === "mb" ? 1024 ** 2 : unit === "gb" ? 1024 ** 3 : 1;
+  return Math.floor(val * mult);
+}
+
+// src/utils/io.ts
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import { access, constants, unlink } from "node:fs/promises";
+import { pipeline } from "node:stream/promises";
+async function getFileSize(filepath) {
+  let size = 0;
+  if (fs.existsSync(filepath)) {
+    size = (await fs.promises.stat(filepath)).size || 0;
+  }
+  return size;
+}
+async function getFileHash(filepath) {
+  const hash = createHash("sha256");
+  const filestream = fs.createReadStream(filepath);
+  await pipeline(filestream, hash);
+  return hash.digest("hex");
+}
+function mkdir(filepath) {
+  if (!fs.existsSync(filepath)) {
+    fs.mkdirSync(filepath, { recursive: true });
+  }
+}
+async function deleteFile(path2) {
+  await access(path2, constants.F_OK);
+  await unlink(path2);
+}
+function sanitizeFilename(name) {
+  if (!name) return name;
+  return name.replace(/[<>"/\\|?*\x00-\x1F]/g, "-").replace(/\s+/g, " ").trim().replace(/[.]+$/, "");
+}
+
+// src/utils/mediatypes.ts
+function isImage(name) {
+  return /\.(jpg|jpeg|png|gif|bmp|tiff|webp|avif)$/i.test(name);
+}
+function isVideo(name) {
+  return /\.(mp4|m4v|avi|mov|mkv|webm|flv|wmv|mpeg|mpg|3gp)$/i.test(name);
+}
+function testMediaType(name, type) {
+  return type === "image" ? isImage(name) : isVideo(name);
+}
 
-// src/utils/file.ts
+// src/services/file.ts
 var CoomerFile = class _CoomerFile {
-  constructor(name, url, filepath, size, downloaded, content) {
+  constructor(name, url, filepath = "", size, downloaded = 0, content) {
     this.name = name;
     this.url = url;
     this.filepath = filepath;
@@ -46,7 +123,12 @@ var CoomerFile = class _CoomerFile {
     this.downloaded = downloaded;
     this.content = content;
   }
-  state = "pause";
+  active = false;
+  hash;
+  async getDownloadedSize() {
+    this.downloaded = await getFileSize(this.filepath);
+    return this;
+  }
   get textContent() {
     const text = `${this.name || ""} ${this.content || ""}`.toLowerCase();
     return text;
@@ -69,7 +151,8 @@ var CoomerFileList = class {
       this.dirPath = path.join(os.homedir(), path.join(dir, dirName));
     }
     this.files.forEach((file) => {
-      file.filepath = path.join(this.dirPath, file.name);
+      const safeName = sanitizeFilename(file.name) || file.name;
+      file.filepath = path.join(this.dirPath, safeName);
     });
     return this;
   }
@@ -87,6 +170,33 @@ var CoomerFileList = class {
     this.files = this.files.slice(n);
     return this;
   }
+  async calculateFileSizes() {
+    for (const file of this.files) {
+      await file.getDownloadedSize();
+    }
+    return this;
+  }
+  getActiveFiles() {
+    return this.files.filter((f) => f.active);
+  }
+  getDownloaded() {
+    return this.files.filter((f) => f.size && f.size <= f.downloaded);
+  }
+  async removeDuplicatesByHash() {
+    for (const file of this.files) {
+      file.hash = await getFileHash(file.filepath);
+    }
+    const { duplicates } = collectUniquesAndDuplicatesBy(this.files, "hash");
+    console.log({ duplicates });
+    logger_default.debug(`duplicates: ${JSON.stringify(duplicates)}`);
+    duplicates.forEach((f) => {
+      deleteFile(f.filepath);
+    });
+  }
+  removeURLDuplicates() {
+    this.files = removeDuplicatesBy(this.files, "url");
+    return this;
+  }
 };
 
 // src/api/bunkr.ts
@@ -139,67 +249,6 @@ async function getBunkrData(url) {
   return filelist;
 }
 
-// src/utils/downloader.ts
-import fs2 from "node:fs";
-import { Readable, Transform } from "node:stream";
-import { pipeline } from "node:stream/promises";
-import { Subject } from "rxjs";
-
-// src/utils/io.ts
-import fs from "node:fs";
-async function getFileSize(filepath) {
-  let size = 0;
-  if (fs.existsSync(filepath)) {
-    size = (await fs.promises.stat(filepath)).size || 0;
-  }
-  return size;
-}
-function mkdir(filepath) {
-  if (!fs.existsSync(filepath)) {
-    fs.mkdirSync(filepath, { recursive: true });
-  }
-}
-
-// src/utils/promise.ts
-async function sleep(time) {
-  return new Promise((resolve) => setTimeout(resolve, time));
-}
-var PromiseRetry = class _PromiseRetry {
-  retries;
-  delay;
-  callback;
-  constructor(options) {
-    this.retries = options.retries || 3;
-    this.delay = options.delay || 1e3;
-    this.callback = options.callback;
-  }
-  async execute(fn) {
-    let retries = this.retries;
-    while (true) {
-      try {
-        return await fn();
-      } catch (error) {
-        if (retries <= 0) {
-          throw error;
-        }
-        if (this.callback) {
-          const res = this.callback(retries, error);
-          if (res) {
-            const { newRetries } = res;
-            if (newRetries === 0) throw error;
-            this.retries = newRetries || retries;
-          }
-        }
-        await sleep(this.delay);
-        retries--;
-      }
-    }
-  }
-  static create(options) {
-    return new _PromiseRetry(options);
-  }
-};
-
 // src/utils/requests.ts
 import { CookieAgent } from "http-cookie-agent/undici";
 import { CookieJar } from "tough-cookie";
@@ -223,190 +272,10 @@ function fetchWithGlobalHeader(url) {
   const requestHeaders = new Headers(HeadersDefault);
   return fetch2(url, { headers: requestHeaders });
 }
-function fetchByteRange(url, downloadedSize) {
+function fetchByteRange(url, downloadedSize, signal) {
   const requestHeaders = new Headers(HeadersDefault);
   requestHeaders.set("Range", `bytes=${downloadedSize}-`);
-  return fetch2(url, { headers: requestHeaders });
-}
-
-// src/utils/timer.ts
-var Timer = class _Timer {
-  constructor(timeout = 1e4, timeoutCallback) {
-    this.timeout = timeout;
-    this.timeoutCallback = timeoutCallback;
-    this.timeout = timeout;
-  }
-  timer = void 0;
-  start() {
-    this.timer = setTimeout(() => {
-      this.stop();
-      this.timeoutCallback();
-    }, this.timeout);
-    return this;
-  }
-  stop() {
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = void 0;
-    }
-    return this;
-  }
-  reset() {
-    this.stop();
-    this.start();
-    return this;
-  }
-  static withSignal(timeout, message) {
-    const controller = new AbortController();
-    const callback = () => {
-      controller.abort(message);
-    };
-    const timer = new _Timer(timeout, callback).start();
-    return {
-      timer,
-      signal: controller.signal
-    };
-  }
-};
-
-// src/utils/downloader.ts
-var Downloader = class {
-  constructor(chunkTimeout = 3e4, chunkFetchRetries = 5, fetchRetries = 7) {
-    this.chunkTimeout = chunkTimeout;
-    this.chunkFetchRetries = chunkFetchRetries;
-    this.fetchRetries = fetchRetries;
-  }
-  subject = new Subject();
-  async fetchStream(file, stream) {
-    const { subject, chunkTimeout } = this;
-    const { timer, signal } = Timer.withSignal(chunkTimeout, "chunkTimeout");
-    const fileStream = fs2.createWriteStream(file.filepath, { flags: "a" });
-    const progressStream = new Transform({
-      transform(chunk, _encoding, callback) {
-        this.push(chunk);
-        file.downloaded += chunk.length;
-        timer.reset();
-        subject.next({ type: "CHUNK_DOWNLOADING_UPDATE", file });
-        callback();
-      }
-    });
-    try {
-      subject.next({ type: "CHUNK_DOWNLOADING_START", file });
-      await pipeline(stream, progressStream, fileStream, { signal });
-    } catch (error) {
-      console.error(error.name === "AbortError" ? signal.reason : error);
-    } finally {
-      subject.next({ type: "CHUNK_DOWNLOADING_END", file });
-    }
-  }
-  async downloadFile(file) {
-    file.downloaded = await getFileSize(file.filepath);
-    const response = await fetchByteRange(file.url, file.downloaded);
-    if (!response?.ok && response?.status !== 416) {
-      throw new Error(`HTTP error! status: ${response?.status}`);
-    }
-    const contentLength = response.headers.get("Content-Length");
-    if (!contentLength && file.downloaded > 0) return;
-    const restFileSize = parseInt(contentLength);
-    file.size = restFileSize + file.downloaded;
-    if (file.size > file.downloaded && response.body) {
-      const stream = Readable.fromWeb(response.body);
-      const sizeOld = file.downloaded;
-      await PromiseRetry.create({
-        retries: this.chunkFetchRetries,
-        callback: () => {
-          if (sizeOld !== file.downloaded) {
-            return { newRetries: 5 };
-          }
-        }
-      }).execute(async () => await this.fetchStream(file, stream));
-    }
-    this.subject.next({ type: "FILE_DOWNLOADING_END" });
-  }
-  async downloadFiles(filelist) {
-    mkdir(filelist.dirPath);
-    this.subject.next({ type: "FILES_DOWNLOADING_START", filesCount: filelist.files.length });
-    for (const file of filelist.files) {
-      this.subject.next({ type: "FILE_DOWNLOADING_START" });
-      await PromiseRetry.create({
-        retries: this.fetchRetries,
-        callback: (retries) => {
-          if (/coomer|kemono/.test(file.url)) {
-            file.url = tryFixCoomerUrl(file.url, retries);
-          }
-        }
-      }).execute(async () => await this.downloadFile(file));
-      this.subject.next({ type: "FILE_DOWNLOADING_END" });
-    }
-    this.subject.next({ type: "FILES_DOWNLOADING_END" });
-  }
-};
-
-// src/utils/multibar.ts
-import { MultiBar } from "cli-progress";
-
-// src/utils/strings.ts
-function b2mb(bytes) {
-  return Number.parseFloat((bytes / 1048576).toFixed(2));
-}
-function formatNameStdout(pathname) {
-  const name = pathname.split("/").pop() || "";
-  const consoleWidth = process.stdout.columns;
-  const width = Math.max(consoleWidth / 2 | 0, 40);
-  if (name.length < width) return name.trim();
-  const result = `${name.slice(0, width - 15)} ... ${name.slice(-10)}`.replace(/ +/g, " ");
-  return result;
-}
-
-// src/utils/multibar.ts
-var config = {
-  clearOnComplete: true,
-  gracefulExit: true,
-  autopadding: true,
-  hideCursor: true,
-  format: "{percentage}% | {filename} | {value}/{total}{size}"
-};
-function createMultibar(downloader) {
-  const multibar = new MultiBar(config);
-  let bar;
-  let minibar;
-  let filename;
-  let index = 0;
-  downloader.subject.subscribe({
-    next: ({ type, filesCount, file }) => {
-      switch (type) {
-        case "FILES_DOWNLOADING_START":
-          bar?.stop();
-          bar = multibar.create(filesCount, 0);
-          break;
-        case "FILES_DOWNLOADING_END":
-          bar?.stop();
-          break;
-        case "FILE_DOWNLOADING_START":
-          bar?.update(++index, { filename: "Downloaded files", size: "" });
-          break;
-        case "FILE_DOWNLOADING_END":
-          multibar.remove(minibar);
-          break;
-        case "CHUNK_DOWNLOADING_START":
-          multibar?.remove(minibar);
-          filename = formatNameStdout(file?.filepath);
-          minibar = multibar.create(b2mb(file?.size), b2mb(file?.downloaded));
-          break;
-        case "CHUNK_DOWNLOADING_UPDATE":
-          minibar?.update(b2mb(file?.downloaded), {
-            filename,
-            size: "mb"
-          });
-          break;
-        case "CHUNK_DOWNLOADING_END":
-          multibar?.remove(minibar);
-          break;
-        default:
-          break;
-      }
-    }
-  });
+  return fetch2(url, { headers: requestHeaders, signal });
 }
 
 // src/api/coomer-api.ts
@@ -436,10 +305,10 @@ async function getUserPostsAPI(user, offset) {
 async function getUserFiles(user) {
   const userPosts = [];
   const offset = 50;
-  for (let i = 0; i < 1e3; i++) {
+  for (let i = 0; i < 1e4; i++) {
     const posts = await getUserPostsAPI(user, i * offset);
     userPosts.push(...posts);
-    if (posts.length < 50) break;
+    if (posts.length < offset) break;
   }
   const filelist = new CoomerFileList();
   for (const p of userPosts) {
@@ -450,13 +319,23 @@ async function getUserFiles(user) {
     const postFiles = [...p.attachments, p.file].filter((f) => f.path).map((f, i) => {
       const ext = f.name.split(".").pop();
       const name = `${datentitle} ${i + 1}.${ext}`;
-      const url = `${user.domain}/${f.path}`;
+      const url = getUrl(f, user);
       return CoomerFile.from({ name, url, content });
     });
     filelist.files.push(...postFiles);
   }
   return filelist;
 }
+function getUrl(f, user) {
+  const normalizedPath = f.path.replace(/^\/+/, "/");
+  let url = "";
+  try {
+    url = new URL(normalizedPath, user.domain).toString();
+  } catch (_) {
+    url = `${user.domain}/${normalizedPath.replace(/^\//, "")}`;
+  }
+  return url;
+}
 async function parseUser(url) {
   const [_, domain, service, id] = url.match(
     /(https:\/\/\w+\.\w+)\/(\w+)\/user\/([\w|.|-]+)/
@@ -531,7 +410,6 @@ async function getUserPage(user, offset) {
   return fetch4(url).then((r) => r.text());
 }
 async function getUserPosts(user) {
-  console.log("Fetching user posts...");
   const posts = [];
   for (let i = 1; i < 1e5; i++) {
     const page = await getUserPage(user, i);
@@ -543,7 +421,6 @@ async function getUserPosts(user) {
   return posts;
 }
 async function getPostsData(posts) {
-  console.log("Fetching posts data...");
   const filelist = new CoomerFileList();
   for (const post of posts) {
     const page = await fetch4(post).then((r) => r.text());
@@ -560,7 +437,9 @@ async function getPostsData(posts) {
 }
 async function getRedditData(url) {
   const user = url.match(/u\/(\w+)/)?.[1];
+  console.log("Fetching user posts...");
   const posts = await getUserPosts(user);
+  console.log("Fetching posts data...");
   const filelist = await getPostsData(posts);
   filelist.dirName = `${user}-reddit`;
   return filelist;
@@ -596,7 +475,7 @@ async function apiHandler(url_) {
   throw Error("Invalid URL");
 }
 
-// src/args-handler.ts
+// src/cli/args-handler.ts
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 function argumentHander() {
@@ -611,8 +490,7 @@ function argumentHander() {
     default: "./"
   }).option("media", {
     type: "string",
-    choices: ["video", "image", "all"],
-    default: "all",
+    choices: ["video", "image"],
     description: "The type of media to download: 'video', 'image', or 'all'. 'all' is the default."
   }).option("include", {
     type: "string",
@@ -622,34 +500,410 @@ function argumentHander() {
     type: "string",
     default: "",
     description: "Filter file names by a comma-separated list of keywords to exclude"
+  }).option("min-size", {
+    type: "string",
+    default: "",
+    description: 'Minimum file size to download. Example: "1mb" or "500kb"'
+  }).option("max-size", {
+    type: "string",
+    default: "",
+    description: 'Maximum file size to download. Example: "1mb" or "500kb"'
   }).option("skip", {
     type: "number",
     default: 0,
     description: "Skips the first N files in the download queue"
+  }).option("remove-dupilicates", {
+    type: "boolean",
+    default: true,
+    description: "removes duplicates by url and file hash"
   }).help().alias("help", "h").parseSync();
 }
 
+// src/cli/ui/index.tsx
+import { render } from "ink";
+import React9 from "react";
+
+// src/cli/ui/app.tsx
+import { Box as Box7 } from "ink";
+import React8 from "react";
+
+// src/cli/ui/components/file.tsx
+import { Box as Box2, Spacer, Text as Text2 } from "ink";
+import React3 from "react";
+
+// src/utils/strings.ts
+function b2mb(bytes) {
+  return (bytes / 1048576).toFixed(2);
+}
+
+// src/cli/ui/components/preview.tsx
+import { Box } from "ink";
+import Image, { TerminalInfoProvider } from "ink-picture";
+import React from "react";
+
+// src/cli/ui/store/index.ts
+import { create } from "zustand";
+var useInkStore = create((set) => ({
+  preview: false,
+  switchPreview: () => set((state) => ({
+    preview: !state.preview
+  })),
+  downloader: void 0,
+  setDownloader: (downloader) => set({ downloader })
+}));
+
+// src/cli/ui/components/preview.tsx
+function Preview({ file }) {
+  const previewEnabled = useInkStore((state) => state.preview);
+  const bigEnough = file.downloaded > 50 * 1024;
+  const shouldShow = previewEnabled && bigEnough && isImage(file.filepath);
+  const imgInfo = `
+    can't read partial images yet...
+    actual size: ${file.size}}
+    downloaded: ${file.downloaded}}
+  `;
+  return shouldShow && /* @__PURE__ */ React.createElement(Box, { paddingX: 1 }, /* @__PURE__ */ React.createElement(TerminalInfoProvider, null, /* @__PURE__ */ React.createElement(Box, { width: 30, height: 15 }, /* @__PURE__ */ React.createElement(Image, { src: file.filepath, alt: imgInfo }))));
+}
+
+// src/cli/ui/components/spinner.tsx
+import spinners from "cli-spinners";
+import { Text } from "ink";
+import React2, { useEffect, useState } from "react";
+function Spinner({ type = "dots" }) {
+  const spinner = spinners[type];
+  const randomFrame = spinner.frames.length * Math.random() | 0;
+  const [frame, setFrame] = useState(randomFrame);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setFrame((previousFrame) => {
+        return (previousFrame + 1) % spinner.frames.length;
+      });
+    }, spinner.interval);
+    return () => {
+      clearInterval(timer);
+    };
+  }, [spinner]);
+  return /* @__PURE__ */ React2.createElement(Text, null, spinner.frames[frame]);
+}
+
+// src/cli/ui/components/file.tsx
+function FileBox({ file }) {
+  const percentage = Number(file.downloaded / file.size * 100).toFixed(2);
+  return /* @__PURE__ */ React3.createElement(React3.Fragment, null, /* @__PURE__ */ React3.createElement(
+    Box2,
+    {
+      borderStyle: "single",
+      borderColor: "magentaBright",
+      borderDimColor: true,
+      paddingX: 1,
+      flexDirection: "column"
+    },
+    /* @__PURE__ */ React3.createElement(Box2, null, /* @__PURE__ */ React3.createElement(Text2, { color: "blue", dimColor: true, wrap: "truncate-middle" }, file.name)),
+    /* @__PURE__ */ React3.createElement(Box2, { flexDirection: "row-reverse" }, /* @__PURE__ */ React3.createElement(Text2, { color: "cyan", dimColor: true }, b2mb(file.downloaded), "/", file.size ? b2mb(file.size) : "\u221E", " MB"), /* @__PURE__ */ React3.createElement(Text2, { color: "redBright", dimColor: true }, file.size ? `  ${percentage}% ` : ""), /* @__PURE__ */ React3.createElement(Spacer, null), /* @__PURE__ */ React3.createElement(Text2, { color: "green", dimColor: true }, /* @__PURE__ */ React3.createElement(Spinner, null)))
+  ), /* @__PURE__ */ React3.createElement(Preview, { file }));
+}
+
+// src/cli/ui/components/filelist.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import React4 from "react";
+function FileListStateBox({ filelist }) {
+  return /* @__PURE__ */ React4.createElement(
+    Box3,
+    {
+      paddingX: 1,
+      flexDirection: "column",
+      borderStyle: "single",
+      borderColor: "magenta",
+      borderDimColor: true
+    },
+    /* @__PURE__ */ React4.createElement(Box3, null, /* @__PURE__ */ React4.createElement(Box3, { marginRight: 1 }, /* @__PURE__ */ React4.createElement(Text3, { color: "cyanBright", dimColor: true }, "Found:")), /* @__PURE__ */ React4.createElement(Text3, { color: "blue", dimColor: true, wrap: "wrap" }, filelist.files.length)),
+    /* @__PURE__ */ React4.createElement(Box3, null, /* @__PURE__ */ React4.createElement(Box3, { marginRight: 1 }, /* @__PURE__ */ React4.createElement(Text3, { color: "cyanBright", dimColor: true }, "Downloaded:")), /* @__PURE__ */ React4.createElement(Text3, { color: "blue", dimColor: true, wrap: "wrap" }, filelist.getDownloaded().length)),
+    /* @__PURE__ */ React4.createElement(Box3, null, /* @__PURE__ */ React4.createElement(Box3, { width: 9 }, /* @__PURE__ */ React4.createElement(Text3, { color: "cyanBright", dimColor: true }, "Folder:")), /* @__PURE__ */ React4.createElement(Box3, { flexGrow: 1 }, /* @__PURE__ */ React4.createElement(Text3, { color: "blue", dimColor: true, wrap: "truncate-middle" }, filelist.dirPath)))
+  );
+}
+
+// src/cli/ui/components/keyboardinfo.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import React5 from "react";
+var info = {
+  "s ": "skip current file",
+  p: "on/off image preview"
+};
+function KeyboardControlsInfo() {
+  const infoRender = Object.entries(info).map(([key, value]) => {
+    return /* @__PURE__ */ React5.createElement(Box4, { key }, /* @__PURE__ */ React5.createElement(Box4, { marginRight: 2 }, /* @__PURE__ */ React5.createElement(Text4, { color: "red", dimColor: true, bold: true }, key)), /* @__PURE__ */ React5.createElement(Text4, { dimColor: true, bold: false }, value));
+  });
+  return /* @__PURE__ */ React5.createElement(
+    Box4,
+    {
+      flexDirection: "column",
+      paddingX: 1,
+      borderStyle: "single",
+      borderColor: "gray",
+      borderDimColor: true
+    },
+    /* @__PURE__ */ React5.createElement(Box4, null, /* @__PURE__ */ React5.createElement(Text4, { color: "red", dimColor: true, bold: true }, "Keyboard controls:")),
+    infoRender
+  );
+}
+
+// src/cli/ui/components/loading.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import React6 from "react";
+function Loading() {
+  return /* @__PURE__ */ React6.createElement(Box5, { paddingX: 1, borderDimColor: true, flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Box5, { alignSelf: "center" }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true, color: "redBright" }, "Fetching Data")), /* @__PURE__ */ React6.createElement(Box5, { alignSelf: "center" }, /* @__PURE__ */ React6.createElement(Text5, { color: "blueBright", dimColor: true }, /* @__PURE__ */ React6.createElement(Spinner, { type: "grenade" }))));
+}
+
+// src/cli/ui/components/titlebar.tsx
+import { Box as Box6, Spacer as Spacer2, Text as Text6 } from "ink";
+import React7 from "react";
+
+// package.json
+var version = "3.4.0";
+
+// src/cli/ui/components/titlebar.tsx
+function TitleBar() {
+  return /* @__PURE__ */ React7.createElement(Box6, null, /* @__PURE__ */ React7.createElement(Spacer2, null), /* @__PURE__ */ React7.createElement(Box6, { borderColor: "magenta", borderStyle: "arrow" }, /* @__PURE__ */ React7.createElement(Text6, { color: "cyanBright" }, "Coomer-Downloader ", version)), /* @__PURE__ */ React7.createElement(Spacer2, null));
+}
+
+// src/cli/ui/hooks/downloader.ts
+import { useEffect as useEffect2, useState as useState2 } from "react";
+var useDownloaderHook = () => {
+  const downloader = useInkStore((state) => state.downloader);
+  const filelist = downloader?.filelist;
+  const [_, setHelper] = useState2(0);
+  useEffect2(() => {
+    downloader?.subject.subscribe(({ type }) => {
+      if (type === "FILE_DOWNLOADING_START" || type === "FILE_DOWNLOADING_END" || type === "CHUNK_DOWNLOADING_UPDATE") {
+        setHelper(Date.now());
+      }
+    });
+  });
+};
+
+// src/cli/ui/hooks/input.ts
+import { useInput } from "ink";
+var useInputHook = () => {
+  const downloader = useInkStore((state) => state.downloader);
+  const switchPreview = useInkStore((state) => state.switchPreview);
+  useInput((input) => {
+    if (input === "s") {
+      downloader?.skip();
+    }
+    if (input === "p") {
+      switchPreview();
+    }
+  });
+};
+
+// src/cli/ui/app.tsx
+function App() {
+  useInputHook();
+  useDownloaderHook();
+  const downloader = useInkStore((state) => state.downloader);
+  const filelist = downloader?.filelist;
+  const isFilelist = filelist instanceof CoomerFileList;
+  return /* @__PURE__ */ React8.createElement(Box7, { borderStyle: "single", flexDirection: "column", borderColor: "blue", width: 80 }, /* @__PURE__ */ React8.createElement(TitleBar, null), !isFilelist ? /* @__PURE__ */ React8.createElement(Loading, null) : /* @__PURE__ */ React8.createElement(React8.Fragment, null, /* @__PURE__ */ React8.createElement(Box7, null, /* @__PURE__ */ React8.createElement(Box7, null, /* @__PURE__ */ React8.createElement(FileListStateBox, { filelist })), /* @__PURE__ */ React8.createElement(Box7, { flexBasis: 30 }, /* @__PURE__ */ React8.createElement(KeyboardControlsInfo, null))), filelist.getActiveFiles().map((file) => {
+    return /* @__PURE__ */ React8.createElement(FileBox, { file, key: file.name });
+  })));
+}
+
+// src/cli/ui/index.tsx
+function createReactInk() {
+  return render(/* @__PURE__ */ React9.createElement(App, null));
+}
+
+// src/services/downloader.ts
+import fs2 from "node:fs";
+import { Readable, Transform } from "node:stream";
+import { pipeline as pipeline2 } from "node:stream/promises";
+import { Subject } from "rxjs";
+
+// src/utils/promise.ts
+async function sleep(time) {
+  return new Promise((resolve) => setTimeout(resolve, time));
+}
+
+// src/utils/timer.ts
+var Timer = class _Timer {
+  constructor(timeout = 1e4, timeoutCallback) {
+    this.timeout = timeout;
+    this.timeoutCallback = timeoutCallback;
+    this.timeout = timeout;
+  }
+  timer;
+  start() {
+    this.timer = setTimeout(() => {
+      this.stop();
+      this.timeoutCallback();
+    }, this.timeout);
+    return this;
+  }
+  stop() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    return this;
+  }
+  reset() {
+    this.stop();
+    this.start();
+    return this;
+  }
+  static withAbortController(timeout, abortControllerSubject, message = "TIMEOUT") {
+    const callback = () => {
+      abortControllerSubject.next(message);
+    };
+    const timer = new _Timer(timeout, callback).start();
+    return { timer };
+  }
+};
+
+// src/services/downloader.ts
+var Downloader = class {
+  constructor(filelist, minSize, maxSize, chunkTimeout = 3e4, chunkFetchRetries = 5, fetchRetries = 7) {
+    this.filelist = filelist;
+    this.minSize = minSize;
+    this.maxSize = maxSize;
+    this.chunkTimeout = chunkTimeout;
+    this.chunkFetchRetries = chunkFetchRetries;
+    this.fetchRetries = fetchRetries;
+    this.setAbortControllerListener();
+  }
+  subject = new Subject();
+  abortController = new AbortController();
+  abortControllerSubject = new Subject();
+  setAbortControllerListener() {
+    this.abortControllerSubject.subscribe((type) => {
+      this.abortController.abort(type);
+      this.abortController = new AbortController();
+    });
+  }
+  async fetchStream(file, stream, sizeOld = 0, retries = this.chunkFetchRetries) {
+    const signal = this.abortController.signal;
+    const subject = this.subject;
+    const { timer } = Timer.withAbortController(
+      this.chunkTimeout,
+      this.abortControllerSubject
+    );
+    try {
+      const fileStream = fs2.createWriteStream(file.filepath, { flags: "a" });
+      const progressStream = new Transform({
+        transform(chunk, _encoding, callback) {
+          this.push(chunk);
+          file.downloaded += chunk.length;
+          timer.reset();
+          subject.next({ type: "CHUNK_DOWNLOADING_UPDATE" });
+          callback();
+        }
+      });
+      subject.next({ type: "CHUNK_DOWNLOADING_START" });
+      await pipeline2(stream, progressStream, fileStream, { signal });
+    } catch (error) {
+      if (signal.aborted) {
+        if (signal.reason === "FILE_SKIP") return;
+        if (signal.reason === "TIMEOUT") {
+          if (retries === 0 && sizeOld < file.downloaded) {
+            retries += this.chunkFetchRetries;
+            sizeOld = file.downloaded;
+          }
+          if (retries === 0) return;
+          return await this.fetchStream(file, stream, sizeOld, retries - 1);
+        }
+      }
+      throw error;
+    } finally {
+      subject.next({ type: "CHUNK_DOWNLOADING_END" });
+      timer.stop();
+    }
+  }
+  skip() {
+    this.abortControllerSubject.next("FILE_SKIP");
+  }
+  filterFileSize(file) {
+    if (!file.size) return;
+    if (this.minSize && file.size < this.minSize || this.maxSize && file.size > this.maxSize) {
+      try {
+        deleteFile(file.filepath);
+      } catch {
+      }
+      this.skip();
+      return;
+    }
+  }
+  async downloadFile(file, retries = this.fetchRetries) {
+    const signal = this.abortController.signal;
+    try {
+      file.downloaded = await getFileSize(file.filepath);
+      const response = await fetchByteRange(file.url, file.downloaded, signal);
+      if (!response?.ok && response?.status !== 416) {
+        throw new Error(`HTTP error! status: ${response?.status}`);
+      }
+      const contentLength = response.headers.get("Content-Length");
+      if (!contentLength && file.downloaded > 0) return;
+      const restFileSize = parseInt(contentLength);
+      file.size = restFileSize + file.downloaded;
+      this.filterFileSize(file);
+      if (file.size > file.downloaded && response.body) {
+        const stream = Readable.fromWeb(response.body);
+        stream.setMaxListeners(20);
+        await this.fetchStream(file, stream, file.downloaded);
+      }
+    } catch (error) {
+      if (signal.aborted) {
+        if (signal.reason === "FILE_SKIP") return;
+      }
+      if (retries > 0) {
+        if (/coomer|kemono/.test(file.url)) {
+          file.url = tryFixCoomerUrl(file.url, retries);
+        }
+        await sleep(1e3);
+        return await this.downloadFile(file, retries - 1);
+      }
+      throw error;
+    }
+  }
+  async downloadFiles() {
+    mkdir(this.filelist.dirPath);
+    this.subject.next({ type: "FILES_DOWNLOADING_START" });
+    for (const file of this.filelist.files) {
+      file.active = true;
+      this.subject.next({ type: "FILE_DOWNLOADING_START" });
+      await this.downloadFile(file);
+      file.active = false;
+      this.subject.next({ type: "FILE_DOWNLOADING_END" });
+    }
+    this.subject.next({ type: "FILES_DOWNLOADING_END" });
+  }
+};
+
 // src/index.ts
 async function run() {
-  const { url, dir, media, include, exclude, skip } = argumentHander();
+  createReactInk();
+  const { url, dir, media, include, exclude, minSize, maxSize, skip, removeDupilicates } = argumentHander();
   const filelist = await apiHandler(url);
-  const found = filelist.files.length;
-  filelist.setDirPath(dir);
-  filelist.skip(skip);
-  filelist.filterByText(include, exclude);
-  filelist.filterByMediaType(media);
-  console.table([
-    {
-      found,
-      skip,
-      filtered: found - filelist.files.length,
-      folder: filelist.dirPath
-    }
-  ]);
+  filelist.setDirPath(dir).skip(skip).filterByText(include, exclude).filterByMediaType(media);
+  if (removeDupilicates) {
+    filelist.removeURLDuplicates();
+  }
+  const minSizeBytes = minSize ? parseSizeValue(minSize) : void 0;
+  const maxSizeBytes = maxSize ? parseSizeValue(maxSize) : void 0;
+  await filelist.calculateFileSizes();
   setGlobalHeaders({ Referer: url });
-  const downloader = new Downloader();
-  createMultibar(downloader);
-  await downloader.downloadFiles(filelist);
-  process2.kill(process2.pid, "SIGINT");
-}
-run();
+  const downloader = new Downloader(filelist, minSizeBytes, maxSizeBytes);
+  useInkStore.getState().setDownloader(downloader);
+  await downloader.downloadFiles();
+  if (removeDupilicates) {
+    await filelist.removeDuplicatesByHash();
+  }
+}
+(async () => {
+  try {
+    await run();
+    process2.exit(0);
+  } catch (err) {
+    console.error("Fatal error:", err);
+    process2.exit(1);
+  }
+})();