nekostream 2026.0.1

package/dist/storage.js

@@ -0,0 +1,215 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSettings = loadSettings;
+exports.saveSettings = saveSettings;
+exports.getProviderBaseUrl = getProviderBaseUrl;
+exports.loadHistory = loadHistory;
+exports.saveHistoryEntry = saveHistoryEntry;
+exports.clearHistory = clearHistory;
+exports.loadAuthSession = loadAuthSession;
+exports.saveAuthSession = saveAuthSession;
+exports.clearAuthSession = clearAuthSession;
+exports.getProviderCookieHeader = getProviderCookieHeader;
+exports.getProviderToken = getProviderToken;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const os_1 = __importDefault(require("os"));
+const OLD_DATA_DIR = path_1.default.join(__dirname, '.data');
+const DATA_DIR = path_1.default.join(os_1.default.homedir(), '.nekostream-cli');
+const HISTORY_FILE = path_1.default.join(DATA_DIR, 'history.json');
+const SETTINGS_FILE = path_1.default.join(DATA_DIR, 'settings.json');
+const AUTH_SESSIONS_FILE = path_1.default.join(DATA_DIR, 'auth-sessions.json');
+// Ensure directory exists
+if (!fs_1.default.existsSync(DATA_DIR)) {
+    fs_1.default.mkdirSync(DATA_DIR, { recursive: true });
+    // Migrate data from old directory if it exists
+    if (fs_1.default.existsSync(OLD_DATA_DIR)) {
+        try {
+            fs_1.default.cpSync(OLD_DATA_DIR, DATA_DIR, { recursive: true });
+        }
+        catch (e) { }
+    }
+}
+const DEFAULT_SETTINGS = {
+    defaultProvider: 'animevietsub',
+    defaultQuality: '1080p',
+    autoPlayNext: false,
+    developerMode: false,
+    providerDomains: {},
+    discordRpcEnabled: true
+};
+// ── Settings ─────────────────────────────────────────────────────────────────
+function loadSettings() {
+    try {
+        if (fs_1.default.existsSync(SETTINGS_FILE)) {
+            const data = fs_1.default.readFileSync(SETTINGS_FILE, 'utf-8');
+            return { ...DEFAULT_SETTINGS, ...JSON.parse(data) };
+        }
+    }
+    catch (e) {
+        console.warn('Failed to load settings', e);
+    }
+    return DEFAULT_SETTINGS;
+}
+function saveSettings(settings) {
+    const current = loadSettings();
+    const updated = { ...current, ...settings };
+    fs_1.default.writeFileSync(SETTINGS_FILE, JSON.stringify(updated, null, 2), 'utf-8');
+}
+const PROVIDER_DEFAULT_DOMAINS = {
+    animevietsub: 'https://animevietsub.site',
+    anime47: 'https://anime47.best',
+    animehay: 'https://animehay.ink'
+};
+/**
+ * Returns the base URL for a provider, respecting custom domain settings.
+ * Mirrors the domain injection logic in providers.ts getProvider().
+ */
+function getProviderBaseUrl(providerName) {
+    const settings = loadSettings();
+    const custom = settings.providerDomains?.[providerName];
+    if (custom && custom.trim()) {
+        const d = custom.trim();
+        return (d.startsWith('http') ? d : 'https://' + d).replace(/\/$/, '');
+    }
+    return PROVIDER_DEFAULT_DOMAINS[providerName] ?? `https://${providerName}.com`;
+}
+// ── History ──────────────────────────────────────────────────────────────────
+function loadHistory() {
+    try {
+        if (fs_1.default.existsSync(HISTORY_FILE)) {
+            const data = fs_1.default.readFileSync(HISTORY_FILE, 'utf-8');
+            return JSON.parse(data);
+        }
+    }
+    catch (e) {
+        console.warn('Failed to load history', e);
+    }
+    return [];
+}
+function saveHistoryEntry(entry) {
+    const history = loadHistory();
+    const newEntry = { ...entry, timestamp: Date.now() };
+    // Remove duplicate entry for the same anime
+    const filtered = history.filter(h => h.animeId !== entry.animeId || h.provider !== entry.provider);
+    filtered.unshift(newEntry); // Add to top
+    // Keep last 100 entries
+    if (filtered.length > 100)
+        filtered.pop();
+    fs_1.default.writeFileSync(HISTORY_FILE, JSON.stringify(filtered, null, 2), 'utf-8');
+}
+function clearHistory() {
+    if (fs_1.default.existsSync(HISTORY_FILE)) {
+        fs_1.default.unlinkSync(HISTORY_FILE);
+    }
+}
+/**
+ * Derive a stable 32-byte encryption key from machine identity.
+ * Not cryptographically robust against local admin access,
+ * but sufficient to prevent casual reading of the JSON file.
+ */
+function deriveEncryptionKey() {
+    const seed = `nekostream-cli:${os_1.default.hostname()}:${os_1.default.userInfo().username}:auth-v1`;
+    return crypto_1.default.createHash('sha256').update(seed).digest();
+}
+function encryptPayload(raw) {
+    try {
+        const key = deriveEncryptionKey();
+        const iv = crypto_1.default.randomBytes(16);
+        const cipher = crypto_1.default.createCipheriv('aes-256-cbc', key, iv);
+        const encrypted = Buffer.concat([cipher.update(raw, 'utf8'), cipher.final()]);
+        return iv.toString('hex') + ':' + encrypted.toString('base64');
+    }
+    catch {
+        // Fallback: plain base64 if crypto fails
+        return 'plain:' + Buffer.from(raw, 'utf8').toString('base64');
+    }
+}
+function decryptPayload(encoded) {
+    try {
+        if (encoded.startsWith('plain:')) {
+            return Buffer.from(encoded.slice(6), 'base64').toString('utf8');
+        }
+        const [ivHex, encryptedB64] = encoded.split(':');
+        if (!ivHex || !encryptedB64)
+            return null;
+        const key = deriveEncryptionKey();
+        const iv = Buffer.from(ivHex, 'hex');
+        const encrypted = Buffer.from(encryptedB64, 'base64');
+        const decipher = crypto_1.default.createDecipheriv('aes-256-cbc', key, iv);
+        return Buffer.concat([decipher.update(encrypted), decipher.final()]).toString('utf8');
+    }
+    catch {
+        return null;
+    }
+}
+function loadAuthSessionsRaw() {
+    try {
+        if (fs_1.default.existsSync(AUTH_SESSIONS_FILE)) {
+            const raw = fs_1.default.readFileSync(AUTH_SESSIONS_FILE, 'utf-8');
+            const parsed = JSON.parse(raw);
+            const result = {};
+            for (const [provider, encoded] of Object.entries(parsed)) {
+                const decrypted = decryptPayload(encoded);
+                if (!decrypted)
+                    continue;
+                result[provider] = JSON.parse(decrypted);
+            }
+            return result;
+        }
+    }
+    catch (e) {
+        console.warn('[Auth] Failed to load auth sessions:', e);
+    }
+    return {};
+}
+function saveAuthSessionsRaw(sessions) {
+    const encoded = {};
+    for (const [provider, session] of Object.entries(sessions)) {
+        encoded[provider] = encryptPayload(JSON.stringify(session));
+    }
+    fs_1.default.writeFileSync(AUTH_SESSIONS_FILE, JSON.stringify(encoded, null, 2), 'utf-8');
+}
+function loadAuthSession(provider) {
+    const sessions = loadAuthSessionsRaw();
+    return sessions[provider] ?? null;
+}
+function saveAuthSession(provider, session) {
+    const sessions = loadAuthSessionsRaw();
+    sessions[provider] = { ...session, provider };
+    saveAuthSessionsRaw(sessions);
+}
+function clearAuthSession(provider) {
+    const sessions = loadAuthSessionsRaw();
+    delete sessions[provider];
+    saveAuthSessionsRaw(sessions);
+}
+/**
+ * Build Cookie header string from stored session.
+ * Filters out expired cookies.
+ */
+function getProviderCookieHeader(provider) {
+    const session = loadAuthSession(provider);
+    if (!session)
+        return null;
+    const nowEpoch = Date.now() / 1000;
+    const validCookies = session.cookies.filter(cookie => {
+        if (!cookie.expirationDate)
+            return true;
+        return cookie.expirationDate > nowEpoch;
+    });
+    if (validCookies.length === 0)
+        return null;
+    return validCookies.map(c => `${c.name}=${c.value}`).join('; ');
+}
+/**
+ * Returns stored JWT access token for providers that use Bearer auth (e.g. Anime47).
+ */
+function getProviderToken(provider) {
+    const session = loadAuthSession(provider);
+    return session?.accessToken ?? null;
+}

