@nxgiang/tiktok-api 1.3.7

package/lib/index.d.ts

@@ -0,0 +1,93 @@
+import { TiktokAPIResponse } from "./types/downloader/tiktokApiDownloader";
+import { SSSTikResponse } from "./types/downloader/ssstikDownloader";
+import { MusicalDownResponse } from "./types/downloader/musicaldownDownloader";
+import { UserSearchResult } from "./types/search/userSearch";
+import { LiveSearchResult } from "./types/search/liveSearch";
+import { VideoSearchResult } from "./types/search/videoSearch";
+import { TiktokStalkUserResponse } from "./types/get/getProfile";
+import { TiktokVideoCommentsResponse } from "./types/get/getComments";
+import { TiktokUserPostsResponse } from "./types/get/getUserPosts";
+import { TiktokUserRepostsResponse } from "./types/get/getUserReposts";
+import { TiktokUserFavoriteVideosResponse } from "./types/get/getUserLiked";
+import { TiktokCollectionResponse } from "./types/get/getCollection";
+import { TiktokTrendingResponse, TrendingCreator } from "./types/get/getTrendings";
+import { TiktokMusicVideosResponse } from "./types/get/getMusicVideos";
+import { TiktokMusicDetailResponse } from "./types/get/getMusicDetail";
+import { TiktokPlaylistResponse } from "./types/get/getPlaylist";
+type DownloaderVersion = "v1" | "v2" | "v3";
+type SearchType = "user" | "live" | "video";
+type TiktokDownloaderResponse<T extends DownloaderVersion> = T extends "v1" ? TiktokAPIResponse : T extends "v2" ? SSSTikResponse : T extends "v3" ? MusicalDownResponse : TiktokAPIResponse;
+type SearchResult<T extends SearchType> = {
+    type: T;
+} & (T extends "user" ? UserSearchResult : T extends "live" ? LiveSearchResult : VideoSearchResult);
+type TiktokSearchResponse<T extends SearchType> = {
+    status: "success" | "error";
+    message?: string;
+    result?: SearchResult<T>[];
+    page?: number;
+    totalResults?: number;
+};
+declare const _default: {
+    Downloader: <T extends DownloaderVersion>(url: string, options?: {
+        version: T;
+        proxy?: string;
+        showOriginalResponse?: boolean;
+    }) => Promise<TiktokDownloaderResponse<T>>;
+    Search: <T extends SearchType>(keyword: string, options?: {
+        type?: T;
+        cookie: string | any[];
+        page?: number;
+        proxy?: string;
+    }) => Promise<TiktokSearchResponse<T>>;
+    StalkUser: (username: string, options?: {
+        proxy?: string;
+    }) => Promise<TiktokStalkUserResponse>;
+    GetVideoComments: (url: string, options?: {
+        commentLimit?: number;
+        proxy?: string;
+    }) => Promise<TiktokVideoCommentsResponse>;
+    GetUserPosts: (username: string, options?: {
+        postLimit?: number;
+        proxy?: string;
+    }) => Promise<TiktokUserPostsResponse>;
+    GetUserLiked: (username: string, options: {
+        cookie: string | any[];
+        postLimit?: number;
+        proxy?: string;
+    }) => Promise<TiktokUserFavoriteVideosResponse>;
+    GetUserReposts: (username: string, options?: {
+        postLimit?: number;
+        proxy?: string;
+        filterDeletedPost?: boolean;
+    }) => Promise<TiktokUserRepostsResponse>;
+    Collection: (collectionIdOrUrl: string, options?: {
+        proxy?: string;
+        page?: number;
+        count?: number;
+    }) => Promise<TiktokCollectionResponse>;
+    Playlist: (playlistIdOrUrl: string, options?: {
+        proxy?: string;
+        page?: number;
+        count?: number;
+    }) => Promise<TiktokPlaylistResponse>;
+    Trending: (options?: {
+        proxy?: string;
+    }) => Promise<TiktokTrendingResponse>;
+    GetVideosByMusicId: (musicIdOrUrl: string, options?: {
+        proxy?: string;
+        page?: number;
+        count?: number;
+    }) => Promise<TiktokMusicVideosResponse>;
+    GetMusicDetail: (musicIdOrUrl: string, options: {
+        cookie: string | any[];
+        proxy?: string;
+    }) => Promise<TiktokMusicDetailResponse>;
+    TrendingCreators: (options?: {
+        proxy?: string;
+    }) => Promise<{
+        status: "success" | "error";
+        message?: string;
+        result?: TrendingCreator[];
+    }>;
+};
+export = _default;

