@tiktool/live 2.4.3 → 2.4.5

package/dist/index.mjs

@@ -1,6 +1,76 @@
+// src/client.ts
+import { EventEmitter } from "events";
+import * as http from "http";
+import * as https from "https";
+import * as zlib from "zlib";
+import WebSocket from "ws";
+
 // src/proto.ts
 var encoder = new TextEncoder();
 var decoder = new TextDecoder();
+var TIKTOK_EMOTE_MAP = {
+  // Standard emojis
+  "happy": "\u{1F60A}",
+  "angry": "\u{1F621}",
+  "cry": "\u{1F622}",
+  "embarrassed": "\u{1F633}",
+  "surprised": "\u{1F62E}",
+  "wronged": "\u{1F61E}",
+  "shout": "\u{1F624}",
+  "flushed": "\u{1F633}",
+  "yummy": "\u{1F60B}",
+  "complacent": "\u{1F60C}",
+  "drool": "\u{1F924}",
+  "scream": "\u{1F631}",
+  "weep": "\u{1F62D}",
+  "speechless": "\u{1F636}",
+  "funnyface": "\u{1F92A}",
+  "laughwithtears": "\u{1F602}",
+  "wicked": "\u{1F608}",
+  "facewithrollingeyes": "\u{1F644}",
+  "sulk": "\u{1F612}",
+  "thinking": "\u{1F914}",
+  "lovely": "\u{1F970}",
+  "greedy": "\u{1F911}",
+  "wow": "\u{1F62F}",
+  "joyful": "\u{1F603}",
+  "hehe": "\u{1F601}",
+  "slap": "\u{1F44B}",
+  "tears": "\u{1F63F}",
+  "stun": "\u{1F635}",
+  "cute": "\u{1F97A}",
+  "blink": "\u{1F609}",
+  "disdain": "\u{1F60F}",
+  "astonish": "\u{1F632}",
+  "cool": "\u{1F60E}",
+  "excited": "\u{1F929}",
+  "proud": "\u{1F624}",
+  "smileface": "\u{1F60A}",
+  "evil": "\u{1F47F}",
+  "angel": "\u{1F607}",
+  "laugh": "\u{1F606}",
+  "pride": "\u{1F981}",
+  "nap": "\u{1F634}",
+  "loveface": "\u{1F60D}",
+  "awkward": "\u{1F62C}",
+  "shock": "\u{1F628}",
+  "funny": "\u{1F604}",
+  "rage": "\u{1F92C}",
+  // Common aliases used in TikTok LIVE
+  "laughcry": "\u{1F602}",
+  "heart": "\u2764\uFE0F",
+  "like": "\u{1F44D}",
+  "love": "\u{1F495}",
+  "shy": "\u{1F648}",
+  "smile": "\u{1F60A}"
+};
+function replaceEmotes(text, imageMap) {
+  return text.replace(/\[([a-zA-Z_]+)\]/g, (match, name) => {
+    const lower = name.toLowerCase();
+    const emoji = TIKTOK_EMOTE_MAP[lower];
+    return emoji || match;
+  });
+}
 function concatBytes(...arrays) {
   let totalLength = 0;
   for (const arr of arrays) totalLength += arr.length;
@@ -101,6 +171,10 @@ function getInt(fields, fn) {
   const f = fields.find((x) => x.fn === fn && x.wt === 0);
   return f ? Number(f.value) : 0;
 }
+function getIntStr(fields, fn) {
+  const f = fields.find((x) => x.fn === fn && x.wt === 0);
+  return f ? String(f.value) : "";
+}
 function getAllBytes(fields, fn) {
   return fields.filter((x) => x.fn === fn && x.wt === 2).map((x) => x.value);
 }
@@ -139,7 +213,7 @@ function looksLikeUsername(s) {
 }
 function parseUser(data) {
   const f = decodeProto(data);
-  const id = String(getInt(f, 1) || getStr(f, 1));
+  const id = getIntStr(f, 1) || getStr(f, 1);
   const nickname = getStr(f, 3) || getStr(f, 2);
   let uniqueId = "";
   const uid4 = getStr(f, 4);
@@ -194,9 +268,10 @@ function parseUser(data) {
 }
 function parseBattleTeamFromArmies(itemBuf) {
   const f = decodeProto(itemBuf);
-  const hostUserId = String(getInt(f, 1));
+  const hostUserId = getIntStr(f, 1) || "0";
   let teamScore = 0;
   const users = [];
+  let hostUser;
   const groups = getAllBytes(f, 2);
   for (const gb of groups) {
     try {
@@ -214,7 +289,19 @@ function parseBattleTeamFromArmies(itemBuf) {
     } catch {
     }
   }
-  return { hostUserId, score: teamScore, users };
+  for (const fieldNum of [3, 4, 5, 6, 7, 8]) {
+    if (hostUser) break;
+    const buf = getBytes(f, fieldNum);
+    if (!buf) continue;
+    try {
+      const parsed = parseUser(buf);
+      if (parsed && (parsed.nickname || parsed.uniqueId) && parsed.uniqueId !== parsed.id && looksLikeUsername(parsed.uniqueId || "")) {
+        hostUser = parsed;
+      }
+    } catch {
+    }
+  }
+  return { hostUserId, score: teamScore, users, hostUser };
 }
 function parseWebcastMessage(method, payload) {
   const f = decodeProto(payload);
@@ -232,7 +319,25 @@ function parseWebcastMessage(method, payload) {
     case "WebcastChatMessage": {
       const userBuf = getBytes(f, 2);
       const user = userBuf ? parseUser(userBuf) : { id: "0", nickname: "", uniqueId: "" };
-      return { ...base, type: "chat", user, comment: getStr(f, 3) };
+      const rawComment = getStr(f, 3);
+      const emoteImages = {};
+      for (const field of f) {
+        if (field.fn === 22 && field.wt === 2) {
+          try {
+            const ewi = decodeProto(field.value);
+            const emoteKey = getStr(ewi, 1);
+            const imgBuf = getBytes(ewi, 2);
+            if (imgBuf && emoteKey) {
+              const imgFields = decodeProto(imgBuf);
+              const url = getStr(imgFields, 1);
+              if (url) emoteImages[emoteKey] = url;
+            }
+          } catch {
+          }
+        }
+      }
+      const comment = replaceEmotes(rawComment, emoteImages);
+      return { ...base, type: "chat", user, comment };
     }
     case "WebcastMemberMessage": {
       const userBuf = getBytes(f, 2);
@@ -286,7 +391,7 @@ function parseWebcastMessage(method, payload) {
       const extraBuf = getBytes(f, 23);
       if (extraBuf) {
         const ef = decodeProto(extraBuf);
-        toUserId = String(getInt(ef, 8));
+        toUserId = getIntStr(ef, 8) || "";
       }
       const groupId = toUserId || getStr(f, 11);
       return {
@@ -329,10 +434,36 @@ function parseWebcastMessage(method, payload) {
       return { ...base, type: "roomUserSeq", totalViewers, viewerCount };
     }
     case "WebcastLinkMicBattle": {
-      const battleId = String(getInt(f, 1) || "");
-      const status = getInt(f, 2) || 1;
-      const battleDuration = getInt(f, 3);
+      const battleId = getIntStr(f, 2) || getIntStr(f, 1) || "";
+      const overallStatus = getInt(f, 4);
       const teams = [];
+      let battleDuration = 0;
+      let battleSettings;
+      const settingsBuf = getBytes(f, 3);
+      if (settingsBuf) {
+        try {
+          const sf = decodeProto(settingsBuf);
+          const startTimeMs = getInt(sf, 2);
+          const duration = getInt(sf, 3);
+          const phase = getInt(sf, 5);
+          const endTimeMs = getInt(sf, 10);
+          battleDuration = duration;
+          battleSettings = {
+            startTimeMs: startTimeMs || void 0,
+            duration: duration || void 0,
+            endTimeMs: endTimeMs || void 0
+          };
+        } catch {
+        }
+      }
+      const settingsPhase = settingsBuf ? (() => {
+        try {
+          return getInt(decodeProto(settingsBuf), 5);
+        } catch {
+          return 0;
+        }
+      })() : 0;
+      const status = settingsPhase || (overallStatus > 0 && overallStatus <= 10 ? overallStatus : 0) || 1;
       const battleUserBufs = getAllBytes(f, 10);
       for (const bub of battleUserBufs) {
         try {
@@ -353,6 +484,23 @@ function parseWebcastMessage(method, payload) {
         } catch {
         }
       }
+      if (teams.length === 0) {
+        const teamBufs5 = getAllBytes(f, 5);
+        for (const tb of teamBufs5) {
+          try {
+            const tf = decodeProto(tb);
+            const userId = getIntStr(tf, 1);
+            if (userId && userId !== "0") {
+              teams.push({
+                hostUserId: userId,
+                score: 0,
+                users: []
+              });
+            }
+          } catch {
+          }
+        }
+      }
       if (teams.length === 0) {
         const teamBufs7 = getAllBytes(f, 7);
         for (const tb of teamBufs7) {
@@ -362,10 +510,10 @@ function parseWebcastMessage(method, payload) {
           }
         }
       }
-      return { ...base, type: "battle", battleId, status, battleDuration, teams };
+      return { ...base, type: "battle", battleId, status, battleDuration, teams, battleSettings };
     }
     case "WebcastLinkMicArmies": {
-      const battleId = String(getInt(f, 1) || "");
+      const battleId = getIntStr(f, 1) || "";
       const battleStatus = getInt(f, 7);
       const teams = [];
       const itemBufs = getAllBytes(f, 3);
@@ -447,8 +595,7 @@ function parseWebcastMessage(method, payload) {
       const title = getStr(f, 4) || getStr(f, 2);
       return { ...base, type: "liveIntro", roomId, title };
     }
-    case "WebcastLinkMicMethod":
-    case "WebcastLinkmicBattleTaskMessage": {
+    case "WebcastLinkMicMethod": {
       const action = getStr(f, 1) || `action_${getInt(f, 1)}`;
       const users = [];
       const userBufs = getAllBytes(f, 2);
@@ -460,6 +607,155 @@ function parseWebcastMessage(method, payload) {
       }
       return { ...base, type: "linkMic", action, users };
     }
+    case "WebcastLinkmicBattleTaskMessage": {
+      const taskAction = getInt(f, 2);
+      const battleRefId = getIntStr(f, 20) || "";
+      let timerType = 0;
+      let remainingSeconds = 0;
+      let endTimestampS = 0;
+      const timerBuf = getBytes(f, 5);
+      if (timerBuf) {
+        try {
+          const tf = decodeProto(timerBuf);
+          timerType = getInt(tf, 1);
+          remainingSeconds = getInt(tf, 2);
+          endTimestampS = getInt(tf, 3);
+        } catch {
+        }
+      }
+      let multiplier = 0;
+      let missionDuration = 0;
+      let missionTarget = 0;
+      let missionType = "";
+      const bonusBuf = getBytes(f, 3);
+      if (bonusBuf) {
+        try {
+          const bf = decodeProto(bonusBuf);
+          const missionBuf = getBytes(bf, 1);
+          if (missionBuf) {
+            const mf = decodeProto(missionBuf);
+            missionTarget = getInt(mf, 1);
+            const items = getAllBytes(mf, 2);
+            for (const item of items) {
+              try {
+                const itemFields = decodeProto(item);
+                const descBuf = getBytes(itemFields, 2);
+                if (descBuf) {
+                  const descFields = decodeProto(descBuf);
+                  const paramBufs = getAllBytes(descFields, 2);
+                  for (const pb of paramBufs) {
+                    try {
+                      const pf = decodeProto(pb);
+                      const key = getStr(pf, 1);
+                      const val = getStr(pf, 2);
+                      if (key === "multi" && val) multiplier = parseInt(val) || 0;
+                      if (key === "dur" && val) missionDuration = parseInt(val) || 0;
+                      if (key === "sum" && val) missionTarget = parseInt(val) || missionTarget;
+                    } catch {
+                    }
+                  }
+                  const typeStr = getStr(descFields, 1);
+                  if (typeStr) missionType = typeStr;
+                }
+              } catch {
+              }
+            }
+            const countdownBuf = getBytes(mf, 3);
+            if (countdownBuf) {
+              try {
+                const cf = decodeProto(countdownBuf);
+                if (!missionDuration) missionDuration = getInt(cf, 2);
+              } catch {
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      if (!missionType) {
+        const descBuf6 = getBytes(f, 6);
+        if (descBuf6) {
+          try {
+            const d6 = decodeProto(descBuf6);
+            const innerBuf = getBytes(d6, 1);
+            if (innerBuf) {
+              const innerF = decodeProto(innerBuf);
+              const typeStr = getStr(innerF, 1);
+              if (typeStr) missionType = typeStr;
+              const paramBufs = getAllBytes(innerF, 2);
+              for (const pb of paramBufs) {
+                try {
+                  const pf = decodeProto(pb);
+                  const key = getStr(pf, 1);
+                  const val = getStr(pf, 2);
+                  if (key === "multi" && val) multiplier = parseInt(val) || 0;
+                  if (key === "sum" && val) missionTarget = parseInt(val) || missionTarget;
+                } catch {
+                }
+              }
+            }
+          } catch {
+          }
+        }
+      }
+      return {
+        ...base,
+        type: "battleTask",
+        taskAction,
+        battleRefId,
+        missionType,
+        multiplier,
+        missionDuration,
+        missionTarget,
+        remainingSeconds,
+        endTimestampS,
+        timerType
+      };
+    }
+    case "WebcastBarrageMessage": {
+      const fieldSummary = f.map((x) => `fn=${x.fn} wt=${x.wt} val=${x.wt === 0 ? x.value : x.wt === 2 ? `[bytes:${x.value.length}]` : x.value}`).join(" | ");
+      console.log(`[proto] WebcastBarrageMessage fields: ${fieldSummary}`);
+      const msgType = getInt(f, 3);
+      const duration = getInt(f, 4);
+      const displayType = getInt(f, 5);
+      const subType = getInt(f, 6);
+      let defaultPattern = "";
+      let content = "";
+      const contentBuf = getBytes(f, 2);
+      if (contentBuf) {
+        try {
+          const cf = decodeProto(contentBuf);
+          defaultPattern = getStr(cf, 1) || "";
+          const paramBufs = getAllBytes(cf, 2);
+          const params = [];
+          for (const pb of paramBufs) {
+            try {
+              const pf = decodeProto(pb);
+              const key = getStr(pf, 1);
+              const val = getStr(pf, 2);
+              if (key && val) params.push(`${key}=${val}`);
+            } catch {
+            }
+          }
+          if (params.length > 0) content = params.join(", ");
+        } catch {
+        }
+      }
+      if (!defaultPattern) {
+        defaultPattern = getStr(f, 1) || "";
+      }
+      console.log(`[proto] Barrage parsed: msgType=${msgType} subType=${subType} displayType=${displayType} duration=${duration} pattern="${defaultPattern}" content="${content}"`);
+      return {
+        ...base,
+        type: "barrage",
+        msgType,
+        subType,
+        displayType,
+        duration,
+        defaultPattern,
+        content
+      };
+    }
     default:
       return { ...base, type: "unknown", method };
   }
@@ -481,260 +777,30 @@ function parseWebcastResponse(payload) {
   return events;
 }
 
-// src/api.ts
+// src/client.ts
 var DEFAULT_UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
 var DEFAULT_SIGN_SERVER = "https://api.tik.tools";
-var pageCache = /* @__PURE__ */ new Map();
-var PAGE_CACHE_TTL = 5 * 60 * 1e3;
-async function resolveLivePage(uniqueId) {
-  const clean = uniqueId.replace(/^@/, "");
-  const cached = pageCache.get(clean);
-  if (cached && Date.now() - cached.ts < PAGE_CACHE_TTL) {
-    return cached.info;
-  }
-  try {
-    const resp = await fetch(`https://www.tiktok.com/@${clean}/live`, {
-      headers: {
-        "User-Agent": DEFAULT_UA,
-        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-        "Accept-Language": "en-US,en;q=0.9"
-      },
-      redirect: "follow"
+function httpGet(url, headers) {
+  return new Promise((resolve, reject) => {
+    const mod = url.startsWith("https") ? https : http;
+    const req = mod.get(url, { headers }, (res) => {
+      const chunks = [];
+      const enc = res.headers["content-encoding"];
+      const stream = enc === "gzip" || enc === "br" ? res.pipe(enc === "br" ? zlib.createBrotliDecompress() : zlib.createGunzip()) : res;
+      stream.on("data", (c) => chunks.push(c));
+      stream.on("end", () => resolve({
+        status: res.statusCode || 0,
+        headers: res.headers,
+        body: Buffer.concat(chunks)
+      }));
+      stream.on("error", reject);
     });
-    if (!resp.ok) return null;
-    let ttwid = "";
-    const setCookies = resp.headers.get("set-cookie") || "";
-    for (const part of setCookies.split(",")) {
-      const trimmed = part.trim();
-      if (trimmed.startsWith("ttwid=")) {
-        ttwid = trimmed.split(";")[0].split("=").slice(1).join("=");
-        break;
-      }
-    }
-    if (!ttwid && typeof resp.headers.getSetCookie === "function") {
-      for (const sc of resp.headers.getSetCookie()) {
-        if (typeof sc === "string" && sc.startsWith("ttwid=")) {
-          ttwid = sc.split(";")[0].split("=").slice(1).join("=");
-          break;
-        }
-      }
-    }
-    const html = await resp.text();
-    let roomId = "";
-    const sigiMatch = html.match(/id="SIGI_STATE"[^>]*>([^<]+)/);
-    if (sigiMatch) {
-      try {
-        const json = JSON.parse(sigiMatch[1]);
-        const jsonStr = JSON.stringify(json);
-        const m = jsonStr.match(/"roomId"\s*:\s*"(\d+)"/);
-        if (m) roomId = m[1];
-      } catch {
-      }
-    }
-    if (!roomId) {
-      const patterns = [
-        /"roomId"\s*:\s*"(\d+)"/,
-        /room_id[=/](\d{10,})/,
-        /"idStr"\s*:\s*"(\d{10,})"/
-      ];
-      for (const p of patterns) {
-        const m = html.match(p);
-        if (m) {
-          roomId = m[1];
-          break;
-        }
-      }
-    }
-    if (!roomId) return null;
-    const crMatch = html.match(/"clusterRegion"\s*:\s*"([^"]+)"/);
-    const clusterRegion = crMatch ? crMatch[1] : "";
-    const info = { roomId, ttwid, clusterRegion };
-    pageCache.set(clean, { info, ts: Date.now() });
-    return info;
-  } catch {
-  }
-  return null;
-}
-async function resolveRoomId(uniqueId) {
-  const info = await resolveLivePage(uniqueId);
-  return info?.roomId ?? null;
-}
-async function fetchSignedUrl(response) {
-  if (!response.signed_url) {
-    return null;
-  }
-  const headers = { ...response.headers || {} };
-  if (response.cookies) {
-    headers["Cookie"] = response.cookies;
-  }
-  const resp = await fetch(response.signed_url, { headers, redirect: "follow" });
-  const text = await resp.text();
-  try {
-    return JSON.parse(text);
-  } catch {
-    return null;
-  }
-}
-async function callApi(opts) {
-  const serverUrl = (opts.serverUrl || DEFAULT_SIGN_SERVER).replace(/\/$/, "");
-  const isGet = opts.method === "GET";
-  const ak = encodeURIComponent(opts.apiKey);
-  const url1 = isGet ? `${serverUrl}${opts.endpoint}?apiKey=${ak}&unique_id=${encodeURIComponent(opts.uniqueId)}` : `${serverUrl}${opts.endpoint}?apiKey=${ak}`;
-  const fetchOpts1 = isGet ? {} : {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ unique_id: opts.uniqueId, ...opts.extraBody })
-  };
-  const resp1 = await fetch(url1, fetchOpts1);
-  const data1 = await resp1.json();
-  if (data1.signed_url || data1.action === "fetch_signed_url") {
-    return fetchSignedUrl(data1);
-  }
-  if (data1.status_code === 0 && data1.action !== "resolve_required") {
-    return data1;
-  }
-  if (data1.action === "resolve_required") {
-    const roomId = await resolveRoomId(opts.uniqueId);
-    if (!roomId) return null;
-    const url2 = isGet ? `${serverUrl}${opts.endpoint}?apiKey=${ak}&room_id=${encodeURIComponent(roomId)}` : `${serverUrl}${opts.endpoint}?apiKey=${ak}`;
-    const fetchOpts2 = isGet ? {} : {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ room_id: roomId, ...opts.extraBody })
-    };
-    const resp2 = await fetch(url2, fetchOpts2);
-    const data2 = await resp2.json();
-    if (data2.signed_url || data2.action === "fetch_signed_url") {
-      return fetchSignedUrl(data2);
-    }
-    return data2;
-  }
-  return data1;
-}
-async function solvePuzzle(apiKey, puzzleB64, pieceB64, serverUrl) {
-  const base = (serverUrl || DEFAULT_SIGN_SERVER).replace(/\/$/, "");
-  const resp = await fetch(`${base}/captcha/solve/puzzle?apiKey=${encodeURIComponent(apiKey)}`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ puzzle: puzzleB64, piece: pieceB64 })
-  });
-  const data = await resp.json();
-  if (data.status_code !== 0) {
-    throw new Error(data.error || `Solver failed (status ${data.status_code})`);
-  }
-  return data.data;
-}
-async function solveRotate(apiKey, outerB64, innerB64, serverUrl) {
-  const base = (serverUrl || DEFAULT_SIGN_SERVER).replace(/\/$/, "");
-  const resp = await fetch(`${base}/captcha/solve/rotate?apiKey=${encodeURIComponent(apiKey)}`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ outer: outerB64, inner: innerB64 })
-  });
-  const data = await resp.json();
-  if (data.status_code !== 0) {
-    throw new Error(data.error || `Solver failed (status ${data.status_code})`);
-  }
-  return data.data;
-}
-async function solveShapes(apiKey, imageB64, serverUrl) {
-  const base = (serverUrl || DEFAULT_SIGN_SERVER).replace(/\/$/, "");
-  const resp = await fetch(`${base}/captcha/solve/shapes?apiKey=${encodeURIComponent(apiKey)}`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ image: imageB64 })
-  });
-  const data = await resp.json();
-  if (data.status_code !== 0) {
-    throw new Error(data.error || `Solver failed (status ${data.status_code})`);
-  }
-  return data.data;
-}
-
-// src/client.ts
-var DEFAULT_UA2 = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
-var DEFAULT_SIGN_SERVER2 = "https://api.tik.tools";
-var TypedEmitter = class {
-  _listeners = /* @__PURE__ */ new Map();
-  on(event, fn) {
-    const arr = this._listeners.get(event) || [];
-    arr.push(fn);
-    this._listeners.set(event, arr);
-    return this;
-  }
-  once(event, fn) {
-    const wrapper = (...args) => {
-      this.off(event, wrapper);
-      fn(...args);
-    };
-    return this.on(event, wrapper);
-  }
-  off(event, fn) {
-    const arr = this._listeners.get(event);
-    if (arr) {
-      this._listeners.set(event, arr.filter((l) => l !== fn));
-    }
-    return this;
-  }
-  emit(event, ...args) {
-    const arr = this._listeners.get(event);
-    if (!arr || arr.length === 0) return false;
-    for (const fn of [...arr]) fn(...args);
-    return true;
-  }
-  removeAllListeners(event) {
-    if (event) this._listeners.delete(event);
-    else this._listeners.clear();
-    return this;
-  }
-};
-async function gunzip(data) {
-  if (typeof DecompressionStream !== "undefined") {
-    const ds = new DecompressionStream("gzip");
-    const writer = ds.writable.getWriter();
-    const reader = ds.readable.getReader();
-    writer.write(data);
-    writer.close();
-    const chunks = [];
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      chunks.push(value);
-    }
-    return concatBytes(...chunks);
-  }
-  try {
-    const zlib = await import("zlib");
-    return new Promise((resolve, reject) => {
-      zlib.gunzip(data, (err, result) => {
-        if (err) reject(err);
-        else resolve(new Uint8Array(result));
-      });
+    req.on("error", reject);
+    req.setTimeout(15e3, () => {
+      req.destroy();
+      reject(new Error("Request timeout"));
     });
-  } catch {
-    return data;
-  }
-}
-var _zlib = null;
-var _zlibLoadAttempted = false;
-async function ensureZlib() {
-  if (_zlib) return _zlib;
-  if (_zlibLoadAttempted) return null;
-  _zlibLoadAttempted = true;
-  try {
-    _zlib = await import("zlib");
-  } catch {
-  }
-  return _zlib;
-}
-ensureZlib();
-function gunzipSync(data) {
-  if (!_zlib) return null;
-  try {
-    return new Uint8Array(_zlib.gunzipSync(data));
-  } catch {
-    return null;
-  }
+  });
 }
 function getWsHost(clusterRegion) {
   if (!clusterRegion) return "webcast-ws.tiktok.com";
@@ -743,21 +809,7 @@ function getWsHost(clusterRegion) {
   if (r.startsWith("us") || r.includes("us")) return "webcast-ws.us.tiktok.com";
   return "webcast-ws.tiktok.com";
 }
-async function resolveWebSocket(userImpl) {
-  if (userImpl) return userImpl;
-  if (typeof globalThis.WebSocket !== "undefined") {
-    return globalThis.WebSocket;
-  }
-  try {
-    const ws = await import("ws");
-    return ws.default || ws;
-  } catch {
-    throw new Error(
-      'No WebSocket implementation found. Either use Node.js 22+ (native WebSocket), Cloudflare Workers, or install the "ws" package: npm i ws'
-    );
-  }
-}
-var TikTokLive = class extends TypedEmitter {
+var TikTokLive = class extends EventEmitter {
   ws = null;
   heartbeatTimer = null;
   reconnectAttempts = 0;
@@ -765,7 +817,7 @@ var TikTokLive = class extends TypedEmitter {
   _connected = false;
   _eventCount = 0;
   _roomId = "";
-  _battleHosts = /* @__PURE__ */ new Map();
+  _ownerUserId = "";
   uniqueId;
   signServerUrl;
   apiKey;
@@ -773,30 +825,55 @@ var TikTokLive = class extends TypedEmitter {
   maxReconnectAttempts;
   heartbeatInterval;
   debug;
-  webSocketImpl;
-  WS;
   constructor(options) {
     super();
     this.uniqueId = options.uniqueId.replace(/^@/, "");
-    this.signServerUrl = (options.signServerUrl || DEFAULT_SIGN_SERVER2).replace(/\/$/, "");
+    this.signServerUrl = (options.signServerUrl || DEFAULT_SIGN_SERVER).replace(/\/$/, "");
     if (!options.apiKey) throw new Error("apiKey is required. Get a free key at https://tik.tools");
     this.apiKey = options.apiKey;
     this.autoReconnect = options.autoReconnect ?? true;
     this.maxReconnectAttempts = options.maxReconnectAttempts ?? 5;
     this.heartbeatInterval = options.heartbeatInterval ?? 1e4;
     this.debug = options.debug ?? false;
-    this.webSocketImpl = options.webSocketImpl;
   }
   async connect() {
     this.intentionalClose = false;
-    if (!this.WS) {
-      this.WS = await resolveWebSocket(this.webSocketImpl);
+    const resp = await httpGet(`https://www.tiktok.com/@${this.uniqueId}/live`, {
+      "User-Agent": DEFAULT_UA,
+      "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+      "Accept-Encoding": "gzip, deflate, br",
+      "Accept-Language": "en-US,en;q=0.9"
+    });
+    let ttwid = "";
+    for (const sc of [resp.headers["set-cookie"] || []].flat()) {
+      if (typeof sc === "string" && sc.startsWith("ttwid=")) {
+        ttwid = sc.split(";")[0].split("=").slice(1).join("=");
+        break;
+      }
+    }
+    if (!ttwid) throw new Error("Failed to obtain session cookie");
+    const html = resp.body.toString();
+    let roomId = "";
+    let ownerUserId = "";
+    const sigiMatch = html.match(/id="SIGI_STATE"[^>]*>([^<]+)/);
+    if (sigiMatch) {
+      try {
+        const json = JSON.parse(sigiMatch[1]);
+        const jsonStr = JSON.stringify(json);
+        const m = jsonStr.match(/"roomId"\s*:\s*"(\d+)"/);
+        if (m) roomId = m[1];
+        const ownerUser = json?.LiveRoom?.liveRoomUserInfo?.user;
+        if (ownerUser?.id) {
+          ownerUserId = String(ownerUser.id);
+        }
+      } catch {
+      }
     }
-    const pageInfo = await resolveLivePage(this.uniqueId);
-    if (!pageInfo) throw new Error(`User @${this.uniqueId} is not currently live`);
-    if (!pageInfo.ttwid) throw new Error("Failed to obtain session cookie");
-    const { roomId, ttwid, clusterRegion } = pageInfo;
+    if (!roomId) throw new Error(`User @${this.uniqueId} is not currently live`);
     this._roomId = roomId;
+    this._ownerUserId = ownerUserId;
+    const crMatch = html.match(/"clusterRegion"\s*:\s*"([^"]+)"/);
+    const clusterRegion = crMatch ? crMatch[1] : "";
     const wsHost = getWsHost(clusterRegion);
     const wsParams = new URLSearchParams({
       version_code: "270000",
@@ -807,9 +884,9 @@ var TikTokLive = class extends TypedEmitter {
       browser_language: "en-US",
       browser_platform: "Win32",
       browser_name: "Mozilla",
-      browser_version: DEFAULT_UA2.split("Mozilla/")[1] || "5.0",
+      browser_version: DEFAULT_UA.split("Mozilla/")[1] || "5.0",
       browser_online: "true",
-      tz_name: "Etc/UTC",
+      tz_name: Intl.DateTimeFormat().resolvedOptions().timeZone,
       app_name: "tiktok_web",
       sup_ws_ds_opt: "1",
       update_version_code: "2.0.0",
@@ -850,71 +927,48 @@ var TikTokLive = class extends TypedEmitter {
       wsUrl = rawWsUrl.replace(/^https:\/\//, "wss://");
     }
     return new Promise((resolve, reject) => {
-      const connUrl = wsUrl + (wsUrl.includes("?") ? "&" : "?") + `ttwid=${ttwid}`;
-      try {
-        this.ws = new this.WS(connUrl, {
-          headers: {
-            "User-Agent": DEFAULT_UA2,
-            "Cookie": `ttwid=${ttwid}`,
-            "Origin": "https://www.tiktok.com"
-          }
-        });
-      } catch {
-        this.ws = new this.WS(connUrl);
-      }
-      const ws = this.ws;
-      let settled = false;
-      ws.onopen = () => {
+      this.ws = new WebSocket(wsUrl, {
+        headers: {
+          "User-Agent": DEFAULT_UA,
+          "Cookie": `ttwid=${ttwid}`,
+          "Origin": "https://www.tiktok.com"
+        }
+      });
+      this.ws.on("open", () => {
         this._connected = true;
         this.reconnectAttempts = 0;
-        const hb = buildHeartbeat(roomId);
-        const enter = buildImEnterRoom(roomId);
-        ws.send(hb.buffer.byteLength === hb.length ? hb.buffer : hb.buffer.slice(hb.byteOffset, hb.byteOffset + hb.byteLength));
-        ws.send(enter.buffer.byteLength === enter.length ? enter.buffer : enter.buffer.slice(enter.byteOffset, enter.byteOffset + enter.byteLength));
+        this.ws.send(buildHeartbeat(roomId));
+        this.ws.send(buildImEnterRoom(roomId));
         this.startHeartbeat(roomId);
         const roomInfo = {
           roomId,
           wsHost,
           clusterRegion,
-          connectedAt: (/* @__PURE__ */ new Date()).toISOString()
+          connectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          ownerUserId: ownerUserId || void 0
         };
         this.emit("connected");
         this.emit("roomInfo", roomInfo);
-        if (!settled) {
-          settled = true;
-          resolve();
-        }
-      };
-      ws.onmessage = (event) => {
-        const raw = event.data !== void 0 ? event.data : event;
-        this.handleMessage(raw);
-      };
-      ws.onclose = (event) => {
+        resolve();
+      });
+      this.ws.on("message", (rawData) => {
+        this.handleFrame(Buffer.from(rawData));
+      });
+      this.ws.on("close", (code, reason) => {
         this._connected = false;
         this.stopHeartbeat();
-        const code = event?.code ?? 1006;
-        const reason = event?.reason ?? "";
-        this.emit("disconnected", code, reason?.toString?.() || "");
+        const reasonStr = reason?.toString() || "";
+        this.emit("disconnected", code, reasonStr);
         if (!this.intentionalClose && this.autoReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
           this.reconnectAttempts++;
           const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts - 1), 3e4);
           setTimeout(() => this.connect().catch((e) => this.emit("error", e)), delay);
         }
-      };
-      ws.onerror = (err) => {
-        this.emit("error", err instanceof Error ? err : new Error(String(err?.message || err)));
-        if (!settled) {
-          settled = true;
-          reject(err);
-        }
-      };
-      setTimeout(() => {
-        if (!settled) {
-          settled = true;
-          ws.close();
-          reject(new Error("Connection timeout"));
-        }
-      }, 15e3);
+      });
+      this.ws.on("error", (err) => {
+        this.emit("error", err);
+        if (!this._connected) reject(err);
+      });
     });
   }
   disconnect() {
@@ -947,69 +1001,27 @@ var TikTokLive = class extends TypedEmitter {
   emit(event, ...args) {
     return super.emit(event, ...args);
   }
-  async handleMessage(raw) {
-    try {
-      let bytes;
-      if (raw instanceof ArrayBuffer) {
-        bytes = new Uint8Array(raw);
-      } else if (raw instanceof Uint8Array) {
-        bytes = raw;
-      } else if (typeof Blob !== "undefined" && raw instanceof Blob) {
-        bytes = new Uint8Array(await raw.arrayBuffer());
-      } else if (raw?.buffer instanceof ArrayBuffer) {
-        bytes = new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength);
-      } else {
-        return;
-      }
-      this.handleFrame(bytes);
-    } catch {
-    }
-  }
-  async handleFrame(buf) {
+  handleFrame(buf) {
     try {
       const fields = decodeProto(buf);
       const idField = fields.find((f) => f.fn === 2 && f.wt === 0);
       const id = idField ? idField.value : 0n;
       const type = getStr(fields, 7);
       const binary = getBytes(fields, 8);
-      if (id > 0n && this.ws && this.ws.readyState === 1) {
-        const ack = buildAck(id);
-        this.ws.send(ack.buffer.byteLength === ack.length ? ack.buffer : ack.buffer.slice(ack.byteOffset, ack.byteOffset + ack.byteLength));
+      if (id > 0n && this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(buildAck(id));
       }
       if (type === "msg" && binary && binary.length > 0) {
         let inner = binary;
         if (inner.length > 2 && inner[0] === 31 && inner[1] === 139) {
-          const syncResult = gunzipSync(inner);
-          if (syncResult) {
-            inner = syncResult;
-          } else {
-            inner = await gunzip(inner);
+          try {
+            inner = zlib.gunzipSync(inner);
+          } catch {
           }
         }
         const events = parseWebcastResponse(inner);
         for (const evt of events) {
           this._eventCount++;
-          if (evt.type === "battle") {
-            for (const team of evt.teams) {
-              const host = team.users.find((u) => u.user.id === team.hostUserId);
-              if (host) {
-                this._battleHosts.set(team.hostUserId, host.user);
-                team.hostUser = host.user;
-              }
-            }
-          }
-          if (evt.type === "battleArmies") {
-            for (const team of evt.teams) {
-              const host = team.users.find((u) => u.user.id === team.hostUserId);
-              if (host) {
-                team.hostUser = host.user;
-                this._battleHosts.set(team.hostUserId, host.user);
-              } else {
-                const cached = this._battleHosts.get(team.hostUserId);
-                if (cached) team.hostUser = cached;
-              }
-            }
-          }
           this.emit("event", evt);
           this.emit(evt.type, evt);
         }
@@ -1020,9 +1032,8 @@ var TikTokLive = class extends TypedEmitter {
   startHeartbeat(roomId) {
     this.stopHeartbeat();
     this.heartbeatTimer = setInterval(() => {
-      if (this.ws && this.ws.readyState === 1) {
-        const hb = buildHeartbeat(roomId);
-        this.ws.send(hb.buffer.byteLength === hb.length ? hb.buffer : hb.buffer.slice(hb.byteOffset, hb.byteOffset + hb.byteLength));
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(buildHeartbeat(roomId));
       }
     }, this.heartbeatInterval);
   }
@@ -1033,14 +1044,60 @@ var TikTokLive = class extends TypedEmitter {
     }
   }
 };
+
+// src/api.ts
+var DEFAULT_SIGN_SERVER2 = "https://api.tik.tools";
+var PAGE_CACHE_TTL = 5 * 60 * 1e3;
+async function getRanklist(opts) {
+  const base = (opts.serverUrl || DEFAULT_SIGN_SERVER2).replace(/\/$/, "");
+  const ak = encodeURIComponent(opts.apiKey);
+  const body = {};
+  if (opts.uniqueId) body.unique_id = opts.uniqueId;
+  if (opts.roomId) body.room_id = opts.roomId;
+  if (opts.anchorId) body.anchor_id = opts.anchorId;
+  if (opts.sessionCookie) body.session_cookie = opts.sessionCookie;
+  if (opts.type) body.type = opts.type;
+  if (opts.rankType) body.rank_type = opts.rankType;
+  const resp = await fetch(`${base}/webcast/ranklist?apiKey=${ak}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  const data = await resp.json();
+  if (data.status_code === 20003) {
+    throw new Error(
+      data.message || "TikTok requires login. Provide sessionCookie with your TikTok session."
+    );
+  }
+  if (data.status_code !== 0) {
+    throw new Error(data.error || `Ranklist failed (status ${data.status_code})`);
+  }
+  return data.data;
+}
+async function getRegionalRanklist(opts) {
+  const base = (opts.serverUrl || DEFAULT_SIGN_SERVER2).replace(/\/$/, "");
+  const ak = encodeURIComponent(opts.apiKey);
+  const body = {};
+  if (opts.uniqueId) body.unique_id = opts.uniqueId;
+  if (opts.roomId) body.room_id = opts.roomId;
+  if (opts.anchorId) body.anchor_id = opts.anchorId;
+  if (opts.rankType) body.rank_type = opts.rankType;
+  if (opts.type) body.type = opts.type;
+  if (opts.gapInterval) body.gap_interval = opts.gapInterval;
+  const resp = await fetch(`${base}/webcast/ranklist/regional?apiKey=${ak}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  const data = await resp.json();
+  if (data.status_code !== 0) {
+    throw new Error(data.error || `Regional ranklist failed (status ${data.status_code})`);
+  }
+  return data;
+}
 export {
   TikTokLive,
-  callApi,
-  fetchSignedUrl,
-  resolveLivePage,
-  resolveRoomId,
-  solvePuzzle,
-  solveRotate,
-  solveShapes
+  getRanklist,
+  getRegionalRanklist
 };
 //# sourceMappingURL=index.mjs.map