package/dist/test-a47-eps.js

@@ -0,0 +1,69 @@
+"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 });
+const auth_service_1 = require("./scrapers/auth-service");
+const fs_1 = __importDefault(require("fs"));
+const cheerio = __importStar(require("cheerio"));
+(async () => {
+    const watchUrl = 'https://anime47.best/xem/android-wa-keiken-ninzuu-ni-hairimasu-ka-10264/ep-1-117377';
+    console.log('Fetching watchUrl...', watchUrl);
+    const watchHtml = await (0, auth_service_1.fetchA47Page)(watchUrl) || '';
+    fs_1.default.writeFileSync('watch.html', watchHtml);
+    const $ = cheerio.load(watchHtml);
+    // Find all scripts that might contain state
+    $('script').each((i, el) => {
+        const text = $(el).html() || '';
+        if (text.includes('window.') || text.includes('episodes') || text.includes('server')) {
+            console.log(`Script ${i} length: ${text.length}`);
+            if (text.length < 5000)
+                console.log(text.substring(0, 500));
+        }
+    });
+    // Let's also check if there are buttons with "Tập"
+    let epCount = 0;
+    $('*').each((i, el) => {
+        const text = $(el).text().trim();
+        if (text.startsWith('Tập ') || /^\d{1,3}$/.test(text)) {
+            if ($(el).attr('class') || $(el).attr('id')) {
+                // console.log('Potential episode element:', el.tagName, $(el).attr('class'), text);
+                epCount++;
+            }
+        }
+    });
+    console.log('Found elements with short numbers or "Tap":', epCount);
+})();