package/lib/index.js

@@ -0,0 +1,137 @@
+"use strict";
+const tiktokAPIDownloader_1 = require("./utils/downloader/tiktokAPIDownloader");
+const ssstikDownloader_1 = require("./utils/downloader/ssstikDownloader");
+const musicaldownDownloader_1 = require("./utils/downloader/musicaldownDownloader");
+const getProfile_1 = require("./utils/get/getProfile");
+const userSearch_1 = require("./utils/search/userSearch");
+const liveSearch_1 = require("./utils/search/liveSearch");
+const getComments_1 = require("./utils/get/getComments");
+const getUserPosts_1 = require("./utils/get/getUserPosts");
+const getUserRepost_1 = require("./utils/get/getUserRepost");
+const getUserLiked_1 = require("./utils/get/getUserLiked");
+const videoSearch_1 = require("./utils/search/videoSearch");
+const getCollection_1 = require("./utils/get/getCollection");
+const getTrendings_1 = require("./utils/get/getTrendings");
+const getMusicVideos_1 = require("./utils/get/getMusicVideos");
+const getMusicDetail_1 = require("./utils/get/getMusicDetail");
+const constants_1 = require("./constants");
+const constants_2 = require("./constants");
+const validator_1 = require("./utils/validator");
+const getPlaylist_1 = require("./utils/get/getPlaylist");
+const urlExtractors_1 = require("./utils/urlExtractors");
+const handleError = (message) => {
+    return {
+        status: "error",
+        message
+    };
+};
+module.exports = {
+    Downloader: async (url, options) => {
+        const version = options?.version?.toLowerCase();
+        switch (version) {
+            case constants_1.DOWNLOADER_VERSIONS.V1:
+                return (await (0, tiktokAPIDownloader_1.TiktokAPI)(url, options?.proxy, options?.showOriginalResponse));
+            case constants_1.DOWNLOADER_VERSIONS.V2:
+                return (await (0, ssstikDownloader_1.SSSTik)(url, options?.proxy));
+            case constants_1.DOWNLOADER_VERSIONS.V3:
+                return (await (0, musicaldownDownloader_1.MusicalDown)(url, options?.proxy));
+            default:
+                return (await (0, tiktokAPIDownloader_1.TiktokAPI)(url, options?.proxy, options?.showOriginalResponse));
+        }
+    },
+    Search: async (keyword, options) => {
+        try {
+            const type = options?.type?.toLowerCase();
+            if (!type || !Object.values(constants_1.SEARCH_TYPES).includes(type)) {
+                throw new Error(constants_2.ERROR_MESSAGES.INVALID_SEARCH_TYPE);
+            }
+            switch (type) {
+                case constants_1.SEARCH_TYPES.USER:
+                    const userResults = await (0, userSearch_1.SearchUser)(keyword, options.cookie, options?.page, options?.proxy);
+                    return {
+                        ...userResults,
+                        result: userResults.result?.map((user) => ({
+                            type: "user",
+                            ...user
+                        }))
+                    };
+                case constants_1.SEARCH_TYPES.LIVE:
+                    const liveResults = await (0, liveSearch_1.SearchLive)(keyword, options.cookie, options?.page, options?.proxy);
+                    return {
+                        ...liveResults,
+                        result: liveResults.result?.map((live) => ({
+                            type: "live",
+                            ...live
+                        }))
+                    };
+                case constants_1.SEARCH_TYPES.VIDEO:
+                    const videoResults = await (0, videoSearch_1.SearchVideo)(keyword, options.cookie, options?.page, options?.proxy);
+                    return {
+                        ...videoResults,
+                        result: videoResults.result?.map((video) => ({
+                            type: "video",
+                            ...video
+                        }))
+                    };
+                default:
+                    throw new Error(constants_2.ERROR_MESSAGES.INVALID_SEARCH_TYPE);
+            }
+        }
+        catch (error) {
+            return {
+                status: "error",
+                message: error.message
+            };
+        }
+    },
+    StalkUser: async (username, options) => {
+        return await (0, getProfile_1.StalkUser)(username, options?.proxy);
+    },
+    GetVideoComments: async (url, options) => {
+        return await (0, getComments_1.getComments)(url, options?.proxy, options?.commentLimit);
+    },
+    GetUserPosts: async (username, options) => {
+        return await (0, getUserPosts_1.getUserPosts)(username, options?.proxy, options?.postLimit);
+    },
+    GetUserLiked: async (username, options) => {
+        if (!(0, validator_1.validateCookie)(options?.cookie)) {
+            return handleError(constants_2.ERROR_MESSAGES.COOKIE_REQUIRED);
+        }
+        return await (0, getUserLiked_1.getUserLiked)(username, options.cookie, options?.proxy, options?.postLimit);
+    },
+    GetUserReposts: async (username, options) => {
+        return await (0, getUserRepost_1.getUserReposts)(username, options?.proxy, options?.postLimit, options?.filterDeletedPost);
+    },
+    Collection: async (collectionIdOrUrl, options) => {
+        const collectionId = (0, urlExtractors_1.extractCollectionId)(collectionIdOrUrl);
+        if (!collectionId) {
+            return {
+                status: "error",
+                message: "Invalid collection ID or URL format"
+            };
+        }
+        return await (0, getCollection_1.getCollection)(collectionId, options?.proxy, options?.page, options?.count);
+    },
+    Playlist: async (playlistIdOrUrl, options) => {
+        const playlistId = (0, urlExtractors_1.extractPlaylistId)(playlistIdOrUrl);
+        if (!playlistId) {
+            return {
+                status: "error",
+                message: "Invalid playlist ID or URL format"
+            };
+        }
+        return await (0, getPlaylist_1.getPlaylist)(playlistId, options?.proxy, options?.page, options?.count);
+    },
+    Trending: async (options) => {
+        return await (0, getTrendings_1.getTrendings)(options?.proxy);
+    },
+    GetVideosByMusicId: async (musicIdOrUrl, options) => {
+        return await (0, getMusicVideos_1.getMusicVideos)(musicIdOrUrl, options?.proxy, options?.page, options?.count);
+    },
+    GetMusicDetail: async (musicIdOrUrl, options) => {
+        return await (0, getMusicDetail_1.getMusicDetail)(musicIdOrUrl, options.cookie, options?.proxy);
+    },
+    TrendingCreators: async (options) => {
+        return await (0, getTrendings_1.getTrendingCreators)(options?.proxy);
+    }
+};

