@0xsharon/synco 0.0.0-stage → 1.0.0

package/dist/cli.cjs

@@ -0,0 +1,984 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  runCli: () => runCli
+});
+module.exports = __toCommonJS(cli_exports);
+var import_commander = require("commander");
+
+// src/lyrics.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+
+// src/types.ts
+var TargetType = /* @__PURE__ */ ((TargetType2) => {
+  TargetType2["PLAINTEXT"] = "PLAINTEXT";
+  TargetType2["PREFER_SYNCED"] = "PREFER_SYNCED";
+  TargetType2["SYNCED_ONLY"] = "SYNCED_ONLY";
+  return TargetType2;
+})(TargetType || {});
+
+// src/utils.ts
+var import_node_os = __toESM(require("os"));
+var import_node_path = __toESM(require("path"));
+var R_FEAT = /\((feat.+)\)/i;
+function syncedToPlaintext(syncedLyrics) {
+  if (!syncedLyrics) return "";
+  return syncedLyrics.replace(/\[\d+:\d+(?:\.\d+)?\]\s*/g, "").replace(/<\d+:\d+(?:\.\d+)?>\s*/g, "").trim();
+}
+function identifyLyricsType(lrc) {
+  if (!lrc || typeof lrc !== "string" || !lrc.trim()) {
+    return "invalid";
+  }
+  const lines = lrc.split("\n").map((l) => l.trim()).filter(Boolean);
+  if (lines.length === 0) return "invalid";
+  const timeTagRegex = /\[\d{1,2}:\d{2}(?:\.\d{1,3})?\]/;
+  const taggedLines = lines.filter((line) => timeTagRegex.test(line));
+  if (taggedLines.length >= 2 || taggedLines.length / lines.length >= 0.25) {
+    return "synced";
+  }
+  return "plaintext";
+}
+function formatTime(timeInSeconds) {
+  const totalSeconds = Math.max(0, timeInSeconds);
+  let minutes = Math.floor(totalSeconds / 60);
+  let seconds = Math.floor(totalSeconds % 60);
+  let hundredths = Math.round((totalSeconds - Math.floor(totalSeconds)) * 100);
+  if (hundredths >= 100) {
+    hundredths = 0;
+    seconds += 1;
+    if (seconds >= 60) {
+      seconds = 0;
+      minutes += 1;
+    }
+  }
+  return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}.${String(hundredths).padStart(2, "0")}`;
+}
+function defaultProcess(str) {
+  return str.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").trim();
+}
+function indelDistance(s1, s2) {
+  const m = s1.length;
+  const n = s2.length;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (s1[i - 1] === s2[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1];
+      } else {
+        dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1);
+      }
+    }
+  }
+  return dp[m][n];
+}
+function fuzzRatio(s1, s2) {
+  if (!s1 && !s2) return 100;
+  if (!s1 || !s2) return 0;
+  const dist = indelDistance(s1, s2);
+  const totalLen = s1.length + s2.length;
+  return totalLen === 0 ? 100 : (totalLen - dist) / totalLen * 100;
+}
+function tokenSetRatio(s1, s2) {
+  const p1 = defaultProcess(s1);
+  const p2 = defaultProcess(s2);
+  if (!p1 && !p2) return 100;
+  if (!p1 || !p2) return 0;
+  const t1 = Array.from(new Set(p1.split(/\s+/).filter(Boolean)));
+  const t2 = Array.from(new Set(p2.split(/\s+/).filter(Boolean)));
+  const set1 = new Set(t1);
+  const set2 = new Set(t2);
+  const intersection = t1.filter((x) => set2.has(x)).sort();
+  const diff1 = t1.filter((x) => !set2.has(x)).sort();
+  const diff2 = t2.filter((x) => !set1.has(x)).sort();
+  const s0 = intersection.join(" ");
+  const s1Rest = diff1.join(" ");
+  const s2Rest = diff2.join(" ");
+  const combined1 = [s0, s1Rest].filter(Boolean).join(" ");
+  const combined2 = [s0, s2Rest].filter(Boolean).join(" ");
+  if (!s0) {
+    return fuzzRatio(combined1, combined2);
+  }
+  return Math.max(
+    fuzzRatio(s0, combined1),
+    fuzzRatio(s0, combined2),
+    fuzzRatio(combined1, combined2)
+  );
+}
+function strScore(a, b) {
+  let lowerA = (a || "").toLowerCase();
+  let lowerB = (b || "").toLowerCase();
+  if (!lowerB.includes("feat")) {
+    lowerA = lowerA.replace(R_FEAT, "");
+    lowerB = lowerB.replace(R_FEAT, "");
+  }
+  return tokenSetRatio(lowerA, lowerB);
+}
+function strSame(a, b, minScore = 65) {
+  return Math.round(strScore(a, b)) >= minScore;
+}
+function sortResults(results, searchTerm, compareKey) {
+  return [...results].sort((a, b) => {
+    const scoreA = strScore(compareKey(a), searchTerm);
+    const scoreB = strScore(compareKey(b), searchTerm);
+    return scoreB - scoreA;
+  });
+}
+function getBestMatch(results, searchTerm, compareKey, minScore = 65) {
+  if (!results || results.length === 0) return null;
+  const sorted = sortResults(results, searchTerm, compareKey);
+  const bestMatch = sorted[0];
+  const valueToCompare = compareKey(bestMatch);
+  if (!strSame(valueToCompare, searchTerm, minScore)) {
+    return null;
+  }
+  return bestMatch;
+}
+function getCachePath(libName = "synco") {
+  const platform = process.platform;
+  let baseDir;
+  if (platform === "win32") {
+    baseDir = process.env.LOCALAPPDATA || import_node_path.default.join(import_node_os.default.homedir(), "AppData", "Local");
+  } else if (platform === "darwin") {
+    baseDir = import_node_path.default.join(import_node_os.default.homedir(), "Library", "Caches");
+  } else {
+    baseDir = process.env.XDG_CACHE_HOME || import_node_path.default.join(import_node_os.default.homedir(), ".cache");
+  }
+  return import_node_path.default.join(baseDir, libName);
+}
+var Logger = class {
+  constructor(context, verbose = false) {
+    this.context = context;
+    this.verbose = verbose;
+  }
+  context;
+  verbose;
+  debug(...args) {
+    if (this.verbose) {
+      console.error(`[${this.context}] [DEBUG]`, ...args);
+    }
+  }
+  info(...args) {
+    if (this.verbose) {
+      console.error(`[${this.context}] [INFO]`, ...args);
+    }
+  }
+  warn(...args) {
+    console.error(`[${this.context}] [WARN]`, ...args);
+  }
+  error(...args) {
+    console.error(`[${this.context}] [ERROR]`, ...args);
+  }
+};
+
+// src/lyrics.ts
+var Lyrics = class {
+  synced = null;
+  unsynced = null;
+  constructor(synced, unsynced) {
+    this.synced = synced ?? null;
+    this.unsynced = unsynced ?? null;
+  }
+  addUnknown(unknown) {
+    if (!unknown || typeof unknown !== "string") return;
+    const trimmed = unknown.trim();
+    if (!trimmed) return;
+    const type = identifyLyricsType(trimmed);
+    if (type === "synced") {
+      this.synced = trimmed;
+    } else if (type === "plaintext") {
+      this.unsynced = trimmed;
+    }
+  }
+  update(other) {
+    if (!other) return;
+    if (other.synced) {
+      this.synced = other.synced;
+    }
+    if (other.unsynced) {
+      this.unsynced = other.unsynced;
+    }
+  }
+  isPreferred(targetType) {
+    return Boolean(
+      this.synced || targetType === "PLAINTEXT" /* PLAINTEXT */ && this.unsynced
+    );
+  }
+  isAcceptable(targetType) {
+    return Boolean(
+      this.synced || targetType !== "SYNCED_ONLY" /* SYNCED_ONLY */ && this.unsynced
+    );
+  }
+  toStr(targetType) {
+    if (targetType === "PLAINTEXT" /* PLAINTEXT */) {
+      if (this.unsynced) return this.unsynced;
+      if (this.synced) return syncedToPlaintext(this.synced);
+      return null;
+    }
+    if (targetType === "PREFER_SYNCED" /* PREFER_SYNCED */) {
+      return this.synced || this.unsynced || null;
+    }
+    return this.synced || null;
+  }
+  async saveLrcFile(filePath, targetType) {
+    const text = this.toStr(targetType);
+    if (!text) return;
+    const resolvedPath = import_node_path2.default.resolve(filePath);
+    await import_node_fs.default.promises.mkdir(import_node_path2.default.dirname(resolvedPath), { recursive: true });
+    await import_node_fs.default.promises.writeFile(resolvedPath, text, "utf-8");
+  }
+};
+
+// src/providers/base.ts
+var import_axios = __toESM(require("axios"));
+var LRCProvider = class {
+  session;
+  logger;
+  options;
+  constructor(options = {}) {
+    this.options = options;
+    this.logger = new Logger(this.constructor.name, Boolean(options.verbose));
+    this.session = import_axios.default.create({
+      timeout: options.timeoutMs ?? 1e4,
+      headers: {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 synco/1.0.0",
+        Accept: "application/json, text/plain, */*"
+      }
+    });
+  }
+  toString() {
+    return this.name;
+  }
+  async get(url, config) {
+    try {
+      const response = await this.session.get(url, config);
+      return response.data;
+    } catch (err) {
+      this.logger.debug(`GET request failed for ${url}:`, err?.message ?? err);
+      return null;
+    }
+  }
+  async post(url, data, config) {
+    try {
+      const response = await this.session.post(url, data, config);
+      return response.data;
+    } catch (err) {
+      this.logger.debug(`POST request failed for ${url}:`, err?.message ?? err);
+      return null;
+    }
+  }
+};
+
+// src/providers/lrclib.ts
+var Lrclib = class _Lrclib extends LRCProvider {
+  name = "Lrclib";
+  static ROOT_URL = "https://lrclib.net";
+  static API_ENDPOINT = `${_Lrclib.ROOT_URL}/api`;
+  static SEARCH_ENDPOINT = `${_Lrclib.API_ENDPOINT}/search`;
+  static LRC_ENDPOINT = `${_Lrclib.API_ENDPOINT}/get/`;
+  constructor(options = {}) {
+    super(options);
+  }
+  async getLrcById(trackId) {
+    const url = `${_Lrclib.LRC_ENDPOINT}${trackId}`;
+    const data = await this.get(url);
+    if (!data) return null;
+    const lyrics = new Lyrics();
+    lyrics.synced = data.syncedLyrics || null;
+    lyrics.unsynced = data.plainLyrics || null;
+    return lyrics;
+  }
+  async getLrc(searchTerm) {
+    const data = await this.get(_Lrclib.SEARCH_ENDPOINT, {
+      params: { q: searchTerm }
+    });
+    if (!data || !Array.isArray(data) || data.length === 0) {
+      this.logger.debug(`No tracks found on Lrclib for "${searchTerm}"`);
+      return null;
+    }
+    const sorted = sortResults(
+      data,
+      searchTerm,
+      (t) => `${t.artistName} - ${t.trackName}`
+    );
+    const best = sorted[0];
+    if (!best) return null;
+    if (best.syncedLyrics || best.plainLyrics) {
+      return new Lyrics(best.syncedLyrics || null, best.plainLyrics || null);
+    }
+    return this.getLrcById(best.id);
+  }
+};
+
+// src/providers/megalobiz.ts
+var cheerio = __toESM(require("cheerio"));
+var Megalobiz = class _Megalobiz extends LRCProvider {
+  name = "Megalobiz";
+  static ROOT_URL = "https://www.megalobiz.com";
+  static API_ENDPOINT = "https://api.megalobiz.com/api/public/v1";
+  constructor(options = {}) {
+    super(options);
+  }
+  async getLrc(searchTerm) {
+    const apiResult = await this.getViaApi(searchTerm);
+    if (apiResult) return apiResult;
+    return this.getViaWeb(searchTerm);
+  }
+  async getViaApi(searchTerm) {
+    try {
+      const data = await this.get(
+        `${_Megalobiz.API_ENDPOINT}/search`,
+        {
+          params: { q: searchTerm },
+          headers: {
+            "User-Agent": "synco-node/1.0 (https://github.com/0xSHARON/synco)"
+          }
+        }
+      );
+      const items = data?.results;
+      if (!items || !Array.isArray(items) || items.length === 0) {
+        return null;
+      }
+      const match = getBestMatch(
+        items,
+        searchTerm,
+        (t) => `${t.artist} ${t.title}`,
+        60
+      );
+      const chosen = match || items[0];
+      const lrcUrl = chosen.lrc_url || `${_Megalobiz.API_ENDPOINT}/lrc/${chosen.id}?format=lrc`;
+      const lrcResponse = await this.session.get(lrcUrl, {
+        headers: {
+          "User-Agent": "synco-node/1.0 (https://github.com/0xSHARON/synco)"
+        },
+        responseType: "text"
+      });
+      if (lrcResponse.status === 200 && lrcResponse.data) {
+        const lyrics = new Lyrics();
+        lyrics.addUnknown(lrcResponse.data);
+        return lyrics;
+      }
+    } catch (err) {
+      this.logger.debug("Megalobiz API error:", err?.message ?? err);
+    }
+    return null;
+  }
+  async getViaWeb(searchTerm) {
+    try {
+      const query = searchTerm.replace(/\s+/g, "+");
+      const searchUrl = `${_Megalobiz.ROOT_URL}/search/all?qry=${query}&searchButton.x=0&searchButton.y=0`;
+      const html = await this.get(searchUrl, { responseType: "text" });
+      if (!html || typeof html !== "string") return null;
+      const $ = cheerio.load(html);
+      const links = [];
+      $('a[href^="/lrc/maker/"]').each((_, el) => {
+        const href = $(el).attr("href");
+        if (href) {
+          const rawText = $(el).text().replace(/by/gi, "").trim();
+          const words = rawText.split(/\s+/).slice(0, searchTerm.split(/\s+/).length + 1);
+          links.push({ href, text: words.join(" ") });
+        }
+      });
+      if (links.length === 0) return null;
+      const match = getBestMatch(links, searchTerm, (item) => item.text, 55);
+      if (!match) return null;
+      const lrcPageUrl = `${_Megalobiz.ROOT_URL}${match.href}`;
+      const pageHtml = await this.get(lrcPageUrl, { responseType: "text" });
+      if (!pageHtml) return null;
+      const lrcId = match.href.split(".").pop();
+      const page$ = cheerio.load(pageHtml);
+      const lrcText = page$(`div#lrc_${lrcId}_details`).text();
+      if (lrcText) {
+        const lyrics = new Lyrics();
+        lyrics.addUnknown(lrcText);
+        return lyrics;
+      }
+    } catch (err) {
+      this.logger.debug("Megalobiz web scraper error:", err?.message ?? err);
+    }
+    return null;
+  }
+};
+
+// src/providers/musixmatch.ts
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path3 = __toESM(require("path"));
+var Musixmatch = class _Musixmatch extends LRCProvider {
+  name = "Musixmatch";
+  static ROOT_URL = "https://apic-desktop.musixmatch.com/ws/1.1/";
+  token = null;
+  lang;
+  enhanced;
+  constructor(options = {}) {
+    super(options);
+    this.lang = options.lang;
+    this.enhanced = Boolean(options.enhanced);
+    if (options.musixmatchToken || process.env.MUSIXMATCH_TOKEN) {
+      this.token = options.musixmatchToken || process.env.MUSIXMATCH_TOKEN || null;
+    }
+  }
+  async requestApi(action, params = {}) {
+    if (action !== "token.get" && !this.token) {
+      await this.ensureToken();
+    }
+    const query = {
+      app_id: "web-desktop-app-v1.0",
+      t: Date.now(),
+      ...params
+    };
+    if (this.token) {
+      query.usertoken = this.token;
+    }
+    const url = `${_Musixmatch.ROOT_URL}${action}`;
+    return this.get(url, { params: query });
+  }
+  async ensureToken() {
+    const tokenFile = import_node_path3.default.join(getCachePath("synco"), "musixmatch_token.json");
+    const currentTime = Math.floor(Date.now() / 1e3);
+    try {
+      if (import_node_fs2.default.existsSync(tokenFile)) {
+        const raw = import_node_fs2.default.readFileSync(tokenFile, "utf-8");
+        const cached = JSON.parse(raw);
+        if (cached.token && cached.token !== "00000000000000000000000000000000000000000000000000000000" && cached.expiration_time && currentTime < cached.expiration_time) {
+          this.token = cached.token;
+          return;
+        }
+      }
+    } catch {
+    }
+    const res = await this.requestApi("token.get", { user_language: "en" });
+    const statusCode = res?.message?.header?.status_code;
+    if (statusCode === 401) {
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+      return this.ensureToken();
+    }
+    const newToken = res?.message?.body?.user_token;
+    if (newToken && typeof newToken === "string") {
+      this.token = newToken;
+      const tokenData = {
+        token: newToken,
+        expiration_time: currentTime + 600
+        // 10 minutes expiration
+      };
+      try {
+        import_node_fs2.default.mkdirSync(import_node_path3.default.dirname(tokenFile), { recursive: true });
+        import_node_fs2.default.writeFileSync(tokenFile, JSON.stringify(tokenData, null, 2), "utf-8");
+      } catch {
+      }
+    }
+  }
+  async getLrcById(trackId) {
+    const subtitleRes = await this.requestApi("track.subtitle.get", {
+      track_id: trackId,
+      subtitle_format: "lrc"
+    });
+    let translationList = [];
+    if (this.lang) {
+      const translationRes = await this.requestApi("crowd.track.translations.get", {
+        track_id: trackId,
+        subtitle_format: "lrc",
+        translation_fields_set: "minimal",
+        selected_language: this.lang
+      });
+      translationList = translationRes?.message?.body?.translations_list || [];
+      if (translationList.length === 0) {
+        this.logger.debug(`Could not find translations in ${this.lang} for track ${trackId}`);
+      }
+    }
+    const body = subtitleRes?.message?.body;
+    let lrcStr = body?.subtitle?.subtitle_body;
+    if (!lrcStr || typeof lrcStr !== "string") {
+      return null;
+    }
+    if (this.lang && translationList.length > 0) {
+      for (const item of translationList) {
+        const org = item?.translation?.subtitle_matched_line;
+        const tr = item?.translation?.description;
+        if (org && tr) {
+          lrcStr = lrcStr.replace(org, `${org}
+(${tr})`);
+        }
+      }
+    }
+    const lyrics = new Lyrics();
+    lyrics.synced = lrcStr;
+    return lyrics;
+  }
+  async getLrcWordByWord(trackId) {
+    const res = await this.requestApi("track.richsync.get", {
+      track_id: trackId
+    });
+    if (res?.message?.header?.status_code !== 200) {
+      return null;
+    }
+    const rawRichsync = res?.message?.body?.richsync?.richsync_body;
+    if (!rawRichsync) return null;
+    try {
+      const items = typeof rawRichsync === "string" ? JSON.parse(rawRichsync) : rawRichsync;
+      let lrcStr = "";
+      for (const item of items) {
+        const baseTs = parseFloat(item.ts);
+        lrcStr += `[${formatTime(baseTs)}] `;
+        if (Array.isArray(item.l)) {
+          for (const line of item.l) {
+            const wordOffset = parseFloat(line.o);
+            const wordTime = formatTime(baseTs + wordOffset);
+            lrcStr += `<${wordTime}> ${line.c} `;
+          }
+        }
+        lrcStr += "\n";
+      }
+      if (lrcStr.trim()) {
+        const lyrics = new Lyrics();
+        lyrics.synced = lrcStr;
+        return lyrics;
+      }
+    } catch (err) {
+      this.logger.debug("Failed to parse Musixmatch word-by-word JSON:", err?.message ?? err);
+    }
+    return null;
+  }
+  async getLrc(searchTerm) {
+    const res = await this.requestApi("track.search", {
+      q: searchTerm,
+      page_size: 5,
+      page: 1
+    });
+    const statusCode = res?.message?.header?.status_code;
+    if (statusCode !== 200) {
+      this.logger.debug(`Musixmatch track.search returned status code ${statusCode}`);
+      return null;
+    }
+    const tracks = res?.message?.body?.track_list;
+    if (!tracks || !Array.isArray(tracks) || tracks.length === 0) {
+      return null;
+    }
+    const match = getBestMatch(
+      tracks,
+      searchTerm,
+      (t) => `${t.track?.track_name} ${t.track?.artist_name}`
+    );
+    if (!match?.track?.track_id) {
+      return null;
+    }
+    const trackId = match.track.track_id;
+    if (this.enhanced) {
+      const enhancedLyrics = await this.getLrcWordByWord(trackId);
+      if (enhancedLyrics && enhancedLyrics.synced) {
+        return enhancedLyrics;
+      }
+    }
+    return this.getLrcById(trackId);
+  }
+};
+
+// src/providers/netease.ts
+var NetEase = class _NetEase extends LRCProvider {
+  name = "NetEase";
+  static API_ENDPOINT_METADATA = "https://music.163.com/api/search/pc";
+  static API_ENDPOINT_LYRICS = "https://music.163.com/api/song/lyric";
+  constructor(options = {}) {
+    super(options);
+    this.session.defaults.headers.common.Cookie = "NMTID=00OAVK3xqDG726ITU6jopU6jF2yMk0AAAGCO8l1BA; JSESSIONID-WYYY=8KQo11YK2GZP45RMlz8Kn80vHZ9%2FGvwzRKQXXy0iQoFKycWdBlQjbfT0MJrFa6hwRfmpfBYKeHliUPH287JC3hNW99WQjrh9b9RmKT%2Fg1Exc2VwHZcsqi7ITxQgfEiee50po28x5xTTZXKoP%2FRMctN2jpDeg57kdZrXz%2FD%2FWghb%5C4DuZ%3A1659124633932; _iuqxldmzr_=32; _ntes_nnid=0db6667097883aa9596ecfe7f188c3ec,1659122833973; _ntes_nuid=0db6667097883aa9596ecfe7f188c3ec;";
+    this.session.defaults.headers.common.Referer = "https://music.163.com/";
+  }
+  async searchTrack(searchTerm) {
+    const data = await this.get(_NetEase.API_ENDPOINT_METADATA, {
+      params: {
+        limit: 10,
+        type: 1,
+        offset: 0,
+        s: searchTerm
+      }
+    });
+    const songs = data?.result?.songs;
+    if (!songs || !Array.isArray(songs) || songs.length === 0) {
+      return null;
+    }
+    const match = getBestMatch(
+      songs,
+      searchTerm,
+      (t) => `${t.name} ${t.artists?.[0]?.name ?? ""}`
+    );
+    return match || songs[0];
+  }
+  async getLrcById(trackId) {
+    const data = await this.get(_NetEase.API_ENDPOINT_LYRICS, {
+      params: {
+        id: trackId,
+        lv: 1
+      }
+    });
+    const lyricText = data?.lrc?.lyric;
+    if (!lyricText || typeof lyricText !== "string") {
+      return null;
+    }
+    const lyrics = new Lyrics();
+    lyrics.addUnknown(lyricText);
+    return lyrics;
+  }
+  async getLrc(searchTerm) {
+    const track = await this.searchTrack(searchTerm);
+    if (!track?.id) return null;
+    return this.getLrcById(track.id);
+  }
+};
+
+// src/providers/genius.ts
+var cheerio2 = __toESM(require("cheerio"));
+var Genius = class _Genius extends LRCProvider {
+  name = "Genius";
+  static SEARCH_ENDPOINT = "https://genius.com/api/search/multi";
+  constructor(options = {}) {
+    super(options);
+    this.session.defaults.headers.common.Cookie = "obuid=e3ee67e0-7df9-4181-8324-d977c6dc9250;";
+    this.session.defaults.headers.common.Referer = "https://genius.com/";
+  }
+  async getLrc(searchTerm) {
+    try {
+      const data = await this.get(_Genius.SEARCH_ENDPOINT, {
+        params: {
+          per_page: 5,
+          q: searchTerm
+        }
+      });
+      const sections = data?.response?.sections;
+      if (!sections || !Array.isArray(sections)) return null;
+      const songSection = sections.find((s) => s.type === "song") || sections[1] || sections[0];
+      const hits = songSection?.hits;
+      if (!hits || !Array.isArray(hits) || hits.length === 0) return null;
+      const songUrl = hits[0]?.result?.url;
+      if (!songUrl) return null;
+      const pageHtml = await this.get(songUrl, {
+        responseType: "text"
+      });
+      if (!pageHtml || typeof pageHtml !== "string") return null;
+      const $ = cheerio2.load(pageHtml);
+      const containers = $('div[data-lyrics-container="true"]');
+      if (containers.length === 0) return null;
+      let lrcStr = "";
+      containers.each((_, el) => {
+        $(el).find("br").replaceWith("\n");
+        const text = $(el).text().trim();
+        if (text) {
+          lrcStr += `${text}
+
+`;
+        }
+      });
+      const cleaned = lrcStr.trim();
+      if (!cleaned) return null;
+      const lyrics = new Lyrics();
+      lyrics.unsynced = cleaned;
+      return lyrics;
+    } catch (err) {
+      this.logger.debug("Genius provider error:", err?.message ?? err);
+      return null;
+    }
+  }
+};
+
+// src/providers/deezer.ts
+var Deezer = class _Deezer extends LRCProvider {
+  name = "Deezer";
+  static SEARCH_ENDPOINT = "https://api.deezer.com/search";
+  static API_ENDPOINT = "https://www.deezer.com/ajax/gw-light.php";
+  token = "null";
+  constructor(options = {}) {
+    super(options);
+  }
+  async initializeToken() {
+    if (this.token !== "null") return;
+    try {
+      const data = await this.apiCall("deezer.getUserData");
+      const checkForm = data?.results?.checkForm;
+      if (checkForm) {
+        this.token = checkForm;
+      }
+    } catch {
+    }
+  }
+  async apiCall(method, jsonData) {
+    return this.post(
+      _Deezer.API_ENDPOINT,
+      jsonData,
+      {
+        params: {
+          api_version: "1.0",
+          api_token: this.token,
+          input: "3",
+          method
+        }
+      }
+    );
+  }
+  async getLrcById(trackId) {
+    await this.initializeToken();
+    const res = await this.apiCall("song.getLyrics", { sng_id: trackId });
+    const results = res?.results;
+    if (!results) return null;
+    const lyrics = new Lyrics();
+    const syncJson = results.LYRICS_SYNC_JSON;
+    if (!syncJson || !Array.isArray(syncJson)) {
+      lyrics.unsynced = results.LYRICS_TEXT || null;
+      return lyrics.unsynced ? lyrics : null;
+    }
+    let lrcStr = "";
+    for (const chunk of syncJson) {
+      if (chunk?.lrc_timestamp && chunk?.line) {
+        lrcStr += `${chunk.lrc_timestamp} ${chunk.line}
+`;
+      }
+    }
+    lyrics.synced = lrcStr.trim() ? lrcStr : null;
+    return lyrics;
+  }
+  async getLrc(searchTerm) {
+    const data = await this.get(_Deezer.SEARCH_ENDPOINT, {
+      params: { q: searchTerm }
+    });
+    const tracks = data?.data;
+    if (!tracks || !Array.isArray(tracks) || tracks.length === 0) {
+      return null;
+    }
+    const match = getBestMatch(
+      tracks,
+      searchTerm,
+      (t) => `${t.title} ${t.artist?.name ?? ""}`
+    );
+    if (!match?.id) return null;
+    return this.getLrcById(match.id);
+  }
+};
+
+// src/providers/lyricsify.ts
+var cheerio3 = __toESM(require("cheerio"));
+var Lyricsify = class _Lyricsify extends LRCProvider {
+  name = "Lyricsify";
+  static ROOT_URL = "https://www.lyricsify.com";
+  static SEARCH_ENDPOINT = `${_Lyricsify.ROOT_URL}/search`;
+  constructor(options = {}) {
+    super(options);
+  }
+  async getLrc(searchTerm) {
+    try {
+      const html = await this.get(_Lyricsify.SEARCH_ENDPOINT, {
+        params: { q: searchTerm },
+        responseType: "text"
+      });
+      if (!html || typeof html !== "string") return null;
+      const $ = cheerio3.load(html);
+      const links = [];
+      $('a[href^="/lyric/"]').each((_, el) => {
+        const href = $(el).attr("href");
+        if (href) {
+          links.push({
+            href,
+            text: $(el).text().toLowerCase().replace(/-/g, " ").trim()
+          });
+        }
+      });
+      if (links.length === 0) return null;
+      const match = getBestMatch(links, searchTerm, (item) => item.text, 55);
+      if (!match) return null;
+      const lrcId = match.href.split(".").pop();
+      const pageHtml = await this.get(`${_Lyricsify.ROOT_URL}${match.href}`, {
+        responseType: "text"
+      });
+      if (!pageHtml) return null;
+      const page$ = cheerio3.load(pageHtml);
+      const lrcText = page$(`div#lyrics_${lrcId}_details`).text();
+      if (lrcText) {
+        const lyrics = new Lyrics();
+        lyrics.addUnknown(lrcText);
+        return lyrics;
+      }
+    } catch (err) {
+      this.logger.debug("Lyricsify provider error:", err?.message ?? err);
+    }
+    return null;
+  }
+};
+
+// src/index.ts
+async function search(searchTerm, optOrPlainOnly, syncedOnly, savePath, providers, lang, enhanced) {
+  const options = typeof optOrPlainOnly === "object" && optOrPlainOnly !== null ? optOrPlainOnly : {
+    plainOnly: Boolean(optOrPlainOnly),
+    syncedOnly: Boolean(syncedOnly),
+    savePath,
+    providers,
+    lang,
+    enhanced: Boolean(enhanced)
+  };
+  const logger = new Logger("synco", Boolean(options.verbose));
+  if (options.plainOnly && options.syncedOnly) {
+    logger.error("--plain-only and --synced-only flags cannot be used together.");
+    return null;
+  }
+  let targetType = "PREFER_SYNCED" /* PREFER_SYNCED */;
+  if (options.plainOnly) {
+    targetType = "PLAINTEXT" /* PLAINTEXT */;
+  } else if (options.syncedOnly) {
+    targetType = "SYNCED_ONLY" /* SYNCED_ONLY */;
+  }
+  const lyrics = new Lyrics();
+  const providerInstances = [
+    new Musixmatch({
+      lang: options.lang,
+      enhanced: options.enhanced,
+      musixmatchToken: options.musixmatchToken,
+      timeoutMs: options.timeoutMs,
+      verbose: options.verbose
+    }),
+    new Lrclib({
+      timeoutMs: options.timeoutMs,
+      verbose: options.verbose
+    }),
+    new NetEase({
+      timeoutMs: options.timeoutMs,
+      verbose: options.verbose
+    }),
+    new Megalobiz({
+      timeoutMs: options.timeoutMs,
+      verbose: options.verbose
+    }),
+    new Genius({
+      timeoutMs: options.timeoutMs,
+      verbose: options.verbose
+    })
+  ];
+  const selectedProviders = selectProviders(providerInstances, options.providers, logger);
+  for (const provider of selectedProviders) {
+    logger.debug(`Looking for an LRC on ${provider.name}`);
+    try {
+      const result = await provider.getLrc(searchTerm);
+      if (result) {
+        lyrics.update(result);
+      }
+    } catch (err) {
+      logger.error(`An error occurred while searching for an LRC on ${provider.name}:`, err?.message ?? err);
+      if (options.lang) {
+        logger.error("Aborting, since `lang` is only supported by Musixmatch");
+        return null;
+      }
+      continue;
+    }
+    if (lyrics.isPreferred(targetType)) {
+      logger.info(`Lyrics found for "${searchTerm}" on ${provider.name}`);
+      break;
+    } else if (lyrics.isAcceptable(targetType)) {
+      logger.info(`Found plaintext lyrics on ${provider.name}, but continuing search for synced lyrics`);
+    } else {
+      logger.debug(`No suitable lyrics found on ${provider.name}, continuing search...`);
+    }
+  }
+  if (!lyrics.isAcceptable(targetType)) {
+    logger.info(`No suitable lyrics found for "${searchTerm}" :(`);
+    return null;
+  }
+  if (options.savePath) {
+    const formattedPath = options.savePath.replace(/{search_term}/g, searchTerm);
+    await lyrics.saveLrcFile(formattedPath, targetType);
+  }
+  return lyrics.toStr(targetType);
+}
+function selectProviders(allProviders, requestedNames, logger) {
+  if (!requestedNames || requestedNames.length === 0) {
+    return allProviders;
+  }
+  const lookup = new Set(requestedNames.map((name) => name.toLowerCase().trim()));
+  const filtered = allProviders.filter((p) => lookup.has(p.name.toLowerCase()));
+  if (filtered.length === 0) {
+    logger?.error(
+      `Providers [${requestedNames.join(", ")}] not found in the list of available providers.`
+    );
+    return [];
+  }
+  return filtered;
+}
+var synco = Object.assign(
+  function(searchTerm, options) {
+    return search(searchTerm, options);
+  },
+  {
+    search,
+    Lyrics,
+    TargetType,
+    LRCProvider,
+    Lrclib,
+    Megalobiz,
+    Musixmatch,
+    NetEase,
+    Genius,
+    Deezer,
+    Lyricsify
+  }
+);
+
+// src/cli.ts
+async function runCli() {
+  const program = new import_commander.Command();
+  program.name("synco").description("Search for LRC format (synchronized lyrics) of a track").version("1.0.0", "-V, --version", "Output the version number").argument("<search_term>", 'The search term to find the track (e.g. "Song Name Artist")').option(
+    "-p, --providers <providers...>",
+    "Providers to include in the searching (e.g. lrclib megalobiz musixmatch netease genius)"
+  ).option("-l, --lang <lang>", "Language of the translation along with the lyrics").option("-o, --output <path>", "Path to save '.lrc' lyrics", "{search_term}.lrc").option("-v, --verbose", "Use this flag to show debug logs", false).option("--plain-only", "Only look for plain text (not synced) lyrics", false).option("--synced-only", "Only look for synced lyrics", false).option("--enhanced", "Returns word by word synced lyrics (if available)", false).option("--token <token>", "Musixmatch user token").action(async (searchTerm, opts) => {
+    try {
+      const lrc = await search(searchTerm, {
+        plainOnly: opts.plainOnly,
+        syncedOnly: opts.syncedOnly,
+        savePath: opts.output,
+        providers: opts.providers,
+        lang: opts.lang,
+        enhanced: opts.enhanced,
+        musixmatchToken: opts.token,
+        verbose: opts.verbose
+      });
+      if (lrc) {
+        console.log(lrc);
+      } else {
+        process.exitCode = 1;
+      }
+    } catch (err) {
+      console.error("Error:", err?.message ?? err);
+      process.exitCode = 1;
+    }
+  });
+  await program.parseAsync(process.argv);
+}
+runCli();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runCli
+});