package/dist/test-a47-real.js

@@ -0,0 +1,56 @@
+"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 });
+const auth_service_1 = require("./scrapers/auth-service");
+const cheerio = __importStar(require("cheerio"));
+const fs_1 = __importDefault(require("fs"));
+(async () => {
+    const watchUrl = 'https://anime47.best/xem/android-wa-keiken-ninzuu-ni-hairimasu-ka-10264/ep-1-117377';
+    console.log('Fetching watchUrl...', watchUrl);
+    const watchHtml = await (0, auth_service_1.fetchA47Page)(watchUrl) || '';
+    const $w = cheerio.load(watchHtml);
+    const links = [];
+    $w('a').each((_, el) => {
+        const href = $w(el).attr('href');
+        if (href && (href.includes('ep-') || href.includes('tap-') || href.includes('episode'))) {
+            links.push({ text: $w(el).text().trim(), href });
+        }
+    });
+    console.log('Found potential episode links:', links);
+    fs_1.default.writeFileSync('watch.html', watchHtml);
+})();

package/dist/test-a47.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const auth_service_ts_1 = require("./scrapers/auth-service.ts");
+(async () => {
+    const html = await (0, auth_service_ts_1.fetchA47Page)('https://anime47.love/api/anime/10208/episodes?lang=vi');
+    console.log(html);
+    process.exit(0);
+})();

package/dist/ui.js