package/lib/lib/logger.d.ts

@@ -0,0 +1,8 @@
+import chalk from "chalk";
+export declare class Logger {
+    static success(message: string): void;
+    static error(message: string): void;
+    static info(message: string): void;
+    static warning(message: string): void;
+    static result(message: string, color?: chalk.Chalk): void;
+}

package/lib/lib/logger.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+class Logger {
+    static success(message) {
+        console.log(chalk_1.default.green("✓  " + message));
+    }
+    static error(message) {
+        console.error(chalk_1.default.red("✗  " + message));
+    }
+    static info(message) {
+        console.log(chalk_1.default.blue("ℹ  " + message));
+    }
+    static warning(message) {
+        console.log(chalk_1.default.yellow("⚠  " + message));
+    }
+    static result(message, color = chalk_1.default.cyan) {
+        console.log(color(message));
+    }
+}
+exports.Logger = Logger;

package/lib/services/cookieManager.d.ts

@@ -0,0 +1,10 @@
+export declare class CookieManager {
+    private cookieFile;
+    private cookieData;
+    constructor();
+    private loadCookies;
+    private saveCookies;
+    setCookie(value: string): void;
+    getCookie(): string | null;
+    deleteCookie(): void;
+}

package/lib/services/cookieManager.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CookieManager = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class CookieManager {
+    constructor() {
+        const homeDir = process.env.HOME || process.env.USERPROFILE;
+        const cookieDir = path_1.default.join(homeDir, ".tiktok-api");
+        if (!fs_1.default.existsSync(cookieDir)) {
+            fs_1.default.mkdirSync(cookieDir, { recursive: true });
+        }
+        this.cookieFile = path_1.default.join(cookieDir, "cookies.json");
+        this.cookieData = this.loadCookies();
+    }
+    loadCookies() {
+        try {
+            if (fs_1.default.existsSync(this.cookieFile)) {
+                const data = fs_1.default.readFileSync(this.cookieFile, "utf8");
+                return JSON.parse(data);
+            }
+        }
+        catch (error) {
+            console.error("Error loading cookies:", error);
+        }
+        return {};
+    }
+    saveCookies() {
+        try {
+            fs_1.default.writeFileSync(this.cookieFile, JSON.stringify(this.cookieData, null, 2));
+        }
+        catch (error) {
+            console.error("Error saving cookies:", error);
+        }
+    }
+    setCookie(value) {
+        this.cookieData["tiktok"] = value;
+        this.saveCookies();
+    }
+    getCookie() {
+        return this.cookieData["tiktok"] || null;
+    }
+    deleteCookie() {
+        delete this.cookieData["tiktok"];
+        this.saveCookies();
+    }
+}
+exports.CookieManager = CookieManager;