@@ -0,0 +1,187 @@
+"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.clearScreen = clearScreen;
+exports.printBanner = printBanner;
+exports.drawAnimeCard = drawAnimeCard;
+const chalk_1 = __importDefault(require("chalk"));
+const storage_1 = require("./storage");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function clearScreen() {
+    try {
+        const settings = (0, storage_1.loadSettings)();
+        if (settings.developerMode)
+            return;
+    }
+    catch (e) { } // Fallback in case storage isn't ready yet
+    // \x1B[2J clears visible screen, \x1B[3J clears scrollback buffer, \x1B[H moves cursor to top left
+    process.stdout.write('\x1B[2J\x1B[3J\x1B[H');
+    if (process.stdin.isTTY) {
+        try {
+            // Force Node.js to re-apply the OS console mode API (fixes Playwright/Chromium corrupting the console on Windows)
+            process.stdin.setRawMode(false);
+            process.stdin.setRawMode(true);
+        }
+        catch (e) { }
+    }
+}
+function interpolateColor(c1, c2, factor) {
+    const result = c1.slice();
+    for (let i = 0; i < 3; i++) {
+        result[i] = Math.round(result[i] + factor * (c2[i] - c1[i]));
+    }
+    return result;
+}
+function hexToRgb(hex) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result ? [parseInt(result[1], 16), parseInt(result[2], 16), parseInt(result[3], 16)] : [0, 0, 0];
+}
+function applyGradient(text, startHex, endHex) {
+    const c1 = hexToRgb(startHex);
+    const c2 = hexToRgb(endHex);
+    let output = '';
+    for (let i = 0; i < text.length; i++) {
+        const factor = i / Math.max(text.length - 1, 1);
+        const color = interpolateColor(c1, c2, factor);
+        output += chalk_1.default.rgb(color[0], color[1], color[2])(text[i]);
+    }
+    return output;
+}
+function printBanner(title, subtitle) {
+    console.log('\n');
+    let version = 'unknown';
+    try {
+        const isCompiled = __dirname.endsWith('dist') || __dirname.endsWith('dist\\') || __dirname.endsWith('dist/');
+        const basePath = isCompiled ? path.join(__dirname, '..') : __dirname;
+        const pkg = JSON.parse(fs.readFileSync(path.join(basePath, 'package.json'), 'utf-8'));
+        version = pkg.version;
+    }
+    catch (e) { }
+    const bracket = [
+        " ▝▜▄   ",
+        "   ▝▜▄ ",
+        "  ▗▟▀  ",
+        " ▝▀    "
+    ];
+    const color1 = hexToRgb('#4285F4');
+    const color2 = hexToRgb('#DB2777');
+    const coloredBracket = bracket.map((line, i) => {
+        const factor = i / 3;
+        const color = interpolateColor(color1, color2, factor);
+        return chalk_1.default.rgb(color[0], color[1], color[2]).bold(line);
+    });
+    console.log(`${coloredBracket[0]}  ${chalk_1.default.bold.white(`NekoStream CLI v${version}`)}`);
+    console.log(`${coloredBracket[1]}`);
+    console.log(`${coloredBracket[2]}  ${chalk_1.default.cyan(title ? title : '')}`);
+    if (subtitle) {
+        console.log(`${coloredBracket[3]}  ${chalk_1.default.gray(subtitle)}`);
+    }
+    else {
+        console.log(`${coloredBracket[3]}`);
+    }
+    console.log('');
+}
+function truncate(str, maxLength) {
+    if (str.length <= maxLength)
+        return str;
+    return str.slice(0, maxLength - 3) + '...';
+}
+function wrapText(text, maxWidth) {
+    const words = text.split(' ');
+    const lines = [];
+    let currentLine = '';
+    for (const word of words) {
+        if ((currentLine + word).length > maxWidth) {
+            if (currentLine)
+                lines.push(currentLine.trim());
+            currentLine = word + ' ';
+        }
+        else {
+            currentLine += word + ' ';
+        }
+    }
+    if (currentLine)
+        lines.push(currentLine.trim());
+    return lines;
+}
+function drawAnimeCard(anime) {
+    const width = 76;
+    const pad = (str, len) => {
+        const visibleLength = str.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '').length;
+        if (visibleLength >= len)
+            return str;
+        return str + ' '.repeat(len - visibleLength);
+    };
+    // Use a gradient for the border? Or just magenta/cyan. Let's use a solid color from the theme.
+    const borderColor = chalk_1.default.hex('#9b59b6'); // Purple border
+    const titleColor = chalk_1.default.hex('#FF69B4').bold; // Pink title
+    const labelColor = chalk_1.default.hex('#00bcd4'); // Cyan labels
+    const valueColor = chalk_1.default.white;
+    console.log(borderColor(' ╭' + '─'.repeat(width) + '╮'));
+    const title = truncate(anime.title, width - 4);
+    console.log(borderColor(' │ ') + pad(titleColor(title), width - 2) + borderColor(' │'));
+    if (anime.titleAlt) {
+        console.log(borderColor(' │ ') + pad(chalk_1.default.gray(truncate(anime.titleAlt, width - 4)), width - 2) + borderColor(' │'));
+    }
+    console.log(borderColor(' ├' + '─'.repeat(width) + '┤'));
+    const row1 = [];
+    row1.push(labelColor(`Số tập: `) + valueColor(anime.episodeCount || '??'));
+    row1.push(labelColor(`Năm SX: `) + valueColor(anime.year && anime.year > 1900 ? anime.year : '??'));
+    const genresStr = anime.genres && anime.genres.length > 0 ? anime.genres.slice(0, 2).join(', ') : '??';
+    row1.push(chalk_1.default.hex('#2980b9')(`Thể loại: `) + valueColor(genresStr));
+    console.log(borderColor(' │ ') + pad(row1.join(chalk_1.default.gray(' | ')), width - 2) + borderColor(' │'));
+    const row2 = [];
+    row2.push(labelColor(`Đạo diễn: `) + valueColor(anime.director || '??'));
+    row2.push(labelColor(`Studio: `) + valueColor(anime.studio || '??'));
+    row2.push(labelColor(`Season: `) + valueColor(anime.season || '??'));
+    console.log(borderColor(' │ ') + pad(row2.join(chalk_1.default.gray(' | ')), width - 2) + borderColor(' │'));
+    if (anime.description) {
+        console.log(borderColor(' │ ') + pad('', width - 2) + borderColor(' │'));
+        // Clean HTML from description
+        const cleanDesc = anime.description.replace(/<[^>]*>?/gm, '');
+        const descLines = wrapText(cleanDesc, width - 4);
+        for (let i = 0; i < Math.min(descLines.length, 6); i++) {
+            let line = descLines[i];
+            if (i === 5 && descLines.length > 6)
+                line = truncate(line, width - 7) + '...';
+            console.log(borderColor(' │ ') + pad(chalk_1.default.gray(line), width - 2) + borderColor(' │'));
+        }
+    }
+    console.log(borderColor(' ╰' + '─'.repeat(width) + '╯\n'));
+}

package/isolate.css

@@ -0,0 +1,115 @@
+html, body {
+  width: 100% !important;
+  height: 100% !important;
+  margin: 0 !important;
+  padding: 0 !important;
+  overflow: hidden !important;
+  background: #000 !important;
+}
+
+#app, #root, #q-app, main, .main, .watch-page {
+  width: 100% !important;
+  height: 100% !important;
+  max-width: 100% !important;
+  margin: 0 !important;
+  padding: 0 !important;
+}
+
+.jwplayer, .jw-player-wrapper, .jw-holder, .jw-media, .jw-video,
+.art-video-player, .video-js, .vjs-tech, video,
+iframe[src*="vlogphim"], iframe[src*="anime47"], iframe[src*="nonprofit"], iframe[src*="anime3s"] {
+  width: 100% !important;
+  height: 100% !important;
+  max-width: 100% !important;
+  max-height: 100% !important;
+  margin: 0 !important;
+  padding: 0 !important;
+  padding-bottom: 0 !important;
+  padding-top: 0 !important;
+  top: 0 !important;
+  left: 0 !important;
+  transform: none !important;
+  background: #000 !important;
+}
+
+.player-section, .video-container, .watch-player {
+  width: 100% !important;
+  height: 100% !important;
+  max-width: 100% !important;
+  max-height: 100% !important;
+  margin: 0 !important;
+  padding: 0 !important;
+  padding-bottom: 0 !important;
+  padding-top: 0 !important;
+  top: 0 !important;
+  left: 0 !important;
+  transform: none !important;
+  overflow: hidden !important;
+  background: #000 !important;
+}
+
+.player-wrapper {
+  width: 100% !important;
+  height: 100% !important;
+  max-width: 100% !important;
+  max-height: 100% !important;
+  margin: 0 !important;
+  padding: 0 !important;
+  padding-bottom: 0 !important;
+  padding-top: 0 !important;
+  top: 0 !important;
+  left: 0 !important;
+  transform: none !important;
+  background: #000 !important;
+}
+
+.watch-player {
+  display: flex !important;
+  flex-direction: column !important;
+}
+
+.watch-player > .player-wrapper,
+.watch-player > .player-wrapper.jw-active,
+.watch-player > .jw-player-wrapper,
+.watch-player > .jwplayer,
+.watch-player .player-wrapper.jw-active {
+  flex: 1 1 auto !important;
+  min-height: 0 !important;
+  height: auto !important;
+}
+
+div[role="dialog"], div[role="alertdialog"], .modal, .popup, .overlay-ads,
+[class*="ad-"], [id*="ad-"] {
+  display: none !important;
+  visibility: hidden !important;
+  opacity: 0 !important;
+  pointer-events: none !important;
+}
+
+header, nav, .header, #header, .navbar, .nav, #nav, .menu, #menu, .top-bar, .head,
+.q-header, .q-footer, .q-drawer,
+.ads, .ad, .banner, .overlay-ads, [class*="ad-"], [id*="ad-"],
+.watch-player .player-controls, .watch-player .server-section, .watch-player .functional-section, 
+.player-controls, .server-section, .functional-section, .watch-player > .q-card:not(:first-child) {
+  display: none !important;
+  visibility: hidden !important;
+  opacity: 0 !important;
+  pointer-events: none !important;
+  height: 0 !important;
+  width: 0 !important;
+}
+
+.jw-overlays,
+.jw-display,
+.jw-controls,
+.jw-display-icon-container,
+.jw-icon-display,
+video {
+  pointer-events: auto !important;
+}
+
+.jw-wrapper,
+.jw-media,
+.jwplayer {
+  background: #000 !important;
+}