package/lib/services/downloadManager.d.ts

@@ -0,0 +1,5 @@
+declare function getDefaultDownloadPath(): string;
+declare function downloadMedia(url: string, outputPath: string, filename: string, cookie?: string): Promise<void>;
+declare function handleMediaDownload(data: any, outputPath: string, version: string): Promise<void>;
+declare function downloadMusicFromDetail(musicIdOrUrl: string, cookie: string | any[], outputPath: string, proxy?: string): Promise<void>;
+export { getDefaultDownloadPath, downloadMedia, handleMediaDownload, downloadMusicFromDetail };

package/lib/services/downloadManager.js

@@ -0,0 +1,188 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultDownloadPath = getDefaultDownloadPath;
+exports.downloadMedia = downloadMedia;
+exports.handleMediaDownload = handleMediaDownload;
+exports.downloadMusicFromDetail = downloadMusicFromDetail;
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const axios_1 = __importDefault(require("axios"));
+const fs = __importStar(require("fs"));
+const logger_1 = require("../lib/logger");
+function getDefaultDownloadPath() {
+    const platform = os.platform();
+    const homeDir = os.homedir();
+    switch (platform) {
+        case "win32":
+            return path.join(homeDir, "Downloads");
+        case "darwin":
+            return path.join(homeDir, "Downloads");
+        case "linux":
+            if (process.env.PREFIX && process.env.PREFIX.includes("com.termux")) {
+                return path.join(homeDir, "storage", "downloads");
+            }
+            return path.join(homeDir, "Downloads");
+        case "android":
+            if (process.env.EXTERNAL_STORAGE) {
+                return path.join(process.env.EXTERNAL_STORAGE, "Download");
+            }
+            return path.join(homeDir, "Download");
+        default:
+            const possiblePaths = [
+                path.join(homeDir, "Downloads"),
+                path.join(homeDir, "Download"),
+                path.join(homeDir, "downloads"),
+                homeDir
+            ];
+            for (const downloadPath of possiblePaths) {
+                if (fs.existsSync(downloadPath)) {
+                    return downloadPath;
+                }
+            }
+            return path.join(homeDir, "Downloads");
+    }
+}
+async function downloadMedia(url, outputPath, filename, cookie) {
+    try {
+        const headers = {};
+        if (cookie) {
+            headers.Cookie = Array.isArray(cookie) ? cookie.join("; ") : cookie;
+            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";
+            headers.Referer = "https://www.tiktok.com/";
+        }
+        const response = await (0, axios_1.default)({
+            method: "GET",
+            url: url,
+            responseType: "stream",
+            headers: headers
+        });
+        if (!fs.existsSync(outputPath)) {
+            fs.mkdirSync(outputPath, { recursive: true });
+        }
+        const writer = fs.createWriteStream(path.join(outputPath, filename));
+        response.data.pipe(writer);
+        return new Promise((resolve, reject) => {
+            writer.on("finish", resolve);
+            writer.on("error", reject);
+        });
+    }
+    catch (error) {
+        throw new Error(`Failed to download media: ${error.message}`);
+    }
+}
+async function handleMediaDownload(data, outputPath, version) {
+    if (data.status !== "success") {
+        throw new Error(data.message);
+    }
+    const { result } = data;
+    const author = result.author;
+    const username = version === "v1" ? author.username : author?.nickname || "";
+    logger_1.Logger.success(`${result.type.charAt(0).toUpperCase() + result.type.slice(1)} Successfully Fetched!`);
+    logger_1.Logger.info(`Media Type: ${result.type}`);
+    switch (result.type) {
+        case "video": {
+            const videoUrl = version === "v1"
+                ? result.video.playAddr[0]
+                : version === "v2"
+                    ? result.video.playAddr[0]
+                    : result.videoHD;
+            const videoName = `ttdl_${username}_${Date.now()}.mp4`;
+            logger_1.Logger.info("Downloading video...");
+            await downloadMedia(videoUrl, outputPath, videoName);
+            logger_1.Logger.success(`Video downloaded successfully to: ${path.join(outputPath, videoName)}`);
+            break;
+        }
+        case "image": {
+            const userOutputPath = path.join(outputPath, `${username}_${Date.now()}`);
+            const images = result.images;
+            for (let i = 0; i < images.length; i++) {
+                const imageName = `ttdl_${username}_${Date.now()}_${i + 1}.png`;
+                logger_1.Logger.info(`Downloading image ${i + 1}/${images.length}...`);
+                await downloadMedia(images[i], userOutputPath, imageName);
+                logger_1.Logger.success(`Image downloaded successfully to: ${path.join(userOutputPath, imageName)}`);
+            }
+            break;
+        }
+        case "music": {
+            const musicName = `ttdl_${username}_${Date.now()}.mp3`;
+            logger_1.Logger.info("Downloading music...");
+            await downloadMedia(result.music, outputPath, musicName);
+            logger_1.Logger.success(`Music downloaded successfully to: ${path.join(outputPath, musicName)}`);
+            break;
+        }
+        default:
+            throw new Error(`Unsupported media type: ${result.type}`);
+    }
+}
+async function downloadMusicFromDetail(musicIdOrUrl, cookie, outputPath, proxy) {
+    try {
+        logger_1.Logger.info(`Fetching music detail for: ${musicIdOrUrl}`);
+        const { getMusicDetail } = await import("../utils/get/getMusicDetail.js");
+        const result = await getMusicDetail(musicIdOrUrl, cookie, proxy);
+        if (result.status !== "success" || !result.result) {
+            throw new Error(result.message || "Failed to fetch music detail");
+        }
+        const { musicInfo } = result.result;
+        const music = musicInfo.music;
+        const author = musicInfo.artist || musicInfo.author;
+        logger_1.Logger.success("Music detail fetched successfully!");
+        logger_1.Logger.info(`Title: ${music.title}`);
+        logger_1.Logger.info(`Author: ${music.authorName}`);
+        logger_1.Logger.info(`Duration: ${music.duration} seconds`);
+        const safeTitle = music.title.replace(/[^a-z0-9]/gi, "_").substring(0, 50);
+        const safeAuthor = (author?.nickname || music.authorName || "Unknown")
+            .replace(/[^a-z0-9]/gi, "_")
+            .substring(0, 30);
+        const musicName = `ttdl_music_${safeAuthor}_${safeTitle}_${Date.now()}.mp3`;
+        logger_1.Logger.info("Downloading music...");
+        const cookieString = Array.isArray(cookie) ? cookie.join("; ") : cookie;
+        await downloadMedia(music.playUrl, outputPath, musicName, cookieString);
+        logger_1.Logger.success(`Music downloaded successfully to: ${path.join(outputPath, musicName)}`);
+        logger_1.Logger.info("\n==== MUSIC INFO ====");
+        logger_1.Logger.info(`Title: ${music.title}`);
+        logger_1.Logger.info(`Author: @${author?.uniqueId || "Unknown"} (${author?.nickname || music.authorName})`);
+        logger_1.Logger.info(`Duration: ${music.duration} seconds`);
+        logger_1.Logger.info(`Original: ${music.original ? "Yes" : "No"}`);
+        logger_1.Logger.info(`Videos using this music: ${musicInfo.stats.videoCount}`);
+    }
+    catch (error) {
+        throw new Error(`Failed to download music: ${error.message}`);
+    }
+}

package/lib/services/tiktokService.d.ts

@@ -0,0 +1,14 @@
+export declare class TiktokService {
+    generateSignature(url: URL): string;
+    generateXBogus(url: URL, signature?: string): string;
+    generateXTTParams(params: any): string;
+    generateURLXbogus(username: string, page: number): string;
+    private getJsdomOptions;
+    private static readonly FILE_PATH;
+    private static readonly BASE_URL;
+    private static readonly AES_KEY;
+    private static readonly AES_IV;
+    private signaturejs;
+    private webmssdk;
+    private resourceLoader;
+}

package/lib/services/tiktokService.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TiktokService = void 0;
+const jsdom_1 = require("jsdom");
+const params_1 = require("../constants/params");
+const xbogus_1 = __importDefault(require("../../helper/xbogus"));
+const headers_1 = require("../constants/headers");
+const fs_1 = __importDefault(require("fs"));
+const crypto_1 = require("crypto");
+const path_1 = __importDefault(require("path"));
+class TiktokService {
+    constructor() {
+        this.signaturejs = fs_1.default.readFileSync(path_1.default.join(TiktokService.FILE_PATH, "signature.js"), "utf-8");
+        this.webmssdk = fs_1.default.readFileSync(path_1.default.join(TiktokService.FILE_PATH, "webmssdk.js"), "utf-8");
+        this.resourceLoader = new jsdom_1.ResourceLoader({
+            userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36 Edg/107.0.1418.35"
+        });
+    }
+    generateSignature(url) {
+        const stringUrl = url.toString();
+        const jsdomOptions = this.getJsdomOptions();
+        const { window } = new jsdom_1.JSDOM(``, jsdomOptions);
+        let _window = window;
+        _window.eval(this.signaturejs.toString());
+        _window.byted_acrawler.init({
+            aid: 24,
+            dfp: true
+        });
+        _window.eval(this.webmssdk);
+        const signature = _window.byted_acrawler.sign({ url: stringUrl });
+        return signature;
+    }
+    generateXBogus(url, signature) {
+        const jsdomOptions = this.getJsdomOptions();
+        const { window } = new jsdom_1.JSDOM(``, jsdomOptions);
+        let _window = window;
+        _window.eval(this.signaturejs.toString());
+        _window.byted_acrawler.init({
+            aid: 24,
+            dfp: true
+        });
+        _window.eval(this.webmssdk);
+        if (signature) {
+            url.searchParams.append("_signature", signature);
+        }
+        const xbogus = _window._0x32d649(url.searchParams.toString());
+        return xbogus;
+    }
+    generateXTTParams(params) {
+        const cipher = (0, crypto_1.createCipheriv)("aes-128-cbc", TiktokService.AES_KEY, TiktokService.AES_IV);
+        return Buffer.concat([cipher.update(params), cipher.final()]).toString("base64");
+    }
+    generateURLXbogus(username, page) {
+        const baseUrl = `${TiktokService.BASE_URL}api/search/user/full/?`;
+        const queryParams = (0, params_1._userSearchParams)(username, page);
+        const xbogusParams = (0, xbogus_1.default)(`${baseUrl}${queryParams}`, headers_1.userAgent);
+        return `${baseUrl}${(0, params_1._userSearchParams)(username, page, xbogusParams)}`;
+    }
+    getJsdomOptions() {
+        return {
+            url: TiktokService.BASE_URL,
+            referrer: TiktokService.BASE_URL,
+            contentType: "text/html",
+            includeNodeLocations: false,
+            runScripts: "outside-only",
+            pretendToBeVisual: true,
+            resources: new jsdom_1.ResourceLoader({ userAgent: headers_1.webUserAgent })
+        };
+    }
+}
+exports.TiktokService = TiktokService;
+TiktokService.FILE_PATH = path_1.default.join(__dirname, "../../helper");
+TiktokService.BASE_URL = "https://www.tiktok.com/";
+TiktokService.AES_KEY = "webapp1.0+202106";
+TiktokService.AES_IV = "webapp1.0+202106";