// ==UserScript==
// @name         NSFWDL Free Video Downloader – PornHub, xHamster, XVideos, XNXX to HD MP4 in one click, no pop-ups
// @name:ro      NSFWDL – descărcător video gratuit: PornHub, xHamster, XVideos, XNXX în MP4 HD dintr-un click
// @name:es      NSFWDL – descargador de vídeos gratis: PornHub, xHamster, XVideos, XNXX a MP4 HD en un clic
// @name:pt-BR   NSFWDL – baixador de vídeos grátis: PornHub, xHamster, XVideos, XNXX em MP4 HD com um clique
// @name:pt      NSFWDL – descarregador de vídeos grátis: PornHub, xHamster, XVideos, XNXX em MP4 HD num clique
// @name:fr      NSFWDL – téléchargeur vidéo gratuit : PornHub, xHamster, XVideos, XNXX en MP4 HD en un clic
// @name:fr-CA   NSFWDL – téléchargeur vidéo gratuit : PornHub, xHamster, XVideos, XNXX en MP4 HD en un clic
// @name:de      NSFWDL – kostenloser Video-Downloader: PornHub, xHamster, XVideos, XNXX als HD-MP4 mit einem Klick
// @name:it      NSFWDL – downloader video gratis: PornHub, xHamster, XVideos, XNXX in MP4 HD con un clic
// @name:nl      NSFWDL – gratis videodownloader: PornHub, xHamster, XVideos, XNXX naar HD-MP4 in één klik
// @name:ru      NSFWDL – бесплатный загрузчик видео: PornHub, xHamster, XVideos, XNXX в MP4 HD в один клик
// @name:uk      NSFWDL – безкоштовний завантажувач відео: PornHub, xHamster, XVideos, XNXX у MP4 HD в один клік
// @name:be      NSFWDL – бясплатны загрузчык відэа: PornHub, xHamster, XVideos, XNXX у MP4 HD адным клікам
// @name:pl      NSFWDL – darmowy downloader wideo: PornHub, xHamster, XVideos, XNXX do MP4 HD jednym kliknięciem
// @name:cs      NSFWDL – stahovač videí zdarma: PornHub, xHamster, XVideos, XNXX do HD MP4 jedním kliknutím
// @name:sk      NSFWDL – sťahovač videí zadarmo: PornHub, xHamster, XVideos, XNXX do HD MP4 jedným kliknutím
// @name:hu      NSFWDL – ingyenes videóletöltő: PornHub, xHamster, XVideos, XNXX HD MP4-be egy kattintással
// @name:bg      NSFWDL – безплатен видео даунлоудър: PornHub, xHamster, XVideos, XNXX в HD MP4 с едно щракване
// @name:hr      NSFWDL – besplatni preuzimač videa: PornHub, xHamster, XVideos, XNXX u HD MP4 jednim klikom
// @name:sr      NSFWDL – бесплатни преузимач видеа: PornHub, xHamster, XVideos, XNXX у HD MP4 једним кликом
// @name:el      NSFWDL – δωρεάν λήψη βίντεο: PornHub, xHamster, XVideos, XNXX σε HD MP4 με ένα κλικ, χωρίς pop-up
// @name:tr      NSFWDL – ücretsiz video indirici: PornHub, xHamster, XVideos, XNXX tek tıkla HD MP4
// @name:id      NSFWDL – pengunduh video gratis: PornHub, xHamster, XVideos, XNXX ke MP4 HD sekali klik
// @name:vi      NSFWDL – trình tải video miễn phí: PornHub, xHamster, XVideos, XNXX sang MP4 HD một cú nhấp
// @name:fil     NSFWDL – libreng video downloader: PornHub, xHamster, XVideos, XNXX sa HD MP4 sa isang click
// @name:th      NSFWDL – ดาวน์โหลดวิดีโอฟรี: PornHub, xHamster, XVideos, XNXX เป็น MP4 HD ในคลิกเดียว ไม่มีป๊อปอัป
// @name:ar      NSFWDL – أداة تنزيل فيديو مجانية: PornHub وxHamster وXVideos وXNXX بصيغة MP4 HD بنقرة واحدة
// @name:he      NSFWDL – מוריד וידאו בחינם: PornHub, xHamster, XVideos, XNXX ל-MP4 באיכות HD בלחיצה אחת
// @name:ja      NSFWDL 無料動画ダウンローダー – PornHub・xHamster・XVideos・XNXX をワンクリックで HD MP4 保存、ポップアップなし
// @name:ko      NSFWDL 무료 동영상 다운로더 – PornHub, xHamster, XVideos, XNXX를 클릭 한 번에 HD MP4로, 팝업 없음
// @name:zh-CN   NSFWDL 免费视频下载器 – 一键将 PornHub、xHamster、XVideos、XNXX 保存为高清 MP4，无弹窗
// @name:zh-TW   NSFWDL 免費影片下載器 – 一鍵將 PornHub、xHamster、XVideos、XNXX 存成高畫質 MP4，無彈出視窗
// @name:sv      NSFWDL – gratis videonedladdare: PornHub, xHamster, XVideos, XNXX till HD-MP4 med ett klick
// @name:da      NSFWDL – gratis videodownloader: PornHub, xHamster, XVideos, XNXX til HD-MP4 med ét klik
// @name:fi      NSFWDL – ilmainen videolataaja: PornHub, xHamster, XVideos, XNXX HD-MP4:ksi yhdellä klikkauksella
// @name:nb      NSFWDL – gratis videonedlaster: PornHub, xHamster, XVideos, XNXX til HD-MP4 med ett klikk
// @name:ka      NSFWDL – უფასო ვიდეო ჩამომტვირთავი: PornHub, xHamster, XVideos, XNXX HD MP4-ად ერთი დაწკაპუნებით
// @name:eo      NSFWDL – senpaga videoelŝutilo: PornHub, xHamster, XVideos, XNXX al HD MP4 per unu klako
// @name:mr      NSFWDL – मोफत व्हिडिओ डाउनलोडर: PornHub, xHamster, XVideos, XNXX एका क्लिकमध्ये HD MP4 मध्ये
// @name:ne      NSFWDL – निःशुल्क भिडियो डाउनलोडर: PornHub, xHamster, XVideos, XNXX एक क्लिकमा HD MP4 मा
// @namespace    https://nsfwdl.com/
// @version      2.9.0
// @description  Free, no sign-up. Download videos without leaving the page: PornHub (incl. Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX and 8 more sites. Pick a real quality with its file size and the MP4 goes straight to your downloads. Download buttons on the player and on thumbnails, one-click saving in your preferred quality. Desktop, Android and iPhone. No pop-ups, no redirects.
// @description:ro  Gratuit, fără cont. Descarcă video fără să părăsești pagina: PornHub (inclusiv Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX și încă 8 site-uri. Alegi o calitate reală cu mărimea fișierului, iar MP4-ul ajunge direct în descărcări. Butoane de descărcare pe player și pe miniaturi, salvare dintr-un click în calitatea preferată. Desktop, Android și iPhone. Fără pop-up-uri, fără redirecționări.
// @description:es  Gratis, sin registro. Descarga vídeos sin salir de la página: PornHub (incl. Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX y 8 sitios más. Elige una calidad real con su tamaño y el MP4 llega directo a tus descargas. Botones de descarga en el reproductor y en las miniaturas, guardado en un clic con tu calidad preferida. Escritorio, Android y iPhone. Sin pop-ups ni redirecciones.
// @description:pt-BR  Grátis, sem cadastro. Baixe vídeos sem sair da página: PornHub (incl. Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX e mais 8 sites. Escolha uma qualidade real com o tamanho do arquivo e o MP4 vai direto para seus downloads. Botões de download no player e nas miniaturas, salve em um clique na sua qualidade preferida. Desktop, Android e iPhone. Sem pop-ups nem redirecionamentos.
// @description:pt  Grátis, sem registo. Descarregue vídeos sem sair da página: PornHub (incl. Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX e mais 8 sites. Escolha uma qualidade real com o tamanho do ficheiro e o MP4 vai diretamente para as suas transferências. Botões de transferência no leitor e nas miniaturas, guarde num clique na sua qualidade preferida. Computador, Android e iPhone. Sem pop-ups nem redirecionamentos.
// @description:fr  Gratuit, sans inscription. Téléchargez des vidéos sans quitter la page : PornHub (Shorties inclus), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX et 8 autres sites. Choisissez une vraie qualité avec sa taille, le MP4 arrive directement dans vos téléchargements. Boutons de téléchargement sur le lecteur et les miniatures, enregistrement en un clic dans votre qualité préférée. Ordinateur, Android et iPhone. Sans pop-up ni redirection.
// @description:fr-CA  Gratuit, sans inscription. Téléchargez des vidéos sans quitter la page : PornHub (Shorties inclus), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX et 8 autres sites. Choisissez une vraie qualité avec sa taille, le MP4 arrive directement dans vos téléchargements. Boutons de téléchargement sur le lecteur et les miniatures, enregistrement en un clic dans votre qualité préférée. Ordinateur, Android et iPhone. Sans pop-up ni redirection.
// @description:de  Kostenlos, ohne Anmeldung. Videos herunterladen, ohne die Seite zu verlassen: PornHub (inkl. Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX und 8 weitere Seiten. Echte Qualität mit Dateigröße wählen, die MP4 landet direkt in den Downloads. Download-Buttons im Player und auf Vorschaubildern, Speichern mit einem Klick in der Wunschqualität. Desktop, Android und iPhone. Ohne Pop-ups, ohne Weiterleitungen.
// @description:it  Gratis, senza registrazione. Scarica video senza lasciare la pagina: PornHub (Shorties inclusi), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX e altri 8 siti. Scegli una qualità reale con la dimensione del file e l'MP4 finisce direttamente nei tuoi download. Pulsanti di download sul player e sulle miniature, salvataggio con un clic nella qualità preferita. Desktop, Android e iPhone. Niente pop-up né reindirizzamenti.
// @description:nl  Gratis, zonder account. Download video's zonder de pagina te verlaten: PornHub (incl. Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX en 8 andere sites. Kies een echte kwaliteit met bestandsgrootte en de MP4 gaat direct naar je downloads. Downloadknoppen op de speler en op miniaturen, opslaan met één klik in je voorkeurskwaliteit. Desktop, Android en iPhone. Geen pop-ups, geen doorverwijzingen.
// @description:ru  Бесплатно, без регистрации. Скачивайте видео, не уходя со страницы: PornHub (вкл. Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX и ещё 8 сайтов. Выберите реальное качество с размером файла, и MP4 сохранится прямо в загрузки. Кнопки скачивания на плеере и на миниатюрах, сохранение в один клик в любимом качестве. ПК, Android и iPhone. Без всплывающих окон и редиректов.
// @description:uk  Безкоштовно, без реєстрації. Завантажуйте відео, не залишаючи сторінку: PornHub (з Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX і ще 8 сайтів. Обирайте реальну якість із розміром файлу, і MP4 збережеться просто в завантаження. Кнопки завантаження на плеєрі та на мініатюрах, збереження в один клік в улюбленій якості. ПК, Android і iPhone. Без спливаючих вікон і переадресацій.
// @description:be  Бясплатна, без рэгістрацыі. Спампоўвайце відэа, не пакідаючы старонку: PornHub (з Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX і яшчэ 8 сайтаў. Выбірайце сапраўдную якасць з памерам файла, і MP4 захаваецца проста ў спампоўкі. Кнопкі спампоўкі на плэеры і на мініяцюрах, захаванне адным клікам у любімай якасці. ПК, Android і iPhone. Без усплывальных вокнаў і перанакіраванняў.
// @description:pl  Za darmo, bez rejestracji. Pobieraj filmy bez opuszczania strony: PornHub (z Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX i 8 innych serwisów. Wybierz prawdziwą jakość z rozmiarem pliku, a MP4 trafi prosto do pobranych. Przyciski pobierania na odtwarzaczu i na miniaturach, zapis jednym kliknięciem w ulubionej jakości. Komputer, Android i iPhone. Bez pop-upów i przekierowań.
// @description:cs  Zdarma, bez registrace. Stahujte videa bez opuštění stránky: PornHub (vč. Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX a 8 dalších webů. Vyberte skutečnou kvalitu s velikostí souboru a MP4 se uloží rovnou do stažených souborů. Tlačítka pro stažení na přehrávači i na náhledech, uložení jedním kliknutím v oblíbené kvalitě. Počítač, Android i iPhone. Bez pop-upů a přesměrování.
// @description:sk  Zadarmo, bez registrácie. Sťahujte videá bez opustenia stránky: PornHub (vrát. Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX a 8 ďalších webov. Vyberte si skutočnú kvalitu s veľkosťou súboru a MP4 sa uloží priamo do stiahnutých súborov. Tlačidlá na stiahnutie na prehrávači aj na náhľadoch, uloženie jedným kliknutím v obľúbenej kvalite. Počítač, Android aj iPhone. Bez pop-upov a presmerovaní.
// @description:hu  Ingyenes, regisztráció nélkül. Töltsd le a videókat az oldal elhagyása nélkül: PornHub (Shorties is), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX és még 8 oldal. Válassz valódi minőséget a fájlmérettel, és az MP4 egyenesen a letöltésekhez kerül. Letöltőgombok a lejátszón és a bélyegképeken, mentés egy kattintással a kedvenc minőségben. Asztali gép, Android és iPhone. Felugró ablakok és átirányítások nélkül.
// @description:bg  Безплатно, без регистрация. Изтегляйте видеа, без да напускате страницата: PornHub (вкл. Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX и още 8 сайта. Изберете реално качество с размера на файла и MP4 файлът отива направо в изтеглянията. Бутони за изтегляне върху плейъра и миниатюрите, запазване с едно щракване в любимото качество. Компютър, Android и iPhone. Без изскачащи прозорци и пренасочвания.
// @description:hr  Besplatno, bez registracije. Preuzimajte videozapise bez napuštanja stranice: PornHub (uklj. Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX i još 8 stranica. Odaberite stvarnu kvalitetu s veličinom datoteke, a MP4 ide ravno u vaša preuzimanja. Gumbi za preuzimanje na playeru i na sličicama, spremanje jednim klikom u omiljenoj kvaliteti. Računalo, Android i iPhone. Bez skočnih prozora i preusmjeravanja.
// @description:sr  Бесплатно, без регистрације. Преузимајте видео записе без напуштања странице: PornHub (укључујући Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX и још 8 сајтова. Изаберите стварни квалитет са величином фајла, а MP4 иде право у преузимања. Дугмад за преузимање на плејеру и на сличицама, чување једним кликом у омиљеном квалитету. Рачунар, Android и iPhone. Без искачућих прозора и преусмеравања.
// @description:el  Δωρεάν, χωρίς εγγραφή. Κατεβάστε βίντεο χωρίς να φύγετε από τη σελίδα: PornHub (μαζί με Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX και 8 ακόμη ιστότοποι. Διαλέξτε πραγματική ποιότητα με το μέγεθος αρχείου και το MP4 πηγαίνει κατευθείαν στις λήψεις σας. Κουμπιά λήψης στο player και στις μικρογραφίες, αποθήκευση με ένα κλικ στην αγαπημένη σας ποιότητα. Υπολογιστής, Android και iPhone. Χωρίς αναδυόμενα παράθυρα και ανακατευθύνσεις.
// @description:tr  Ücretsiz, kayıt gerektirmez. Sayfadan ayrılmadan video indirin: PornHub (Shorties dahil), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX ve 8 site daha. Dosya boyutuyla gerçek bir kalite seçin; MP4 doğrudan indirilenlere gelir. Oynatıcıda ve küçük resimlerde indirme düğmeleri, tercih ettiğiniz kalitede tek tıkla kaydetme. Masaüstü, Android ve iPhone. Açılır pencere ve yönlendirme yok.
// @description:id  Gratis, tanpa daftar. Unduh video tanpa meninggalkan halaman: PornHub (termasuk Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX dan 8 situs lain. Pilih kualitas asli lengkap dengan ukuran file, dan MP4 langsung masuk ke unduhan. Tombol unduh di pemutar dan di thumbnail, simpan sekali klik dengan kualitas favorit. Desktop, Android, dan iPhone. Tanpa pop-up, tanpa pengalihan.
// @description:vi  Miễn phí, không cần đăng ký. Tải video ngay trên trang: PornHub (gồm Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX và 8 trang khác. Chọn chất lượng thật kèm dung lượng tệp, tệp MP4 được lưu thẳng vào mục tải xuống. Nút tải trên trình phát và ảnh thu nhỏ, lưu bằng một cú nhấp với chất lượng ưa thích. Máy tính, Android và iPhone. Không pop-up, không chuyển hướng.
// @description:fil  Libre, walang sign-up. Mag-download ng mga video nang hindi umaalis sa page: PornHub (kasama ang Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX at 8 pang site. Pumili ng totoong kalidad kasama ang laki ng file, at diretso sa iyong mga download ang MP4. May download button sa player at sa mga thumbnail, isang click na pag-save sa paborito mong kalidad. Desktop, Android at iPhone. Walang pop-up, walang redirect.
// @description:th  ฟรี ไม่ต้องสมัคร ดาวน์โหลดวิดีโอโดยไม่ต้องออกจากหน้า: PornHub (รวม Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX และอีก 8 เว็บไซต์ เลือกคุณภาพจริงพร้อมขนาดไฟล์ แล้ว MP4 จะถูกบันทึกลงในโฟลเดอร์ดาวน์โหลดทันที มีปุ่มดาวน์โหลดบนเครื่องเล่นและภาพขนาดย่อ บันทึกในคลิกเดียวด้วยคุณภาพที่ชอบ ใช้ได้บนคอมพิวเตอร์ Android และ iPhone ไม่มีป๊อปอัป ไม่มีการเปลี่ยนเส้นทาง
// @description:ar  مجاني وبدون تسجيل. نزّل الفيديوهات دون مغادرة الصفحة: PornHub (مع Shorties) وxHamster وXVideos وXNXX وRedGifs وEporner وSpankBang وYouPorn وRedTube وErome وThisVid وTXXX و8 مواقع أخرى. اختر جودة حقيقية مع حجم الملف، ويُحفظ ملف MP4 مباشرة في التنزيلات. أزرار تنزيل على المشغّل وعلى الصور المصغّرة، وحفظ بنقرة واحدة بالجودة المفضّلة. الكمبيوتر وAndroid وiPhone. دون نوافذ منبثقة أو إعادة توجيه.
// @description:he  חינם, בלי הרשמה. הורידו סרטונים בלי לעזוב את הדף: PornHub (כולל Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX ועוד 8 אתרים. בחרו איכות אמיתית עם גודל הקובץ, וקובץ ה-MP4 נשמר ישירות בהורדות. כפתורי הורדה על הנגן ועל התמונות הממוזערות, שמירה בלחיצה אחת באיכות המועדפת. מחשב, Android ו-iPhone. בלי חלונות קופצים ובלי הפניות.
// @description:ja  無料・登録不要。ページを離れずに動画を保存：PornHub（Shorties含む）・xHamster・XVideos・XNXX・RedGifs・Eporner・SpankBang・YouPorn・RedTube・Erome・ThisVid・TXXX ほか8サイト。実際の画質とファイルサイズを選ぶだけで、MP4 はそのままダウンロードへ。プレーヤーとサムネイルに保存ボタン、好みの画質でワンクリック保存。PC・Android・iPhone 対応。ポップアップもリダイレクトもなし。
// @description:ko  무료, 가입 불필요. 페이지를 떠나지 않고 동영상 저장: PornHub(Shorties 포함), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX 외 8개 사이트. 실제 화질과 파일 크기를 고르면 MP4가 다운로드 폴더로 바로 저장됩니다. 플레이어와 썸네일에 다운로드 버튼, 선호 화질로 원클릭 저장. PC, Android, iPhone 지원. 팝업도 리디렉션도 없음.
// @description:zh-CN  免费，无需注册。无需离开页面即可下载视频：PornHub（含 Shorties）、xHamster、XVideos、XNXX、RedGifs、Eporner、SpankBang、YouPorn、RedTube、Erome、ThisVid、TXXX 等 20 个网站。选择真实画质并查看文件大小，MP4 直接保存到下载。播放器和缩略图上都有下载按钮，可按偏好画质一键保存。支持电脑、安卓和 iPhone。无弹窗，无跳转。
// @description:zh-TW  免費，無需註冊。無需離開頁面即可下載影片：PornHub（含 Shorties）、xHamster、XVideos、XNXX、RedGifs、Eporner、SpankBang、YouPorn、RedTube、Erome、ThisVid、TXXX 等 20 個網站。選擇真實畫質並查看檔案大小，MP4 直接存到下載資料夾。播放器和縮圖上都有下載按鈕，可依偏好畫質一鍵儲存。支援電腦、Android 和 iPhone。無彈出視窗，無跳轉。
// @description:sv  Gratis, utan konto. Ladda ner videor utan att lämna sidan: PornHub (inkl. Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX och 8 andra sajter. Välj en verklig kvalitet med filstorlek så hamnar MP4-filen direkt i dina nedladdningar. Nedladdningsknappar på spelaren och på miniatyrer, spara med ett klick i önskad kvalitet. Dator, Android och iPhone. Inga popup-fönster, inga omdirigeringar.
// @description:da  Gratis, uden konto. Download videoer uden at forlade siden: PornHub (inkl. Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX og 8 andre sider. Vælg en ægte kvalitet med filstørrelse, og MP4-filen lander direkte i dine overførsler. Downloadknapper på afspilleren og på miniaturer, gem med ét klik i din foretrukne kvalitet. Computer, Android og iPhone. Ingen pop-ups, ingen omdirigeringer.
// @description:fi  Ilmainen, ei rekisteröitymistä. Lataa videoita poistumatta sivulta: PornHub (myös Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX ja 8 muuta sivustoa. Valitse todellinen laatu tiedostokoon kanssa, ja MP4 tallentuu suoraan latauksiin. Latauspainikkeet soittimessa ja pikkukuvissa, tallennus yhdellä klikkauksella suosikkilaadussa. Tietokone, Android ja iPhone. Ei ponnahdusikkunoita, ei uudelleenohjauksia.
// @description:nb  Gratis, uten konto. Last ned videoer uten å forlate siden: PornHub (inkl. Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX og 8 andre nettsteder. Velg en ekte kvalitet med filstørrelse, og MP4-filen havner rett i nedlastingene dine. Nedlastingsknapper på avspilleren og på miniatyrbilder, lagre med ett klikk i foretrukket kvalitet. PC, Android og iPhone. Ingen popup-vinduer, ingen omdirigeringer.
// @description:ka  უფასო, რეგისტრაციის გარეშე. ჩამოტვირთეთ ვიდეოები გვერდის დატოვების გარეშე: PornHub (Shorties-ის ჩათვლით), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX და კიდევ 8 საიტი. აირჩიეთ რეალური ხარისხი ფაილის ზომით და MP4 პირდაპირ ჩამოტვირთვებში მოხვდება. ჩამოტვირთვის ღილაკები პლეერზე და მინიატურებზე, შენახვა ერთი დაწკაპუნებით სასურველ ხარისხში. კომპიუტერი, Android და iPhone. ამომხტარი ფანჯრებისა და გადამისამართებების გარეშე.
// @description:eo  Senpage, sen registriĝo. Elŝutu videojn sen forlasi la paĝon: PornHub (inkl. Shorties), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX kaj 8 aliaj retejoj. Elektu veran kvaliton kun dosiergrandeco, kaj la MP4 iras rekte al viaj elŝutaĵoj. Elŝutbutonoj sur la ludilo kaj sur bildetoj, konservado per unu klako en via preferata kvalito. Komputilo, Android kaj iPhone. Sen ŝprucfenestroj, sen alidirektoj.
// @description:mr  मोफत, साइन-अप नाही. पेज न सोडता व्हिडिओ डाउनलोड करा: PornHub (Shorties सह), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX आणि आणखी 8 साइट्स. फाइल आकारासह खरी क्वालिटी निवडा, आणि MP4 थेट तुमच्या डाउनलोड्समध्ये जाते. प्लेअरवर आणि थंबनेलवर डाउनलोड बटणे, आवडत्या क्वालिटीत एका क्लिकमध्ये सेव्ह. डेस्कटॉप, Android आणि iPhone. पॉप-अप नाहीत, रीडायरेक्ट नाहीत.
// @description:ne  निःशुल्क, साइन-अप चाहिँदैन। पेज नछोडी भिडियो डाउनलोड गर्नुहोस्: PornHub (Shorties सहित), xHamster, XVideos, XNXX, RedGifs, Eporner, SpankBang, YouPorn, RedTube, Erome, ThisVid, TXXX र थप 8 साइटहरू। फाइल साइजसहित वास्तविक गुणस्तर छान्नुहोस्, र MP4 सिधै तपाईंको डाउनलोडमा जान्छ। प्लेयर र थम्बनेलमा डाउनलोड बटन, मनपर्ने गुणस्तरमा एक क्लिकमा सेभ। डेस्कटप, Android र iPhone। पप-अप छैन, रिडाइरेक्ट छैन।
// @author       NSFWDL
// @icon         https://nsfwdl.com/static/app-icons/icon-192.png
// @homepageURL  https://nsfwdl.com/
// @supportURL   https://nsfwdl.com/contact
// @license      MIT
// @match        *://*.xnxx.com/*
// @match        *://*.xvideos.com/*
// @match        *://*.xhamster.com/*
// @match        *://*.xhamster.one/*
// @match        *://*.xhamster.desi/*
// @match        *://*.xhms.pro/*
// @match        *://*.xhday.com/*
// @match        *://*.xhvid.com/*
// @match        *://*.eporner.com/*
// @match        *://*.erome.com/*
// @match        *://*.redgifs.com/*
// @match        *://*.youjizz.com/*
// @match        *://*.porntop.com/*
// @match        *://*.redtube.com/*
// @match        *://*.youporn.com/*
// @match        *://*.tnaflix.com/*
// @match        *://*.porntrex.com/*
// @match        *://*.noodlemagazine.com/*
// @match        *://*.txxx.com/*
// @match        *://*.txxx.tube/*
// @match        *://*.upornia.com/*
// @match        *://*.upornia.tube/*
// @match        *://*.vjav.com/*
// @match        *://*.vjav.tube/*
// @match        *://*.hclips.com/*
// @match        *://*.hdzog.com/*
// @match        *://*.hdzog.tube/*
// @match        *://*.hotmovs.com/*
// @match        *://*.hotmovs.tube/*
// @match        *://*.inporn.com/*
// @match        *://*.privatehomeclips.com/*
// @match        *://*.tubepornclassic.com/*
// @match        *://*.voyeurhit.com/*
// @match        *://*.voyeurhit.tube/*
// @match        *://*.vxxx.com/*
// @match        *://*.nuvid.com/*
// @match        *://*.rule34video.com/*
// @match        *://*.spankbang.com/*
// @match        *://*.nsfw.xxx/*
// @match        *://*.thisvid.com/*
// @match        *://*.nsfw247.to/*
// @match        *://*.pornhub.com/*
// @match        *://*.pornhub.org/*
// @include      /^https?:\/\/(?:[a-z0-9-]+\.)*xhamster[0-9]{1,3}\.(?:com|desi)\//
// @match        *://*.fullxh.com/videos/*
// @match        *://*.megaxh.com/videos/*
// @match        *://*.xhaccess.com/videos/*
// @match        *://*.xhamp.net/videos/*
// @match        *://*.xhbig.com/videos/*
// @match        *://*.xhco.life/videos/*
// @match        *://*.xhco.live/videos/*
// @match        *://*.xhezr.skin/videos/*
// @match        *://*.xhfanclub.com/videos/*
// @match        *://*.xhfuck.com/videos/*
// @match        *://*.xhnetwork.live/videos/*
// @match        *://*.xhplanet.com/videos/*
// @match        *://*.xhreal5.com/videos/*
// @match        *://*.xhsocial.com/videos/*
// @match        *://*.xhspot.com/videos/*
// @match        *://*.xhtotal.com/videos/*
// @match        *://*.xhtv.live/videos/*
// @match        *://*.xhvid1.com/videos/*
// @grant        GM_xmlhttpRequest
// @grant        GM.xmlHttpRequest
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_registerMenuCommand
// @grant        GM_notification
// @grant        GM.notification
// @connect      nsfwdl.com
// @connect      dl.nsfwdl.com
// @antifeature  payment Downloads are free, up to 30 a day. 1080p is free for the first 10 of them. More a day, more 1080p, qualities above 1440p and files over 500 MB need a paid NSFWDL Supporter key (entered in Settings); without one, those qualities are shown with a lock and never started.
// @run-at       document-idle
// @noframes
// ==/UserScript==

// How it works (and what it sends):
// - On a single-video page of a supported site (and on RedGifs feeds, for
//   the clip on screen) it shows a small Download button. Nothing is
//   requested until you open the panel. Then the current video's public
//   page link is sent to https://nsfwdl.com only, to list its
//   real formats. Choosing one starts the job on NSFWDL; the panel follows
//   its status and hands the finished MP4 to your browser's downloads.
// - Requests go to nsfwdl.com and its download host dl.nsfwdl.com, nowhere
//   else. They carry a fixed "/userscript" marker so NSFWDL can count
//   downloads made from this script ("/userscript/bulk" for videos queued
//   with Select videos). Like any visit, they reach NSFWDL from
//   your IP address.
// - Supporter key (optional, Settings): many userscript managers don't send
//   your nsfwdl.com cookies, so the key you enter is exchanged once on
//   nsfwdl.com for a session token. The script keeps the token in your
//   userscript manager and sends it only to nsfwdl.com, in an
//   X-NSFWDL-Supporter header. "Remove" ends that session; the key itself
//   is never stored. If your manager does send the cookies and you activated
//   a key on nsfwdl.com in this browser, the script asks nsfwdl.com for its
//   own session instead, so you don't type the key twice.
// - Free downloads per day count per browser, not per IP address, so people
//   sharing a VPN or mobile-network address don't use up each other's. For
//   that the script makes one random value, keeps it in your userscript
//   manager and sends it only to nsfwdl.com, in an X-NSFWDL-Client header.
//   It is not linked to you, an account or your IP.
// - The script stores only its settings, that random value, whether you
//   minimized the button and, unless you turn it off, a list of the videos
//   you saved with it, to mark them as downloaded (GM_setValue; only the
//   random value is ever sent, as above). No analytics, ads or tracking
//   code.
// - Without GM_xmlhttpRequest (some managers), the button falls back to
//   opening the video in NSFWDL in a new tab, as version 1 did.
(function () {
  "use strict";

  const NSFWDL = "https://nsfwdl.com";
  const DOWNLOAD_HOSTS = Object.freeze(["dl.nsfwdl.com", "nsfwdl.com"]);
  const PAGE_PATH = "/userscript";
  // Bulk select (2.7.0): videos queued from a listing page. NSFWDL lets
  // these requests yield when a site is busy, so normal clicks go first.
  const BULK_PAGE_PATH = "/userscript/bulk";
  const LISTING_MIN = 4;        // video links on a page before "Select videos" shows
  const BULK_WAIT_KINDS = Object.freeze(["server_busy", "rate_limited_download_start", "rate_limited_extraction", "rate_limited_upstream"]);
  const BULK_FAIL_STREAK = 3;   // failures in a row that pause a batch
  const BULK_REF_MAX_AGE_MS = 10 * 60 * 1000;   // NSFWDL format refs last 15 minutes
  const WIDGET_ID = "nsfwdl-download-widget";
  const THUMB_ID = "nsfwdl-thumb-button";
  const LISTING_URL = "https://sleazyfork.org/en/scripts/597630";
  const POLL_MS = 2000;
  // Background tabs poll slower (battery, CPU); each loop re-reads
  // document.hidden, so coming back resumes full speed at once. Kept at 5 s:
  // the browser suite finishes hidden queued jobs within 30 s.
  const POLL_HIDDEN_MS = 5000;
  const SYNC_MS = 1000;
  const SYNC_HIDDEN_MS = 10000;
  function pollDelay() { return document.hidden ? POLL_HIDDEN_MS : POLL_MS; }
  function syncDelay() { return document.hidden ? SYNC_HIDDEN_MS : SYNC_MS; }
  const PREPARE_DEADLINE_MS = 20 * 60 * 1000;
  const HANDOFF_DEADLINE_MS = 10 * 60 * 1000;
  const QUALITY_CHOICES = Object.freeze(["ask", "best", "1080", "720", "480", "smallest"]);
  const QUALITY_LABELS = Object.freeze({
    ask: "Ask every time", best: "Best available", 1080: "1080p or lower", 720: "720p or lower",
    480: "480p or lower", smallest: "Smallest file",
  });
  const DEFAULT_SETTINGS = Object.freeze({quality: "ask", position: "right", thumbs: true, marks: true, bulk: true});
  // At most this many downloads run at once from the script; the rest wait
  // their turn in the panel. NSFWDL lets a Free connection read 3 files at
  // a time, and the site itself may need a slot too.
  const MAX_PARALLEL = 4;    // with a Supporter session
  const FREE_PARALLEL = 3;   // NSFWDL's Free limit on files at once (2026-10-11)
  const HISTORY_LIMIT = 3000;
  // xHamster's rotating mirror domains (xhspot.com, xhaccess.com, ...): a
  // video page there ends in xHamster's own video ID, "xh..." or the 6-9
  // digit one of older videos. NSFWDL fetches the same video on xhamster.com.
  const XH_MIRROR_VIDEO = /^\/videos\/[^/?#]+-(?:xh[0-9A-Za-z]{4,12}|[0-9]{6,9})\/?$/;

  const SITES = [
    {id: "xnxx", name: "XNXX", route: "/xnxx-downloader", hosts: ['xnxx.com'], hostPatterns: [], video: /^\/video-/},
    {id: "xvideos", name: "XVideos", route: "/xvideos-downloader", hosts: ['xvideos.com'], hostPatterns: [], video: /^\/video[.\d]/},
    {id: "xhamster", name: "xHamster", route: "/xhamster-downloader", hosts: ['xhamster.com', 'xhamster.one', 'xhamster.desi', 'xhms.pro', 'xhday.com', 'xhvid.com'], hostPatterns: [/(?:[a-z0-9-]+\.)*xhamster[0-9]{1,3}\.(?:com|desi)/], video: /^\/(?:videos\/|shorts\/[^/?#]+-xh[0-9A-Za-z]{4,12}\/?$)/},
    {id: "eporner", name: "Eporner", route: "/eporner-downloader", hosts: ['eporner.com'], hostPatterns: [], video: /^\/(?:video-|hd-porn\/)/},
    {id: "erome", name: "Erome", route: "/erome-downloader", hosts: ['erome.com'], hostPatterns: [], video: /^\/a\//},
    {id: "redgifs", name: "RedGifs", route: "/redgifs-downloader", hosts: ['redgifs.com'], hostPatterns: [], video: /^\/watch\//},
    {id: "youjizz", name: "YouJizz", route: "/youjizz-downloader", hosts: ['youjizz.com'], hostPatterns: [], video: /^\/videos\//},
    {id: "porntop", name: "PornTop", route: "/porntop-downloader", hosts: ['porntop.com'], hostPatterns: [], video: /^\/video\//},
    {id: "redtube", name: "RedTube", route: "/redtube-downloader", hosts: ['redtube.com'], hostPatterns: [], video: /^\/\d+/},
    {id: "youporn", name: "YouPorn", route: "/youporn-downloader", hosts: ['youporn.com'], hostPatterns: [], video: /^\/watch\/\d+/},
    {id: "tnaflix", name: "TNAFlix", route: "/tnaflix-downloader", hosts: ['tnaflix.com'], hostPatterns: [], video: /\/video\d+/},
    {id: "porntrex", name: "Porntrex", route: "/porntrex-downloader", hosts: ['porntrex.com'], hostPatterns: [], video: /^\/video\/\d+/},
    {id: "noodlemagazine", name: "NoodleMagazine", route: "/noodlemagazine-downloader", hosts: ['noodlemagazine.com'], hostPatterns: [], video: /^\/watch\//},
    {id: "txxx", name: "TXXX", route: "/txxx-downloader", hosts: ['txxx.com', 'txxx.tube', 'upornia.com', 'upornia.tube', 'vjav.com', 'vjav.tube', 'hclips.com', 'hdzog.com', 'hdzog.tube', 'hotmovs.com', 'hotmovs.tube', 'inporn.com', 'privatehomeclips.com', 'tubepornclassic.com', 'voyeurhit.com', 'voyeurhit.tube', 'vxxx.com'], hostPatterns: [], video: /^\/(?:videos\/\d+|video-\d+)/},
    {id: "nuvid", name: "Nuvid", route: "/nuvid-downloader", hosts: ['nuvid.com'], hostPatterns: [], video: /^\/video\/\d+/},
    {id: "rule34video", name: "Rule34Video", route: "/rule34video-downloader", hosts: ['rule34video.com'], hostPatterns: [], video: /^\/video\/\d+/},
    {id: "spankbang", name: "SpankBang", route: "/spankbang-downloader", hosts: ['spankbang.com'], hostPatterns: [], video: /^\/[a-z0-9]+\/video\//},
    {id: "nsfwxxx", name: "NSFW.xxx", route: "/nsfwxxx-downloader", hosts: ['nsfw.xxx'], hostPatterns: [], video: /^\/post\/\d+/},
    {id: "thisvid", name: "ThisVid", route: "/thisvid-downloader", hosts: ['thisvid.com'], hostPatterns: [], video: /^\/videos\//},
    {id: "nsfw247", name: "NSFW247", route: "/nsfw247-downloader", hosts: ['nsfw247.to'], hostPatterns: [], video: /^\/(?=[^/?]*\d)[a-z0-9]+(?:-[a-z0-9]+)+\/?(?:\?.*)?$/i},
    {id: "pornhub", name: "PornHub", route: "/pornhub-downloader", hosts: ['pornhub.com', 'pornhub.org'], hostPatterns: [], video: /^\/(?:view_(?:video|clip)\.php\?(?:.*&)?viewkey=|shorties\/[A-Za-z0-9]+|gif\/\d+)/},
  ];

  function siteFor(hostname) {
    const host = String(hostname || "").toLowerCase().replace(/\.$/, "");
    return SITES.find((site) =>
      site.hosts.some((base) => host === base || host.endsWith("." + base)) ||
      site.hostPatterns.some((pattern) => new RegExp("^" + pattern.source + "$").test(host))
    ) || null;
  }

  function isVideoPage(site, url) {
    return Boolean(site) && site.video.test(url.pathname + url.search);
  }

  // xHamster for a video page on one of its mirror domains; null otherwise.
  function mirrorSite(url) {
    const labels = String(url.hostname || "").toLowerCase().split(".");
    if (labels.length < 2 || !labels[labels.length - 2].includes("xh") || !XH_MIRROR_VIDEO.test(url.pathname)) return null;
    return SITES.find((s) => s.id === "xhamster");
  }

  function siteForUrl(url) {
    return siteFor(url.hostname) || mirrorSite(url);
  }

  // A stable key for "this video" across a site's domains and mirrors, for
  // the downloaded marks: PornHub's viewkey, xHamster's video ID, otherwise
  // the site and the page path.
  function videoKey(site, href) {
    let url;
    try { url = new URL(href); } catch (_) { return ""; }
    if (!site) return "";
    if (site.id === "pornhub") {
      const key = url.searchParams.get("viewkey");
      if (key) return "pornhub:" + key;
    }
    if (site.id === "xhamster") {
      const id = (url.pathname.match(/-(xh[0-9A-Za-z]{4,12}|[0-9]{5,9})\/?$/) || [])[1];
      if (id) return "xhamster:" + id;
    }
    return site.id + ":" + url.pathname.replace(/\/+$/, "").toLowerCase();
  }

  // ── Feeds ──────────────────────────────────────────────────────────────
  // RedGifs' feeds (home, /browse, niches, profiles, and the list under a
  // /watch/ clip) keep one URL while clips scroll by. RedGifs marks the clip
  // on screen as div.GifPreview_isActive[data-feed-item-id="<id>"] and moves
  // its single <video> there (checked live, desktop and phone, 2026-10-08).
  // Only the page is read; nothing is sent until you click.
  // Returns the clip's /watch/ link, "" when the clip on screen is not a
  // video, or undefined on pages without a feed (the URL decides there).
  const REDGIFS_ID = /^[A-Za-z0-9]{4,100}$/;
  function redgifsFeedUrl(doc) {
    const previews = doc.querySelectorAll(".GifPreview[data-feed-item-id]");
    if (!previews.length) return undefined;
    let active = doc.querySelector(".GifPreview.GifPreview_isActive[data-feed-item-id]");
    if (!active) {
      const playing = Array.from(doc.querySelectorAll(".GifPreview[data-feed-item-id] video")).find((v) => !v.paused);
      active = playing ? playing.closest(".GifPreview[data-feed-item-id]") : null;
    }
    if (!active || !(active.classList.contains("GifPreview_isVideo") || active.querySelector("video"))) return "";
    const id = active.getAttribute("data-feed-item-id") || "";
    return REDGIFS_ID.test(id) ? "https://www.redgifs.com/watch/" + id.toLowerCase() : "";
  }
  // xHamster Shorts: the URL becomes /shorts/<slug>-xh<id> once you scroll
  // (checked live on desktop, 2026-10-11), which the URL rule covers. Only
  // the first clip of the bare /shorts feed has no link of its own; the page
  // names it in "firstMomentProps" (slashes escaped). It is used only while
  // the clip on screen is that one (div[data-id] = its numeric id).
  function xhamsterShortsUrl(doc) {
    if (!/^\/shorts\/?$/.test(doc.location.pathname)) return undefined;
    let first = null;
    for (const script of doc.querySelectorAll("script:not([src])")) {
      const text = script.textContent || "";
      const at = text.indexOf('"firstMomentProps":{"id":');
      if (at < 0) continue;
      const chunk = text.slice(at, at + 20000);
      const id = (chunk.match(/^"firstMomentProps":\{"id":(\d{3,12})\b/) || [])[1];
      const page = (chunk.match(/"pageURL":"(https:\\\/\\\/[^"]{10,300})"/) || [])[1];
      // Keep looking otherwise: a userscript manager may add this very
      // script inline, and its text names "firstMomentProps" too.
      if (id && page) { first = {id, url: page.replace(/\\\//g, "/")}; break; }
    }
    if (!first || !/^https:\/\/[^/]+\/shorts\/[^/?#]+-xh[0-9A-Za-z]{4,12}\/?$/.test(first.url)) return "";
    const view = doc.defaultView;
    let best = null;
    let bestArea = 0;
    for (const node of doc.querySelectorAll("div[data-id]")) {
      const r = node.getBoundingClientRect();
      const area = Math.max(0, Math.min(r.bottom, view.innerHeight) - Math.max(r.top, 0)) * Math.max(0, Math.min(r.right, view.innerWidth) - Math.max(r.left, 0));
      if (area > bestArea) { best = node; bestArea = area; }
    }
    return best && best.getAttribute("data-id") === first.id ? first.url : "";
  }
  const FEEDS = Object.freeze({redgifs: redgifsFeedUrl, xhamster: xhamsterShortsUrl});

  // The video the dock is for: the clip on screen in a feed, else the page.
  function currentVideoUrl(site, href, doc) {
    let url;
    try { url = new URL(href); } catch (_) { return ""; }
    const feed = site && FEEDS[site.id] ? FEEDS[site.id](doc) : undefined;
    if (feed !== undefined) return feed;
    return isVideoPage(site, url) ? href.split("#")[0] : "";
  }

  // Version 1's behaviour, kept as the fallback: the NSFWDL page for this
  // site with the video link in the #url= fragment (never sent to a server).
  function targetUrl(site, pageUrl) {
    return NSFWDL + site.route + "?ref=userscript#url=" + encodeURIComponent(pageUrl);
  }

  // A link on a listing, search or profile page that leads to a single
  // video of the same site, as an absolute URL; null for anything else.
  function videoLinkTarget(site, href, baseHref) {
    let url;
    try { url = new URL(href, baseHref); } catch (_) { return null; }
    if (url.protocol !== "https:" && url.protocol !== "http:") return null;
    if (siteForUrl(url) !== site || !isVideoPage(site, url)) return null;
    url.hash = "";
    return url.href;
  }

  // ── Formats ────────────────────────────────────────────────────────────
  // One list from NSFWDL's /api/extract, best first. Only what the source
  // really offers; sizes are NSFWDL's own figures (exact or estimated).
  function qualityBadge(height) {
    if (height >= 2160) return "4K";
    if (height >= 1440) return "2K";
    if (height >= 1080) return "Full HD";
    if (height >= 720) return "HD";
    return "";
  }

  function normalizeFormats(data, supporterActive) {
    const formats = (data && Array.isArray(data.formats) ? data.formats : [])
      .filter((f) => f && typeof f.format_ref === "string" && f.format_ref && f.access !== "unsupported");
    const withVideo = formats.filter((f) => f.has_video !== false);
    const list = (withVideo.length ? withVideo : formats).map((f) => {
      const height = Number(f.height) || Number((String(f.quality_label || "").match(/(\d{3,4})p/) || [])[1]) || 0;
      const size = Number(f.estimated_size_bytes || f.filesize || f.filesize_approx) || 0;
      return {
        ref: f.format_ref,
        height,
        label: height ? height + "p" : String(f.quality_label || "Original").slice(0, 40),
        fps: Number(f.fps) > 30 ? Math.round(Number(f.fps)) : 0,
        sizeBytes: size > 0 ? size : null,
        sizeExact: f.size_kind === "exact",
        locked: f.access === "supporter" && !supporterActive,
        // Why the server locks it: file_size, quality (above 1440p) or
        // hd_allowance (today's free 1080p downloads are used).
        reason: typeof f.limit_reason === "string" ? f.limit_reason : "file_size",
        recommended: f.recommended === true,
        badge: qualityBadge(height),
      };
    });
    list.sort((a, b) => (b.height - a.height) || ((b.sizeBytes || 0) - (a.sizeBytes || 0)));
    const seen = new Set();
    return list.filter((c) => {
      const key = c.label + "|" + c.fps + "|" + c.locked;
      if (seen.has(key)) return false;
      seen.add(key);
      return true;
    });
  }

  // The format a one-click download takes for the "preferred quality"
  // setting; never a locked (Supporter) one. null means "ask".
  function pickPreferred(choices, preference) {
    const free = (choices || []).filter((c) => !c.locked);
    if (!free.length || !preference || preference === "ask") return null;
    if (preference === "best") return free[0];
    if (preference === "smallest") return free[free.length - 1];
    const cap = Number(preference);
    if (!cap) return null;
    return free.find((c) => c.height && c.height <= cap) || free[free.length - 1];
  }

  // One sentence per lock reason present in the list, in a fixed order.
  function lockReasons(choices) {
    const reasons = new Set(choices.filter((c) => c.locked).map((c) => c.reason));
    const text = {
      hd_allowance: "You've used today's free 1080p downloads; 720p and lower stay free.",
      quality: "Qualities above 1440p are for Supporters.",
      file_size: "Files over 500 MB are for Supporters.",
    };
    const known = Object.keys(text).filter((reason) => reasons.has(reason)).map((reason) => text[reason]);
    return (known.length ? known : [text.file_size]).join(" ");
  }

  // Only NSFWDL's own one-time file links are ever opened.
  function safeDownloadUrl(value) {
    let url;
    try { url = new URL(String(value || ""), NSFWDL); } catch (_) { return null; }
    if (url.protocol !== "https:" || !DOWNLOAD_HOSTS.includes(url.hostname) || url.port) return null;
    if (!/^\/(?:d|api\/download)\/[A-Za-z0-9_-]{20,128}$/.test(url.pathname)) return null;
    return url.origin + url.pathname;
  }

  function formatBytes(bytes) {
    const mb = bytes / 1e6;
    if (mb >= 1000) return (mb / 1000).toFixed(2) + " GB";
    return (mb >= 100 ? Math.round(mb) : mb.toFixed(1)) + " MB";
  }

  function formatSize(choice) {
    if (!choice.sizeBytes) return "";
    return (choice.sizeExact ? "" : "~") + formatBytes(choice.sizeBytes);
  }

  function formatDuration(seconds) {
    const s = Math.floor(Number(seconds) || 0);
    if (s <= 0) return "";
    const h = Math.floor(s / 3600), m = Math.floor((s % 3600) / 60), r = s % 60;
    return h ? h + ":" + String(m).padStart(2, "0") + ":" + String(r).padStart(2, "0") : m + ":" + String(r).padStart(2, "0");
  }

  // NSFWDL refuses a file while this connection already reads its limit of
  // files at once (Free: 3). A slot frees only when one of them finishes,
  // which takes 5-15 minutes on a slow line, so a refused job waits that long
  // (15 s, then 30 s, then every minute) instead of failing. With 6 tries 15 s
  // apart, 12 of 20 refused xHamster/PornHub files never arrived (7 days to
  // 2026-10-12).
  const SLOT_WAIT_MS = 30 * 60 * 1000;

  function slotRetrySeconds(attempt, retryAfter) {
    return Math.max(Number(retryAfter) || 0, Math.min(60, 15 * 2 ** Math.max(0, attempt - 1)));
  }

  // ── Bulk downloads (2.7.0) ─────────────────────────────────────────────
  // NSFWDL sends the limits with the downloads left today, so they change
  // without a script update; a parallel of 0 switches bulk off.
  function bulkLimits(status) {
    const bulk = status && status.bulk;
    if (!bulk || typeof bulk !== "object") return null;
    const whole = (value, max) => Math.max(0, Math.min(max, Math.floor(Number(value) || 0)));
    const left = Number.isInteger(status.downloads_left_today) ? Math.max(0, status.downloads_left_today) : null;
    return {parallel: whole(bulk.parallel, 8), maxItems: whole(bulk.max_items, 300), gapMs: Math.max(500, whole(bulk.start_gap_ms, 60000)), left};
  }

  // What a batch takes from the picked videos: never more than the batch
  // limit or the downloads left today, and nothing already queued.
  function planBatch(urls, limits, queued) {
    const fresh = [];
    for (const url of urls || []) if (!(queued && queued.has(url)) && !fresh.includes(url)) fresh.push(url);
    let room = limits ? limits.maxItems : 0;
    if (limits && limits.left !== null && limits.left !== undefined) room = Math.min(room, limits.left);
    const take = fresh.slice(0, Math.max(0, room));
    return {take, over: fresh.length - take.length};
  }

  // Whether the next bulk video may start now. A normal click always keeps
  // one slot: bulk never takes the last one.
  function bulkMayStart(o) {
    if (o.paused || !o.parallel) return false;
    if (o.runningBulk >= o.parallel || o.running >= o.limit - 1) return false;
    return o.now - o.lastStart >= o.gapMs;
  }

  // What a job's row says, from the server's measured state only.
  function jobView(job) {
    switch (job.phase) {
      case "waiting":
        if (job.busyWait) return {mode: "waiting", text: "The site is busy on NSFWDL. Trying again shortly…"};
        if (job.slotWaitSince) return {mode: "waiting", text: "Waiting for one of your downloads to finish…"};
        return {mode: "waiting", text: job.ahead > 0 ? "Waiting its turn · " + job.ahead + " ahead" : "Waiting its turn…"};
      case "starting": return {mode: "waiting", text: "Starting…"};
      case "queued": return {mode: "waiting", text: "Waiting for a free slot on NSFWDL…"};
      case "preparing": {
        const done = Number(job.bytesPrepared) || 0;
        if (done > 0 && job.sizeBytes && job.sizeBytes > done) {
          const fraction = Math.min(0.99, done / job.sizeBytes);
          return {mode: "measured", fraction, text: "Preparing " + Math.floor(fraction * 100) + "% · " + formatBytes(done) + " of ~" + formatBytes(job.sizeBytes)};
        }
        return {mode: "working", text: done > 0 ? "Preparing the file… " + formatBytes(done) : "Preparing the file…"};
      }
      case "saving": return {mode: "working", text: "Handing the file to your browser…"};
      case "receiving": return {mode: "working", text: "Your browser is downloading the file…"};
      case "stalled": return {mode: "stalled", text: "Your browser didn't start the download. Save it with the button below."};
      case "saved": return {mode: "done", text: "Saved to your downloads"};
      case "handed": return {mode: "done", text: "Handed to your browser. Check your downloads."};
      case "failed": return {mode: "error", text: job.error || "This download failed."};
      default: return {mode: "waiting", text: "…"};
    }
  }

  if (typeof module === "object" && module.exports) {
    module.exports = {SITES, FEEDS, xhamsterShortsUrl, currentVideoUrl, siteFor, siteForUrl, mirrorSite, videoKey, isVideoPage, targetUrl, videoLinkTarget, normalizeFormats, pickPreferred, lockReasons, safeDownloadUrl, qualityBadge, jobView, formatDuration, slotRetrySeconds, SLOT_WAIT_MS, MAX_PARALLEL, FREE_PARALLEL, bulkLimits, planBatch, bulkMayStart, BULK_PAGE_PATH};
    return;
  }

  const site = siteForUrl(new URL(location.href));
  if (!site) return;

  // ── Transport (GM_xmlhttpRequest to nsfwdl.com only) ───────────────────
  function gmRequestFunction() {
    try { if (typeof GM_xmlhttpRequest === "function") return GM_xmlhttpRequest; } catch (_) { /* not granted */ }
    try { if (typeof GM === "object" && GM && typeof GM.xmlHttpRequest === "function") return GM.xmlHttpRequest.bind(GM); } catch (_) { /* not granted */ }
    return null;
  }

  function api(method, path, body, timeout) {
    const send = gmRequestFunction();
    return new Promise((resolve, reject) => {
      const fail = (message, extra) => reject(Object.assign(new Error(message), {status: 0, transient: true}, extra || {}));
      const headers = body ? {"Content-Type": "application/json", Accept: "application/json"} : {Accept: "application/json"};
      const token = supporterToken();
      if (token) headers["X-NSFWDL-Supporter"] = token;
      const client = clientToken();
      if (client) headers["X-NSFWDL-Client"] = client;
      send({
        method,
        url: NSFWDL + path,
        headers,
        data: body ? JSON.stringify(body) : undefined,
        timeout: timeout || 45000,
        onload: (response) => {
          let data = {};
          try { data = JSON.parse(response.responseText || "{}"); } catch (_) { data = {}; }
          if (!data || typeof data !== "object" || Array.isArray(data)) data = {};
          const status = Number(response.status) || 0;
          if (status >= 200 && status < 300) { resolve(data); return; }
          if (data.error_kind === "supporter_session_expired" && token) forgetSupporter();
          const message = typeof data.message === "string" && data.message.trim()
            ? data.message.trim().slice(0, 300)
            : status === 429 ? "Too many requests right now. Wait a moment and try again." : "NSFWDL couldn't process this video.";
          reject(Object.assign(new Error(message), {
            status,
            kind: typeof data.error_kind === "string" ? data.error_kind : "",
            transient: data.transient === true || status === 429 || status >= 500,
            retryAfter: Number(data.retry_after_seconds) || 0,
            supporter: data.category === "size" || (data.error_kind === "rate_limited_daily_downloads" && !supporterActive()),
          }));
        },
        onerror: () => fail("Can't reach NSFWDL. Check your connection."),
        ontimeout: () => fail("NSFWDL took too long to answer. Try again."),
      });
    });
  }

  // ── Settings (GM storage) ───────────────────────────────────────────────
  function readValue(key, fallback) {
    try { return typeof GM_getValue === "function" ? GM_getValue(key, fallback) : fallback; } catch (_) { return fallback; }
  }

  function writeValue(key, value) {
    try { if (typeof GM_setValue === "function") GM_setValue(key, value); } catch (_) { /* optional */ }
  }

  function readSettings() {
    const stored = readValue("settings", null);
    const value = Object.assign({}, DEFAULT_SETTINGS, stored && typeof stored === "object" ? stored : {});
    if (!QUALITY_CHOICES.includes(String(value.quality))) value.quality = DEFAULT_SETTINGS.quality;
    if (value.position !== "left") value.position = "right";
    value.thumbs = value.thumbs !== false;
    value.marks = value.marks !== false;
    value.bulk = value.bulk !== false;
    return value;
  }

  const settings = readSettings();
  const inPage = Boolean(gmRequestFunction());

  // ── Browser ID for the Free daily count (random, made once) ────────────
  // NSFWDL counts Free downloads per browser with it instead of per IP.
  // Never derived from anything about you; "" if the browser has no
  // crypto.getRandomValues (the server then counts per IP, as before).
  function clientToken() {
    const stored = readValue("client", "");
    if (typeof stored === "string" && /^[A-Za-z0-9_-]{22,64}$/.test(stored)) return stored;
    try {
      const bytes = new Uint8Array(24);
      crypto.getRandomValues(bytes);
      const token = btoa(String.fromCharCode(...bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
      writeValue("client", token);
      return token;
    } catch (_) {
      return "";
    }
  }

  // ── Supporter session (token only; the key itself is never stored) ─────
  // {token, expiresAt (unix seconds)}. The server is the authority: an
  // expired or revoked session answers supporter_session_expired, which
  // drops it here too.
  let supporter = readSupporter();
  let supporterChecked = false;
  // 2.7.1: a key activated on nsfwdl.com in this browser (see linkFromSite).
  let siteLink = null;      // the request in flight
  let siteLinkAt = 0;       // when it was last asked
  const SITE_LINK_EVERY_MS = 20000;

  function readSupporter() {
    const stored = readValue("supporter", null);
    if (!stored || typeof stored !== "object" || typeof stored.token !== "string" || !stored.token) return null;
    const expiresAt = Number(stored.expiresAt) || 0;
    return expiresAt * 1000 > Date.now() ? {token: stored.token, expiresAt} : null;
  }

  function supporterToken() {
    return supporter && supporter.expiresAt * 1000 > Date.now() ? supporter.token : "";
  }

  function supporterActive() {
    return Boolean(supporterToken());
  }

  function forgetSupporter() {
    supporter = null;
    writeValue("supporter", null);
  }

  // Checks a stored session once per page, before the first format list.
  // Re-reads the storage first: another tab may have added or removed it.
  async function checkSupporter() {
    const stored = readSupporter();
    if (!stored || !supporter || stored.token !== supporter.token) supporterChecked = false;
    supporter = stored;
    if (!supporterToken()) { linkFromSite(); return; }
    if (supporterChecked) return;
    supporterChecked = true;
    try {
      const status = await api("GET", "/api/supporter/status", null, 15000);
      if (status.tier !== "supporter") forgetSupporter();
      else if (Number(status.expires_at)) {
        supporter = {token: supporter.token, expiresAt: Number(status.expires_at)};
        writeValue("supporter", supporter);
      }
    } catch (error) {
      if (!error.transient) forgetSupporter();
      else supporterChecked = false;
    }
  }

  // With no session of its own, asks nsfwdl.com (at most every 20 s, and
  // again when the tab comes back into view) whether this browser has a key
  // active on the site. That works only when the manager sends the site's
  // cookie; nsfwdl.com then gives the script its own session for that key.
  // Off after "Remove from this browser" until a key is entered here again.
  function linkFromSite() {
    if (supporterToken() || readValue("siteLink", true) === false) return Promise.resolve(false);
    if (siteLink) return siteLink;
    if (Date.now() - siteLinkAt < SITE_LINK_EVERY_MS) return Promise.resolve(false);
    siteLinkAt = Date.now();
    siteLink = api("POST", "/api/supporter/link", {client: "userscript"}, 8000).then((data) => {
      if (supporterToken() || data.tier !== "supporter" || typeof data.session_token !== "string" || !data.session_token) return false;
      supporter = {token: data.session_token, expiresAt: Number(data.expires_at) || 0};
      supporterChecked = true;
      writeValue("supporter", supporter);
      return supporterActive();
    }, () => false).finally(() => { siteLink = null; });
    return siteLink;
  }

  // Lets a site check that is already on its way finish before the
  // formats are locked or unlocked.
  async function siteLinkSettled() {
    if (siteLink) await siteLink;
  }

  async function activateSupporter(key) {
    const data = await api("POST", "/api/supporter/activate", {key, client: "userscript"}, 20000);
    if (data.tier !== "supporter" || typeof data.session_token !== "string" || !data.session_token) {
      throw new Error("That key could not be activated.");
    }
    supporter = {token: data.session_token, expiresAt: Number(data.expires_at) || 0};
    supporterChecked = true;
    writeValue("supporter", supporter);
    writeValue("siteLink", true);
  }

  async function removeSupporter() {
    try { await api("POST", "/api/supporter/logout", {}, 15000); } catch (_) { /* removed locally anyway */ }
    forgetSupporter();
    writeValue("siteLink", false);
  }

  // ── Downloaded marks (local list, never sent anywhere) ─────────────────
  // {videoKey: day number}; the oldest entries go past HISTORY_LIMIT.
  function readHistory() {
    const stored = readValue("history", null);
    return stored && typeof stored === "object" && !Array.isArray(stored) ? stored : {};
  }
  let history = readHistory();

  function wasDownloaded(url) {
    if (!settings.marks) return false;
    const key = videoKey(siteForUrl(new URL(url)) || site, url);
    return Boolean(key) && Object.prototype.hasOwnProperty.call(history, key);
  }

  function rememberDownload(url) {
    if (!settings.marks || !url) return;
    let key;
    try { key = videoKey(siteForUrl(new URL(url)) || site, url); } catch (_) { return; }
    if (!key) return;
    history = readHistory();   // another tab may have added some
    delete history[key];
    history[key] = Math.floor(Date.now() / 86400000);
    const keys = Object.keys(history);
    if (keys.length > HISTORY_LIMIT) for (const old of keys.slice(0, keys.length - HISTORY_LIMIT)) delete history[old];
    writeValue("history", history);
    marksSeen = new WeakMap();
    scheduleMarks();
  }

  function clearHistory() {
    history = {};
    marksSeen = new WeakMap();
    writeValue("history", {});
    for (const img of document.querySelectorAll("[data-nsfwdl-saved]")) img.removeAttribute("data-nsfwdl-saved");
  }

  // ── Telling the visitor when they're elsewhere ─────────────────────────
  function notifyFunction() {
    try { if (typeof GM_notification === "function") return GM_notification; } catch (_) { /* not granted */ }
    try { if (typeof GM === "object" && GM && typeof GM.notification === "function") return GM.notification.bind(GM); } catch (_) { /* not granted */ }
    return null;
  }

  // Only when this tab is in the background: in front, the panel says it.
  function notify(text) {
    const send = notifyFunction();
    if (!send || !document.hidden) return;
    try { send({title: "NSFWDL", text, silent: false, timeout: 15000, onclick: () => { try { window.focus(); } catch (_) { /* ignore */ } }}); } catch (_) { /* optional */ }
  }

  // Progress in the tab title while downloads run ("⬇ 45% · page title").
  const TITLE_MARK = /^(?:⬇ [^·]{1,20}(?:·\s*|$))+/;
  let titleOwned = false;
  function updateTitle() {
    const running = state.jobs.filter((job) => !FINISHED.includes(job.phase));
    const counts = bulkCounts();
    let label = "";
    if (counts && counts.active) {
      label = "⬇ " + counts.done + "/" + counts.total;
    } else if (running.length === 1) {
      const view = jobView(running[0]);
      label = view.mode === "measured" ? "⬇ " + Math.floor(view.fraction * 100) + "%" : "⬇ …";
    } else if (running.length > 1) {
      label = "⬇ " + running.length + " running";
    }
    const base = document.title.replace(TITLE_MARK, "");
    if (label) {
      const next = base ? label + " · " + base : label;
      if (document.title !== next) document.title = next;
      titleOwned = true;
    } else if (titleOwned) {
      if (document.title !== base) document.title = base;
      titleOwned = false;
    }
  }

  // ── UI ─────────────────────────────────────────────────────────────────
  const STYLE = `
    :host { all: initial; color-scheme: dark; }
    * { box-sizing: border-box; }
    .root { position: relative; font: 600 14px/1.35 system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif; color: #f4f1ff; }
    .dock { display: flex; align-items: stretch; gap: 6px; max-width: calc(100vw - 32px); padding: 6px; border: 1px solid rgba(196,181,253,.25); border-radius: 16px; background: rgba(14,9,24,.96); box-shadow: 0 16px 38px rgba(0,0,0,.45), 0 0 26px rgba(250,42,191,.18); backdrop-filter: blur(14px); -webkit-backdrop-filter: blur(14px); }
    .brand { display: flex; flex-direction: column; justify-content: center; padding: 4px 8px 4px 10px; white-space: nowrap; }
    .brand strong { font-size: 14px; letter-spacing: -.02em; background: linear-gradient(110deg,#fff,#a78bfa 50%,#fa2abf); -webkit-background-clip: text; background-clip: text; color: transparent; }
    .brand small { max-width: 110px; overflow: hidden; color: #a99bc8; font-size: 10px; font-weight: 600; text-overflow: ellipsis; }
    .btn { display: inline-flex; min-height: 44px; align-items: center; justify-content: center; gap: 6px; padding: 0 14px; border: 1px solid transparent; border-radius: 11px; color: #fff; font: inherit; font-weight: 800; text-decoration: none; cursor: pointer; transition: filter .15s ease, transform .15s ease; -webkit-tap-highlight-color: transparent; }
    .btn-primary { background: linear-gradient(135deg,#6f46ff,#fa2abf); }
    .btn-ghost { background: transparent; border-color: rgba(196,181,253,.3); color: #ddd6fe; }
    .btn-icon { min-width: 34px; padding: 0 8px; background: transparent; color: #a99bc8; }
    .btn:hover { filter: brightness(1.1); transform: translateY(-1px); }
    .btn:focus-visible, .card:focus-visible, a:focus-visible, select:focus-visible, input:focus-visible { outline: 3px solid #fbbf24; outline-offset: 2px; }
    .pill { width: 48px; height: 48px; border-radius: 50%; padding: 0; font-size: 20px; box-shadow: 0 10px 28px rgba(0,0,0,.45); }
    .panel { position: absolute; bottom: calc(100% + 10px); width: min(370px, calc(100vw - 32px)); max-height: min(74vh, 640px); display: flex; flex-direction: column; border: 1px solid rgba(196,181,253,.25); border-radius: 18px; background: rgba(14,9,24,.98); box-shadow: 0 22px 48px rgba(0,0,0,.55); overflow: hidden; }
    .root.right .panel { right: 0; } .root.left .panel { left: 0; }
    .panel[hidden] { display: none; }
    .head { display: flex; align-items: flex-start; gap: 10px; padding: 14px 14px 10px; border-bottom: 1px solid rgba(196,181,253,.14); }
    .head .meta { flex: 1; min-width: 0; }
    .title { margin: 0; font-size: 14px; font-weight: 800; color: #fff; display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden; overflow-wrap: anywhere; }
    .sub { margin-top: 3px; font-size: 11px; color: #a99bc8; }
    .body { padding: 12px 14px; overflow-y: auto; }
    h4 { margin: 0 0 8px; font-size: 11px; font-weight: 800; letter-spacing: .08em; text-transform: uppercase; color: #a99bc8; }
    .section + .section { margin-top: 14px; }
    .grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(98px, 1fr)); gap: 7px; }
    .card { position: relative; display: flex; flex-direction: column; align-items: flex-start; gap: 2px; min-height: 58px; padding: 9px 10px; border: 1px solid rgba(196,181,253,.22); border-radius: 12px; background: rgba(46,26,77,.5); color: #fff; font: inherit; text-align: left; cursor: pointer; transition: border-color .15s ease, background .15s ease, transform .15s ease; }
    .card:hover { border-color: #fa2abf; background: rgba(250,42,191,.12); transform: translateY(-1px); }
    .card .q { font-size: 15px; font-weight: 850; }
    .card .s { font-size: 11px; font-weight: 600; color: #a99bc8; }
    .card .badge { position: absolute; top: 7px; right: 7px; padding: 1px 5px; border-radius: 6px; background: rgba(250,42,191,.16); color: #f9a8d4; font-size: 9px; font-weight: 800; }
    .card.rec { border-color: rgba(167,139,250,.6); }
    .card.locked { border-style: dashed; background: rgba(245,158,11,.06); }
    .card.locked .s { color: #fbbf24; }
    .note { margin: 12px 0 0; font-size: 11px; color: #a99bc8; }
    .note a, .foot a { color: #c4b5fd; }
    .foot { display: flex; justify-content: space-between; align-items: center; gap: 8px; padding: 10px 14px; border-top: 1px solid rgba(196,181,253,.14); font-size: 11px; color: #a99bc8; }
    .foot .links { display: flex; gap: 12px; align-items: center; }
    .linkbtn { padding: 0; border: 0; background: none; color: #c4b5fd; font: inherit; text-decoration: underline; cursor: pointer; }
    .job { padding: 10px 0; }
    .job + .job { border-top: 1px solid rgba(196,181,253,.12); }
    .job .jt { font-size: 12.5px; font-weight: 750; color: #f4f1ff; display: -webkit-box; -webkit-line-clamp: 1; -webkit-box-orient: vertical; overflow: hidden; overflow-wrap: anywhere; }
    .job .jq { font-size: 11px; color: #a99bc8; margin: 1px 0 7px; }
    .track { position: relative; height: 7px; border-radius: 99px; background: rgba(196,181,253,.16); overflow: hidden; }
    .bar { position: relative; height: 100%; width: 0; border-radius: 99px; background: linear-gradient(90deg,#6f46ff,#fa2abf); transition: width .9s linear; overflow: hidden; }
    .bar.waiting { width: 36%; transition: none; animation: slide 1.35s cubic-bezier(.45,0,.55,1) infinite; }
    .bar.working, .bar.done { width: 100%; }
    .bar.working::after { content: ""; position: absolute; inset: 0; background-image: repeating-linear-gradient(-45deg, rgba(255,255,255,.28) 0 8px, rgba(255,255,255,0) 8px 16px); background-size: 22.6px 22.6px; animation: stripes .7s linear infinite; }
    .bar.done { background: linear-gradient(90deg,#22c55e,#4ade80); }
    .bar.error, .bar.stalled { width: 100%; background: #b45309; }
    .bar.error { background: #b91c1c; }
    .line { margin-top: 6px; font-size: 12px; color: #ddd6fe; font-variant-numeric: tabular-nums; }
    .line.error { color: #fecaca; }
    .row { display: flex; flex-wrap: wrap; gap: 8px; margin-top: 8px; }
    .row .btn { min-height: 36px; padding: 0 12px; font-size: 12.5px; }
    .error { padding: 10px 12px; border: 1px solid rgba(248,113,113,.35); border-radius: 12px; background: rgba(127,29,29,.25); color: #fecaca; font-size: 12.5px; }
    .spinner { width: 26px; height: 26px; margin: 10px auto; border: 3px solid rgba(196,181,253,.25); border-top-color: #fa2abf; border-radius: 50%; animation: spin .8s linear infinite; }
    .center { text-align: center; color: #a99bc8; font-size: 12px; }
    .setting { display: flex; flex-direction: column; gap: 6px; margin-bottom: 14px; font-size: 12.5px; }
    .setting select { min-height: 38px; padding: 0 10px; border: 1px solid rgba(196,181,253,.3); border-radius: 10px; background: #1d1330; color: #fff; font: inherit; }
    .setting.check { flex-direction: row; align-items: center; gap: 10px; }
    .setting small { color: #a99bc8; font-size: 11px; }
    .setting.supporter { margin-top: 14px; padding-top: 14px; border-top: 1px solid rgba(196,181,253,.15); }
    .keyform { display: flex; gap: 8px; }
    .keyform input { flex: 1; min-width: 0; min-height: 38px; padding: 0 10px; border: 1px solid rgba(196,181,253,.3); border-radius: 10px; background: #1d1330; color: #fff; font: inherit; }
    .keyform .btn { min-height: 38px; }
    .error-text { color: #fecaca; }
    .rate { margin-top: 10px; padding: 9px 11px; border-radius: 12px; background: rgba(167,139,250,.12); font-size: 12px; color: #ddd6fe; }
    .rate a { color: #f9a8d4; font-weight: 800; }
    .sponsor-slot[hidden] { display: none; }
    .bulk { padding: 10px 12px; border: 1px solid rgba(196,181,253,.22); border-radius: 12px; background: rgba(46,26,77,.35); }
    .bulk + .bulk, .bulk + h4 { margin-top: 14px; }
    .bulk h4 { margin-bottom: 6px; }
    .bulk .job { padding: 8px 0 2px; }
    .bulk details { margin-top: 8px; font-size: 12px; color: #ddd6fe; }
    .bulk summary { cursor: pointer; }
    .count { margin: 10px 0 0; font-size: 13px; color: #fff; }
    .btn[disabled] { opacity: .45; cursor: not-allowed; filter: none; transform: none; }
    @keyframes slide { 0% { transform: translateX(-105%); } 100% { transform: translateX(285%); } }
    @keyframes stripes { to { background-position: 22.6px 0; } }
    @keyframes spin { to { transform: rotate(360deg); } }
    @media (max-width: 380px) { .brand small { max-width: 80px; } .btn { padding: 0 11px; } }
    @media (prefers-reduced-motion: reduce) { *, *::before, *::after { animation: none !important; transition: none !important; } .bar.waiting { width: 100%; opacity: .45; } }
  `;

  const THUMB_STYLE = `
    :host { all: initial; }
    button { display: inline-flex; align-items: center; gap: 5px; height: 30px; padding: 0 10px; border: 0; border-radius: 999px; background: linear-gradient(135deg,#6f46ff,#fa2abf); color: #fff; font: 800 12px/1 system-ui,-apple-system,"Segoe UI",sans-serif; box-shadow: 0 6px 18px rgba(0,0,0,.45); cursor: pointer; }
    button:hover { filter: brightness(1.12); }
    button:focus-visible { outline: 3px solid #fbbf24; outline-offset: 2px; }
  `;

  function el(tag, attrs, children) {
    const node = document.createElement(tag);
    for (const [key, value] of Object.entries(attrs || {})) {
      if (value === undefined || value === null || value === false) continue;
      if (key === "class") node.className = value;
      else if (key === "text") node.textContent = value;
      else if (key.startsWith("on") && typeof value === "function") node.addEventListener(key.slice(2), value);
      else node.setAttribute(key, value === true ? "" : String(value));
    }
    for (const child of [].concat(children || [])) if (child) node.append(child);
    return node;
  }

  function externalLink(href, text, className) {
    const a = el("a", {class: className, href, target: "_blank", rel: "noopener noreferrer", text});
    a.referrerPolicy = "no-referrer";
    return a;
  }

  function deviceClass() {
    return window.matchMedia && window.matchMedia("(max-width: 768px)").matches ? "mobile" : "desktop";
  }

  // Following a file link starts as a navigation, so the browser asks
  // "beforeunload" first; the leave warning below must not stop our own
  // hand-over.
  let handOverAt = 0;
  function noteHandOver() {
    handOverAt = Date.now();
  }

  // The file response is "Content-Disposition: attachment", so following the
  // link saves the file and leaves this page in place.
  function saveFile(fileUrl) {
    noteHandOver();
    const anchor = el("a", {href: fileUrl, rel: "noopener noreferrer"});
    anchor.referrerPolicy = "no-referrer";
    anchor.style.display = "none";
    document.documentElement.append(anchor);
    anchor.click();
    anchor.remove();
  }

  const host = el("div", {id: WIDGET_ID, "data-site": site.id});
  for (const [prop, value] of [["position", "fixed"], ["bottom", "16px"], ["display", "block"], ["z-index", "2147483647"]]) {
    host.style.setProperty(prop, value, "important");
  }
  host.style.setProperty(settings.position === "left" ? "left" : "right", "16px", "important");
  const shadow = host.attachShadow({mode: "open"});
  const root = el("div", {class: "root " + settings.position});
  shadow.append(el("style", {text: STYLE}), root);
  const panel = el("section", {class: "panel", hidden: true, role: "dialog", "aria-label": "NSFWDL downloader"});
  const dock = el("div", {class: "dock", role: "group", "aria-label": "NSFWDL download button"});
  root.append(panel, dock);

  const state = {
    open: false,
    collapsed: readValue("collapsed", false) === true,
    view: "pick",          // "pick" | "settings"
    pageUrl: "",           // the video page this button is for
    target: null,          // {url, info, choices, error, loading, token}
    jobs: [],
    token: 0,
    primaryButton: null,
    supporterMessage: "",  // last Supporter key result, shown in Settings
    dailyLeft: null,       // Free downloads left today, once NSFWDL says few are left
    listing: false,        // this page lists enough videos for "Select videos"
    bulk: {
      selecting: false,    // thumbnails are being picked
      picked: new Set(),   // picked video URLs
      links: [],           // [{key, url, media, title, skip}] on the page now
      config: null,        // bulkLimits() from NSFWDL
      configAt: 0,
      loading: false,
      error: "",
      paused: false,
      pauseReason: "",     // "user" | "stalled" | "failures" | "daily"
      notice: "",
      lastStart: 0,
      holdUntil: 0,        // a busy answer holds the whole batch until then
      failStreak: 0,
      announced: false,
      preset: settings.quality === "ask" ? "best" : settings.quality,
      skipSaved: true,
    },
  };

  const FINISHED = ["saved", "handed", "failed"];
  // Phases that hold a slot (see MAX_PARALLEL); "waiting" ones don't yet.
  const RUNNING = ["starting", "queued", "preparing", "saving", "receiving"];
  // Phases whose file has not reached the browser yet. The jobs live in this
  // page: leaving it drops them, and NSFWDL keeps a prepared file nobody
  // fetches until it expires. 112 userscript files went that way in the 4
  // days to 2026-10-11, 75 of them followed within 2 minutes by a download
  // of another video (the visitor had moved on to the next page).
  const UNSAVED = ["waiting", "starting", "queued", "preparing", "saving", "stalled"];

  function hasUnsavedJobs() {
    return state.jobs.some((job) => UNSAVED.includes(job.phase));
  }

  window.addEventListener("beforeunload", (event) => {
    if (!hasUnsavedJobs() || Date.now() - handOverAt < 3000) return;
    event.preventDefault();
    event.returnValue = "";
  });

  function activeJobs() {
    return state.jobs.filter((job) => !FINISHED.includes(job.phase));
  }

  // {done, total, active} for the bulk batch, or null without one.
  function bulkCounts() {
    const jobs = state.jobs.filter((job) => job.bulk);
    if (!jobs.length) return null;
    const done = jobs.filter((job) => FINISHED.includes(job.phase)).length;
    return {done, total: jobs.length, active: done < jobs.length};
  }

  function dockLabel() {
    const counts = bulkCounts();
    if (counts && counts.active) return (state.bulk.paused ? "⏸ " : "⬇ ") + counts.done + "/" + counts.total;
    const active = activeJobs();
    if (active.length > 1) return "⬇ " + active.length + " running";
    if (active.length === 1) {
      const view = jobView(active[0]);
      return view.mode === "measured" ? Math.floor(view.fraction * 100) + "%" : "…";
    }
    const saved = state.jobs.length && state.jobs[state.jobs.length - 1].phase === "saved";
    return saved ? "✓ Saved" : "⬇ Download";
  }

  function renderDock() {
    dock.replaceChildren();
    if (state.collapsed) {
      dock.style.cssText = "padding:0;border:0;background:transparent;box-shadow:none";
      dock.append(el("button", {
        class: "btn btn-primary pill", type: "button", "aria-label": "Show the NSFWDL download button", text: "⬇",
        onclick: () => { state.collapsed = false; writeValue("collapsed", false); renderDock(); },
      }));
      return;
    }
    dock.removeAttribute("style");
    const before = state.pageUrl && wasDownloaded(state.pageUrl);
    const brand = el("div", {class: "brand"}, [el("strong", {text: "NSFWDL"}), el("small", {text: before ? "✓ Downloaded" : site.name, title: before ? "You saved this video before with NSFWDL" : null})]);
    const selectOnly = inPage && !state.pageUrl && !state.jobs.length && state.listing;
    if (selectOnly) {
      // A listing page with nothing running: the dock's only job is bulk select.
      state.primaryButton = null;
      dock.append(brand, el("button", {
        class: "btn btn-primary", type: "button", "aria-haspopup": "dialog", title: "Pick videos on this page and download them in one go",
        text: state.bulk.selecting ? "☑ " + state.bulk.picked.size + " selected" : "☑ Select videos",
        onclick: () => (state.bulk.selecting && state.open ? closePanel() : startSelecting()),
      }));
    } else if (inPage) {
      state.primaryButton = el("button", {
        class: "btn btn-primary", type: "button", "aria-expanded": String(state.open), "aria-haspopup": "dialog",
        title: "Download this " + site.name + " video (Alt+Shift+D)", text: dockLabel(),
        onclick: () => (state.open ? closePanel() : dockAction()),
      });
      dock.append(brand, state.primaryButton);
      if (state.listing) {
        dock.append(el("button", {
          class: "btn btn-ghost", type: "button", title: "Select videos on this page (bulk download)", "aria-label": "Select videos on this page",
          text: state.bulk.selecting ? "☑ " + state.bulk.picked.size : "☑",
          onclick: () => (state.bulk.selecting && state.open ? closePanel() : startSelecting()),
        }));
      }
    } else {
      dock.append(brand, externalLink(targetUrl(site, state.pageUrl || location.href), "⬇ Download", "btn btn-primary"));
    }
    dock.append(el("button", {
      class: "btn btn-icon", type: "button", title: "Minimize", "aria-label": "Minimize the NSFWDL button", text: "–",
      onclick: () => { closePanel(); state.collapsed = true; writeValue("collapsed", true); renderDock(); },
    }));
  }

  function refreshDockLabel() {
    if (state.primaryButton && state.primaryButton.isConnected) state.primaryButton.textContent = dockLabel();
  }

  function header(titleText, subText) {
    return el("div", {class: "head"}, [
      el("div", {class: "meta"}, [el("p", {class: "title", text: titleText}), subText ? el("div", {class: "sub", text: subText}) : null]),
      el("button", {class: "btn btn-icon", type: "button", "aria-label": "Close", text: "✕", onclick: closePanel}),
    ]);
  }

  function footer(url) {
    return el("div", {class: "foot"}, [
      el("span", {text: "No pop-ups. No redirects."}),
      el("span", {class: "links"}, [
        el("button", {class: "linkbtn", type: "button", text: "⚙ Settings", onclick: () => { state.view = state.view === "settings" ? (state.bulk.selecting ? "bulk" : "pick") : "settings"; state.supporterMessage = ""; render(); }}),
        externalLink(targetUrl(site, url || state.pageUrl || location.href), "Open on NSFWDL ↗"),
      ]),
    ]);
  }

  function dockAction() {
    if (FEEDS[site.id]) sync();   // the clip on screen now, not at the last tick
    if (state.pageUrl) openPanelFor(state.pageUrl, {oneClick: true});
    else openPanel();   // not a video page: show the downloads started from thumbnails
  }

  function openPanel() {
    state.open = true;
    renderDock();
    render();
  }

  function closePanel() {
    if (state.bulk.selecting) stopSelecting(true);
    state.open = false;
    panel.hidden = true;
    renderDock();
  }

  // Opens the panel for a video URL (this page or a thumbnail's video) and
  // lists its formats. With the "preferred quality" setting, a one-click
  // open starts that quality straight away.
  function openPanelFor(url, options) {
    state.view = "pick";
    const sameTarget = state.target && state.target.url === url && (state.target.choices || state.target.loading);
    if (!sameTarget) loadFormats(url, Boolean(options && options.oneClick));
    openPanel();
  }

  async function loadFormats(url, oneClick) {
    const token = ++state.token;
    state.target = {url, info: null, choices: null, error: null, loading: true};
    render();
    try {
      await checkSupporter();
      const route = await api("POST", "/api/route", {url, page_path: PAGE_PATH}, 20000);
      const payload = {url, mode: route.mode || "validated", device: deviceClass(), page_path: PAGE_PATH};
      if (route.source) payload.expected_source = route.source;
      const data = await api("POST", "/api/extract", payload, 60000);
      await siteLinkSettled();
      if (token !== state.token) return;
      const choices = normalizeFormats(data, supporterActive());
      state.target = {url, info: data, choices, error: null, loading: false};
      const preferred = oneClick ? pickPreferred(choices, settings.quality) : null;
      if (preferred) startJob(preferred);
      else render();
    } catch (error) {
      if (token !== state.token) return;
      state.target = {url, info: null, choices: null, error, loading: false};
      render();
    }
  }

  function choiceCard(choice) {
    const sub = choice.locked
      ? "🔒 Supporter"
      : [formatSize(choice), choice.fps ? choice.fps + " fps" : ""].filter(Boolean).join(" · ") || "MP4";
    const label = choice.label + " MP4" + (choice.sizeBytes ? ", " + formatSize(choice) : "") + (choice.locked ? ", needs an NSFWDL Supporter key" : "");
    return el("button", {
      class: "card" + (choice.locked ? " locked" : "") + (choice.recommended && !choice.locked ? " rec" : ""),
      type: "button", "aria-label": label,
      onclick: () => (choice.locked ? window.open(NSFWDL + "/supporter?from=userscript", "_blank", "noopener,noreferrer") : startJob(choice)),
    }, [choice.badge ? el("span", {class: "badge", text: choice.badge}) : null, el("span", {class: "q", text: choice.label}), el("span", {class: "s", text: sub})]);
  }

  function pickSection() {
    const target = state.target;
    if (!target) return [];
    if (target.loading) {
      return [el("div", {class: "section"}, [el("div", {class: "spinner", "aria-hidden": "true"}), el("p", {class: "center", text: "Finding the real formats on NSFWDL…"})])];
    }
    if (target.error) {
      const actions = el("div", {class: "row"});
      if (target.error.transient) actions.append(el("button", {class: "btn btn-primary", type: "button", text: "Try again", onclick: () => loadFormats(target.url, false)}));
      return [el("div", {class: "section"}, [el("div", {class: "error", role: "alert", text: target.error.message}), actions])];
    }
    // In a feed the clip on screen may have changed since the panel opened.
    const moved = FEEDS[site.id] && state.pageUrl && target.url !== state.pageUrl
      ? el("div", {class: "row"}, [el("button", {class: "btn btn-primary", type: "button", text: "Show the clip on screen now", onclick: () => openPanelFor(state.pageUrl)})])
      : null;
    const choices = target.choices || [];
    if (!choices.length) return [el("p", {class: "center", text: "No downloadable format was found for this video."}), moved];
    const section = el("div", {class: "section"}, [moved ? el("p", {class: "note", text: "You scrolled to another clip. These formats are for the one you opened."}) : null, moved, el("h4", {text: "Choose a quality · MP4"}), el("div", {class: "grid"}, choices.map(choiceCard))]);
    if (choices.some((c) => c.locked)) {
      section.append(el("p", {class: "note"}, [
        "🔒 " + lockReasons(choices) + " A paid ", externalLink(NSFWDL + "/supporter?from=userscript", "Supporter key"), " (from $2) unlocks them. Have a key? ",
        el("button", {class: "linkbtn", type: "button", text: "Enter it in Settings", onclick: () => { state.view = "settings"; render(); }}),
      ]));
    }
    return [section];
  }

  function jobRow(job) {
    const view = jobView(job);
    const bar = el("div", {class: "bar " + view.mode});
    if (view.mode === "measured") bar.style.width = (view.fraction * 100).toFixed(1) + "%";
    const track = el("div", {class: "track", role: "progressbar", "aria-label": "Download progress", "aria-valuemin": "0", "aria-valuemax": "100"}, [bar]);
    if (view.mode === "measured") track.setAttribute("aria-valuenow", String(Math.floor(view.fraction * 100)));
    if (view.mode === "done") track.setAttribute("aria-valuenow", "100");
    const row = el("div", {class: "job"}, [
      el("div", {class: "jt", text: job.title}),
      el("div", {class: "jq", text: [job.label, job.sizeBytes ? (job.sizeExact ? "" : "~") + formatBytes(job.sizeBytes) : ""].filter(Boolean).join(" · ")}),
      track,
      el("p", {class: "line" + (view.mode === "error" ? " error" : ""), "aria-live": "polite", text: view.text}),
    ]);
    // Reserved for a possible sponsor message while a file is prepared. It
    // stays empty and hidden: the script shows no ads and loads nothing from
    // third parties. Adding anything here would require declaring
    // "@antifeature ads" in the header first.
    if (job.phase === "queued" || job.phase === "preparing") row.append(el("div", {class: "sponsor-slot", "data-slot": "reserved", hidden: true}));
    const actions = el("div", {class: "row"});
    if (job.fileUrl && ["saving", "receiving", "stalled", "saved", "handed"].includes(job.phase)) {
      const again = el("a", {class: "btn " + (job.phase === "stalled" ? "btn-primary" : "btn-ghost"), href: job.fileUrl + "?via=tap", rel: "noopener noreferrer", text: job.phase === "stalled" ? "⬇ Save the file" : "Didn't start? Save again", onclick: noteHandOver});
      again.referrerPolicy = "no-referrer";
      actions.append(again);
    }
    if (job.phase === "failed" && job.retry) actions.append(el("button", {class: "btn btn-primary", type: "button", text: "Try again", onclick: () => (job.bulk ? retryBulk([job]) : (removeJob(job), startJob(job.choice, job.target)))}));
    if (job.phase === "failed" && job.supporter) actions.append(externalLink(NSFWDL + "/supporter?from=" + (job.supporterFrom || "userscript"), "Supporter options", "btn btn-ghost"));
    if (actions.children.length) row.append(actions);
    return row;
  }

  function jobsSection() {
    if (!state.jobs.length) return [];
    const single = state.jobs.filter((job) => !job.bulk);
    const section = el("div", {class: "section"}, [bulkSummary(), single.length ? el("h4", {text: "Your downloads"}) : null, ...single.slice().reverse().map(jobRow)]);
    if (hasUnsavedJobs()) section.append(el("p", {class: "note keep-open", text: "Stay on this page until your files start saving. You can open other videos in a new tab."}));
    if (state.dailyLeft !== null && state.dailyLeft !== undefined && !supporterActive()) {
      section.append(el("p", {class: "note"}, [
        (state.dailyLeft === 1 ? "1 free download" : state.dailyLeft + " free downloads") + " left today. A ",
        externalLink(NSFWDL + "/supporter?from=userscript", "Supporter key"), " (from $2, card or PayPal) raises it to 300 a day.",
      ]));
    }
    const saved = Number(readValue("savedCount", 0)) || 0;
    if (saved >= 3 && readValue("rateDismissed", false) !== true) {
      // Either answer ends it: following the link or "Not now".
      const dismiss = () => { writeValue("rateDismissed", true); render(); };
      const rate = externalLink(LISTING_URL + "/feedback", "Rate it ★");
      rate.addEventListener("click", dismiss);
      section.append(el("div", {class: "rate"}, [
        "Enjoying NSFWDL? A quick rating helps other people find it. ", rate, " · ",
        el("button", {class: "linkbtn", type: "button", text: "Not now", onclick: dismiss}),
      ]));
    }
    return [section];
  }

  function settingsView() {
    const quality = el("select", {"aria-label": "Preferred quality", onchange: (event) => { settings.quality = event.target.value; saveSettings(); }},
      QUALITY_CHOICES.map((value) => el("option", {value, text: QUALITY_LABELS[value], selected: settings.quality === value})));
    const position = el("select", {"aria-label": "Button position", onchange: (event) => { settings.position = event.target.value === "left" ? "left" : "right"; saveSettings(); applyPosition(); }},
      [["right", "Bottom right"], ["left", "Bottom left"]].map(([value, text]) => el("option", {value, text, selected: settings.position === value})));
    const thumbs = el("input", {type: "checkbox", checked: settings.thumbs, onchange: (event) => { settings.thumbs = event.target.checked; saveSettings(); }});
    const marks = el("input", {type: "checkbox", checked: settings.marks, onchange: (event) => { settings.marks = event.target.checked; saveSettings(); marksSeen = new WeakMap(); scheduleMarks(); renderDock(); }});
    const bulk = el("input", {type: "checkbox", checked: settings.bulk, onchange: (event) => { settings.bulk = event.target.checked; saveSettings(); listingCheckedAt = 0; lastHref = ""; sync(); }});
    const remembered = Object.keys(history).length;
    return [
      header("Settings", "Stored only in your userscript manager"),
      el("div", {class: "body"}, [
        el("label", {class: "setting"}, ["Preferred quality", quality, el("small", {text: "With a preferred quality, one click on Download starts it straight away."})]),
        el("label", {class: "setting"}, ["Button position", position]),
        el("label", {class: "setting check"}, [thumbs, "Download buttons on videos and thumbnails (desktop)"]),
        el("label", {class: "setting check"}, [marks, "Mark videos I already downloaded"]),
        el("label", {class: "setting check"}, [bulk, "\"Select videos\" button on listing pages (bulk download, desktop)"]),
        el("p", {class: "note"}, [
          remembered ? remembered + " video" + (remembered === 1 ? "" : "s") + " remembered, only in your userscript manager. " : "The list stays only in your userscript manager. ",
          remembered ? el("button", {class: "linkbtn", type: "button", text: "Clear the list", onclick: () => { clearHistory(); renderDock(); render(); }}) : null,
        ]),
        supporterSetting(),
        el("p", {class: "note", text: "Shortcut: Alt+Shift+D opens the downloader on a video page."}),
      ]),
      footer(),
    ];
  }

  // Supporter key: entered once, exchanged for a session token on nsfwdl.com.
  function supporterSetting() {
    const message = el("p", {class: "note", role: "status", "aria-live": "polite", text: state.supporterMessage || ""});
    if (supporterActive()) {
      const until = new Date(supporter.expiresAt * 1000).toLocaleString();
      return el("div", {class: "setting supporter"}, [
        el("span", {text: "Supporter key"}),
        el("small", {text: "✓ Supporter active until " + until + ". 1080p without a daily limit, qualities above 1440p and files up to about 2 GB are unlocked."}),
        el("div", {class: "row"}, [el("button", {class: "btn btn-ghost", type: "button", text: "Remove from this browser", onclick: async () => {
          await removeSupporter();
          state.supporterMessage = "Supporter session removed. A key active on nsfwdl.com isn't picked up again until you enter one here.";
          resetTargetLocks();
          render();
        }})]),
        message,
      ]);
    }
    const input = el("input", {type: "password", autocomplete: "off", spellcheck: "false", placeholder: "NSFW-DL…", "aria-label": "Supporter key", maxlength: "256"});
    const button = el("button", {class: "btn btn-primary", type: "submit", text: "Activate"});
    const form = el("form", {class: "keyform", onsubmit: async (event) => {
      event.preventDefault();
      const key = input.value.trim();
      if (key.length < 19) { message.textContent = "Paste the whole key, like NSFW-DLAB-CD12-EF34."; message.className = "note error-text"; return; }
      button.disabled = true;
      message.className = "note";
      message.textContent = "Activating…";
      try {
        await activateSupporter(key);
        state.supporterMessage = "Supporter activated. Every quality and large files are now unlocked.";
        resetTargetLocks();
      } catch (error) {
        state.supporterMessage = "";
        input.value = "";
        button.disabled = false;
        message.className = "note error-text";
        message.textContent = error.message || "That key could not be activated.";
        return;
      }
      render();
    }}, [input, button]);
    return el("div", {class: "setting supporter"}, [
      el("span", {text: "Supporter key"}),
      form,
      el("small", {}, ["Unlocks 1080p without a daily limit, qualities above 1440p and files over 500 MB. ", externalLink(NSFWDL + "/supporter?from=userscript", "Get a key"), ". The key is exchanged on nsfwdl.com for a session; only that session is kept here. A key works in up to 3 browsers or devices at once. Activated it on nsfwdl.com in this browser? Most managers let the script pick it up by itself."]),
      message,
    ]);
  }

  // Re-reads the open video's formats so the locks match the session.
  function resetTargetLocks() {
    if (state.target && state.target.info) state.target.choices = normalizeFormats(state.target.info, supporterActive());
  }

  function saveSettings() {
    writeValue("settings", {quality: settings.quality, position: settings.position, thumbs: settings.thumbs, marks: settings.marks, bulk: settings.bulk});
  }

  function applyPosition() {
    host.style.removeProperty("left");
    host.style.removeProperty("right");
    host.style.setProperty(settings.position === "left" ? "left" : "right", "16px", "important");
    root.className = "root " + settings.position;
  }

  function render() {
    refreshDockLabel();
    updateTitle();
    if (!state.open) { panel.hidden = true; return; }
    const keepScroll = panel.querySelector(".body") ? panel.querySelector(".body").scrollTop : 0;
    if (state.view === "settings") {
      panel.replaceChildren(...settingsView());
    } else if (state.view === "bulk") {
      panel.replaceChildren(...bulkView());
      const body = panel.querySelector(".body");
      if (body) body.scrollTop = keepScroll;
    } else {
      const info = (state.target && state.target.info) || {};
      const title = info.title || (state.target && state.target.url !== state.pageUrl ? "Video from this page" : !state.target && !state.pageUrl ? "Your downloads" : site.name + " video");
      const sub = [site.name, formatDuration(info.duration)].filter(Boolean).join(" · ");
      const body = el("div", {class: "body"}, [...pickSection(), ...jobsSection()]);
      panel.replaceChildren(header(title, sub), body, footer(state.target && state.target.url));
      body.scrollTop = keepScroll;
    }
    panel.hidden = false;
  }

  function removeJob(job) {
    state.jobs = state.jobs.filter((item) => item !== job);
  }

  function updateJob(job, changes) {
    const before = job.phase;
    Object.assign(job, changes);
    if (changes.phase === "saved" && !job.counted) {
      job.counted = true;
      writeValue("savedCount", (Number(readValue("savedCount", 0)) || 0) + 1);
    }
    if (changes.phase && changes.phase !== before) {
      // A batch notifies once when it pauses or ends, not for every video.
      if (changes.phase === "saved" || changes.phase === "handed") {
        rememberDownload(job.target && job.target.url);
        renderDock();
        if (!job.bulk) notify((changes.phase === "saved" ? "Saved: " : "Handed to your browser: ") + job.title);
      } else if (changes.phase === "stalled") {
        if (job.bulk) {
          // The browser held the file back (Chrome asks once per site before
          // several downloads): stop, or NSFWDL would prepare files nobody gets.
          pauseBulk("stalled", "Your browser held a file back instead of saving it. Allow multiple downloads for this site (the icon at the right of the address bar), and the batch continues.");
        } else {
          notify("Your file is ready. Come back to the tab to save it: " + job.title);
        }
      } else if (changes.phase === "failed") {
        if (!job.bulk) notify("Download failed: " + job.title);
      }
      if (job.bulk) bulkProgress(job, changes.phase);
      // A slot may have freed up.
      if (!RUNNING.includes(changes.phase)) pump();
    }
    render();
  }

  // Starts waiting jobs, oldest first, while fewer than the limit run.
  let pumpTimer = 0;
  function pump() {
    clearTimeout(pumpTimer);
    const limit = supporterActive() ? MAX_PARALLEL : FREE_PARALLEL;
    let running = state.jobs.filter((job) => RUNNING.includes(job.phase)).length;
    let runningBulk = state.jobs.filter((job) => job.bulk && RUNNING.includes(job.phase)).length;
    let nextWake = 0;
    const wakeAt = (at) => { nextWake = nextWake ? Math.min(nextWake, at) : at; };
    // Normal clicks first, then the bulk batch in what room is left.
    for (const job of state.jobs) {
      if (job.bulk || job.phase !== "waiting") continue;
      if (job.notBefore && job.notBefore > Date.now()) { wakeAt(job.notBefore); continue; }
      if (running >= limit) break;
      running += 1;
      runJob(job);
    }
    const b = state.bulk;
    const parallel = b.config ? b.config.parallel : 0;
    const gapMs = b.config ? b.config.gapMs : 2000;
    const held = b.holdUntil > Date.now();
    if (held && state.jobs.some((job) => job.bulk && job.phase === "waiting")) wakeAt(b.holdUntil);
    for (const job of state.jobs) {
      if (held || !job.bulk || job.phase !== "waiting" || b.paused) continue;
      if (job.notBefore && job.notBefore > Date.now()) { wakeAt(job.notBefore); continue; }
      const now = Date.now();
      if (!bulkMayStart({paused: b.paused, parallel, runningBulk, running, limit, now, lastStart: b.lastStart, gapMs})) {
        if (now - b.lastStart < gapMs && runningBulk < parallel && running < limit - 1) wakeAt(b.lastStart + gapMs);
        break;
      }
      running += 1;
      runningBulk += 1;
      b.lastStart = now;
      runJob(job);
    }
    let ahead = 0;
    for (const job of state.jobs) if (job.phase === "waiting" && !job.bulk) job.ahead = ahead++;
    if (nextWake) pumpTimer = setTimeout(pump, Math.max(500, nextWake - Date.now()));
  }

  const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

  function startJob(choice, forTarget) {
    const target = forTarget || state.target;
    const url = target && target.url;
    // A repeated click on the same quality of the same video.
    if (state.jobs.some((job) => job.choice.ref === choice.ref && job.target && job.target.url === url && !FINISHED.includes(job.phase))) {
      if (!state.open) { state.open = true; renderDock(); }
      render();
      return;
    }
    const title = (target && target.info && target.info.title) || site.name + " video";
    const job = {
      choice, target, title, label: choice.label, sizeBytes: choice.sizeBytes, sizeExact: choice.sizeExact,
      phase: "waiting", ahead: 0, attempts: 0, slotWaitSince: 0, notBefore: 0, bytesPrepared: 0, fileUrl: null, error: "", retry: false, supporter: false,
    };
    state.jobs.push(job);
    const single = state.jobs.filter((item) => !item.bulk);
    if (single.length > 12) {
      const keep = new Set(single.slice(-12));
      state.jobs = state.jobs.filter((item) => item.bulk || keep.has(item) || activeJobs().includes(item));
    }
    if (!state.open) { state.open = true; renderDock(); }
    pump();
    render();
  }

  // NSFWDL refused the file because this connection already reads its limit
  // of files at once: put the job back in line until a slot frees (see
  // SLOT_WAIT_MS).
  function requeue(job, seconds) {
    const now = Date.now();
    if (!job.slotWaitSince) job.slotWaitSince = now;
    if (now - job.slotWaitSince > SLOT_WAIT_MS) return false;
    job.attempts += 1;
    updateJob(job, {phase: "waiting", notBefore: now + slotRetrySeconds(job.attempts, seconds) * 1000, id: null, fileUrl: null, bytesPrepared: 0});
    return true;
  }

  // A bulk video has no format yet: list its formats like the panel does
  // and take the batch's quality preset.
  async function resolveBulkChoice(job) {
    await checkSupporter();
    const url = job.target.url;
    const route = await api("POST", "/api/route", {url, page_path: BULK_PAGE_PATH}, 20000);
    const payload = {url, mode: route.mode || "validated", device: deviceClass(), page_path: BULK_PAGE_PATH};
    if (route.source) payload.expected_source = route.source;
    const data = await api("POST", "/api/extract", payload, 60000);
    await siteLinkSettled();
    const choice = pickPreferred(normalizeFormats(data, supporterActive()), state.bulk.preset);
    if (!choice) throw Object.assign(new Error("No downloadable format was found for this video."), {transient: false});
    const title = typeof data.title === "string" && data.title.trim() ? data.title.trim().slice(0, 200) : job.title;
    Object.assign(job, {choice, choiceAt: Date.now(), title, label: choice.label, sizeBytes: choice.sizeBytes, sizeExact: choice.sizeExact});
  }

  async function runJob(job) {
    job.phase = "starting";   // holds its slot from this moment
    job.notBefore = 0;
    job.busyWait = false;
    render();
    try {
      if (job.bulk && job.choice && Date.now() - (job.choiceAt || 0) > BULK_REF_MAX_AGE_MS) job.choice = null;
      if (!job.choice) await resolveBulkChoice(job);
      const started = await api("POST", "/api/download", {format_ref: job.choice.ref, page_path: job.bulk ? BULK_PAGE_PATH : PAGE_PATH}, 30000);
      const fileUrl = safeDownloadUrl(started.download_url);
      const id = /^[A-Za-z0-9_-]{20,128}$/.test(String(started.download_id || "")) ? started.download_id : null;
      if (!fileUrl || !id) throw Object.assign(new Error("NSFWDL returned an unexpected answer. Try again."), {transient: true});
      state.dailyLeft = Number.isInteger(started.free_downloads_left_today) ? started.free_downloads_left_today : null;
      if (state.jobs.some((other) => other !== job && other.id === id && activeJobs().includes(other))) {
        removeJob(job);   // the same download is already running (a repeated click)
        pump();
        render();
        return;
      }
      updateJob(job, {id, fileUrl, phase: started.state === "ready" ? "saving" : started.state === "queued" ? "queued" : "preparing"});
      if (started.state !== "ready") await waitUntilReady(job);
      updateJob(job, {phase: "saving"});
      saveFile(fileUrl);
      await followHandoff(job);
    } catch (error) {
      if (error && error.kind === "rate_limited_active_downloads" && requeue(job, error.retryAfter)) return;
      if (job.bulk && error) {
        // The site or NSFWDL is busy: wait and try again, it is not a failure.
        if (BULK_WAIT_KINDS.includes(error.kind)) {
          job.busyWait = true;
          if (requeue(job, error.retryAfter)) {
            // The rest of the batch waits too, instead of each asking again.
            state.bulk.holdUntil = Math.max(state.bulk.holdUntil, job.notBefore);
            pump();
            return;
          }
          job.busyWait = false;
        }
        // expired_format_ref: the format list is stale. free_hd_allowance_used:
        // today's free 1080p ran out after this video's list was read, so a
        // fresh list offers the best free quality (720p or lower) instead.
        if ((error.kind === "expired_format_ref" || error.kind === "free_hd_allowance_used") && !job.refRetried) {
          job.refRetried = true;
          job.choice = null;
          if (requeue(job, 1)) return;
        }
        if (error.kind === "rate_limited_daily_downloads") pauseBulk("daily", "Today's downloads are used up, so the rest of this batch can't start today.");
      }
      updateJob(job, {
        phase: "failed",
        error: (error && error.message) || "This download failed.",
        retry: Boolean(error && error.transient),
        supporter: Boolean(error && error.supporter),
        supporterFrom: error && error.kind === "rate_limited_daily_downloads" ? "userscript-cap" : "userscript-size",
      });
      if (!state.open && !job.bulk) { state.open = true; renderDock(); render(); }
    }
  }

  async function poll(job) {
    let misses = 0;
    for (;;) {
      try {
        return await api("GET", "/api/download/" + encodeURIComponent(job.id) + "/status", null, 20000);
      } catch (error) {
        // A dropped poll is not a failed job; the server keeps working.
        if (!error.transient || ++misses >= 5) throw error;
        await sleep(1000 * misses);
      }
    }
  }

  async function waitUntilReady(job) {
    const deadline = Date.now() + PREPARE_DEADLINE_MS;
    while (Date.now() < deadline) {
      await sleep(pollDelay());
      const status = await poll(job);
      if (status.state === "ready") return;
      if (status.state === "failed") {
        throw Object.assign(new Error(failureMessage(status.error_kind)), {transient: !["file_too_large_free", "file_exceeded_free_safety_ceiling", "geo_blocked", "media_unavailable", "paid_content"].includes(status.error_kind), supporter: /^file_(too_large|exceeded)_free/.test(String(status.error_kind || ""))});
      }
      updateJob(job, {phase: status.state === "queued" ? "queued" : "preparing", bytesPrepared: Number(status.bytes_prepared) || 0});
    }
    throw Object.assign(new Error("Preparing this file took too long. Try again or open it on NSFWDL."), {transient: true});
  }

  function failureMessage(kind) {
    const messages = {
      file_too_large_free: "This file is over the 500 MB free limit. Choose a smaller quality.",
      file_exceeded_free_safety_ceiling: "This file turned out larger than the free allowance. Choose a smaller quality.",
      geo_blocked: "The site blocks this video in the country NSFWDL's server is in.",
      media_unavailable: "This video is unavailable, private, or removed.",
      upstream_download_failed: "The site couldn't deliver this file. Try again or choose another quality.",
      preparation_timeout: "Preparing this file took too long. Try another quality.",
      merge_failed: "The video and audio couldn't be combined. Try another quality.",
      media_url_expired: "The video link expired. Try again.",
    };
    return messages[kind] || "This download failed. Try again or open it on NSFWDL.";
  }

  // After the hand-over the server reports whether the browser is reading
  // the file. If nothing arrives, offer a plain link: a fresh click on it
  // works where the automatic hand-over was blocked.
  async function followHandoff(job) {
    const startedAt = Date.now();
    while (Date.now() - startedAt < HANDOFF_DEADLINE_MS) {
      await sleep(pollDelay());
      let status;
      try { status = await poll(job); } catch (_) { updateJob(job, {phase: "handed"}); return; }  // the one-time link expired
      if (status.handoff === "delivered") { updateJob(job, {phase: "saved"}); return; }
      if (status.handoff === "receiving") updateJob(job, {phase: "receiving"});
      else if (status.handoff === "stalled" || (status.handoff === "waiting" && Date.now() - startedAt > 10000)) {
        if (job.phase !== "stalled") updateJob(job, {phase: "stalled"});
      }
      if (status.state === "failed") {
        if (status.error_kind === "rate_limited_active_downloads" && requeue(job, 15)) return;
        updateJob(job, {phase: "failed", error: failureMessage(status.error_kind), retry: true});
        return;
      }
    }
    updateJob(job, {phase: "handed"});
  }

  // ── Bulk select and queue (2.7.0) ──────────────────────────────────────
  // "Select videos" marks every video thumbnail on the page; clicks pick
  // them instead of opening them. The batch then runs through the same jobs
  // as single downloads, a few at a time (NSFWDL's limits), with the site's
  // thumbnails and links read only from this page.
  const PICK_STYLE_ID = "nsfwdl-pick-style";
  let pickObserver = null;
  let pickTimer = 0;
  let listingCheckedAt = 0;

  function linkTitle(anchor) {
    const img = anchor.querySelector("img[alt]");
    const text = anchor.getAttribute("title") || (img && img.getAttribute("alt")) || anchor.textContent || "";
    return text.replace(/\s+/g, " ").trim().slice(0, 140);
  }

  // One entry per video on the page, in page order. Without media it only
  // reads links (cheap, no layout); with media it keeps the ones whose
  // thumbnail is big enough to click.
  function pageVideoLinks(withMedia) {
    const byKey = new Map();
    for (const anchor of document.querySelectorAll("a[href]")) {
      if (host.contains(anchor)) continue;
      const url = videoLinkTarget(site, anchor.getAttribute("href"), location.href);
      if (!url || url === state.pageUrl) continue;
      const key = videoKey(site, url) || url;
      let entry = byKey.get(key);
      if (!entry) { entry = {key, url, media: null, title: "", skip: false}; byKey.set(key, entry); }
      if (withMedia && !entry.media) entry.media = biggestMedia(anchor);
      if (!entry.title) entry.title = linkTitle(anchor);
    }
    const list = Array.from(byKey.values());
    return withMedia ? list.filter((entry) => entry.media) : list;
  }

  function checkListing() {
    if (Date.now() - listingCheckedAt < 3000) return state.listing;
    listingCheckedAt = Date.now();
    state.listing = Boolean(inPage && settings.bulk && canHover) && pageVideoLinks(false).length >= LISTING_MIN;
    return state.listing;
  }

  function ensurePickStyle() {
    if (document.getElementById(PICK_STYLE_ID) || !document.head) return;
    document.head.append(el("style", {id: PICK_STYLE_ID, text:
      "[data-nsfwdl-pick]{cursor:copy !important}" +
      "[data-nsfwdl-pick=\"0\"]{outline:3px dashed rgba(167,139,250,.95) !important;outline-offset:-3px !important}" +
      "[data-nsfwdl-pick=\"1\"]{outline:5px solid #fa2abf !important;outline-offset:-5px !important;filter:brightness(.7) !important}" +
      "[data-nsfwdl-pick=\"skip\"]{opacity:.4 !important;cursor:not-allowed !important}"}));
  }

  function refreshPicks() {
    const b = state.bulk;
    if (!b.selecting) return;
    ensurePickStyle();
    b.links = pageVideoLinks(true);
    const live = new Set();
    for (const entry of b.links) {
      live.add(entry.media);
      entry.skip = b.skipSaved && wasDownloaded(entry.url);
      if (entry.skip) b.picked.delete(entry.url);
      const value = entry.skip ? "skip" : b.picked.has(entry.url) ? "1" : "0";
      if (entry.media.getAttribute("data-nsfwdl-pick") !== value) entry.media.setAttribute("data-nsfwdl-pick", value);
    }
    for (const node of document.querySelectorAll("[data-nsfwdl-pick]")) if (!live.has(node)) node.removeAttribute("data-nsfwdl-pick");
  }

  function schedulePicks() {
    if (pickTimer) return;
    pickTimer = setTimeout(() => { pickTimer = 0; refreshPicks(); render(); renderDock(); }, 700);
  }

  async function startSelecting() {
    const b = state.bulk;
    hideThumb();
    b.selecting = true;
    b.error = "";
    state.view = "bulk";
    refreshPicks();
    if (!pickObserver && typeof MutationObserver === "function" && document.body) {
      // Listings load more thumbnails as you scroll.
      pickObserver = new MutationObserver(schedulePicks);
      pickObserver.observe(document.body, {childList: true, subtree: true});
    }
    openPanel();
    if (b.config && Date.now() - b.configAt < 60000) return;
    b.loading = true;
    render();
    try {
      await checkSupporter();
      await siteLinkSettled();
      b.config = bulkLimits(await api("GET", "/api/supporter/status", null, 15000));
      b.configAt = Date.now();
    } catch (error) {
      b.error = (error && error.message) || "Can't reach NSFWDL. Check your connection.";
    }
    b.loading = false;
    render();
    renderDock();
  }

  // quiet: called from closePanel, which renders the dock itself.
  function stopSelecting(quiet) {
    const b = state.bulk;
    b.selecting = false;
    b.picked.clear();
    b.links = [];
    if (pickObserver) { pickObserver.disconnect(); pickObserver = null; }
    for (const node of document.querySelectorAll("[data-nsfwdl-pick]")) node.removeAttribute("data-nsfwdl-pick");
    if (state.view === "bulk") state.view = "pick";
    if (!quiet) { render(); renderDock(); }
  }

  function togglePick(url) {
    const picked = state.bulk.picked;
    if (picked.has(url)) picked.delete(url); else picked.add(url);
    refreshPicks();
    render();
    renderDock();
  }

  // While selecting, a click on a video link picks it instead of opening it.
  document.addEventListener("click", (event) => {
    const b = state.bulk;
    if (!b.selecting) return;
    const anchor = event.target && event.target.closest ? event.target.closest("a[href]") : null;
    if (!anchor || host.contains(anchor)) return;
    const url = videoLinkTarget(site, anchor.getAttribute("href"), location.href);
    if (!url) return;
    event.preventDefault();
    event.stopPropagation();
    event.stopImmediatePropagation();
    const key = videoKey(site, url) || url;
    const entry = b.links.find((item) => item.key === key);
    if (entry && !entry.skip) togglePick(entry.url);
  }, true);

  function queuedBulkUrls() {
    return new Set(state.jobs.filter((job) => job.bulk && !FINISHED.includes(job.phase)).map((job) => job.target.url));
  }

  function startBulk(urls) {
    const b = state.bulk;
    const titles = new Map(b.links.map((entry) => [entry.url, entry.title]));
    for (const url of urls) {
      state.jobs.push({
        bulk: true, choice: null, choiceAt: 0, target: {url}, title: titles.get(url) || "Video from this page", label: "", sizeBytes: null, sizeExact: false,
        phase: "waiting", ahead: 0, attempts: 0, slotWaitSince: 0, notBefore: 0, bytesPrepared: 0, fileUrl: null, error: "", retry: false, supporter: false,
      });
    }
    if (b.config && b.config.left !== null) b.config.left = Math.max(0, b.config.left - urls.length);
    Object.assign(b, {paused: false, pauseReason: "", notice: "", failStreak: 0, announced: false});
    stopSelecting(true);
    state.view = "pick";
    state.open = true;
    renderDock();
    pump();
    render();
  }

  function pauseBulk(reason, text) {
    const b = state.bulk;
    if (b.paused && b.pauseReason === reason) return;
    Object.assign(b, {paused: true, pauseReason: reason, notice: text});
    if (reason !== "user") notify(text);
    renderDock();
    render();
  }

  function resumeBulk() {
    Object.assign(state.bulk, {paused: false, pauseReason: "", notice: "", failStreak: 0});
    pump();
    renderDock();
    render();
  }

  function cancelBulk() {
    state.jobs = state.jobs.filter((job) => !(job.bulk && job.phase === "waiting"));
    Object.assign(state.bulk, {paused: false, pauseReason: "", notice: ""});
    renderDock();
    render();
  }

  function retryBulk(jobs) {
    for (const job of jobs) {
      Object.assign(job, {phase: "waiting", choice: null, choiceAt: 0, attempts: 0, slotWaitSince: 0, notBefore: 0, bytesPrepared: 0, fileUrl: null, id: null, error: "", retry: false, supporter: false, busyWait: false, refRetried: false});
    }
    Object.assign(state.bulk, {announced: false});
    resumeBulk();
  }

  function clearFinishedBulk() {
    state.jobs = state.jobs.filter((job) => !(job.bulk && FINISHED.includes(job.phase)));
    renderDock();
    render();
  }

  function bulkProgress(job, phase) {
    const b = state.bulk;
    if (phase === "saved" || phase === "handed" || phase === "receiving") {
      b.failStreak = 0;
      // The visitor allowed the downloads: carry on by itself.
      if (b.pauseReason === "stalled" && phase !== "handed") resumeBulk();
    } else if (phase === "failed") {
      b.failStreak += 1;
      if (b.failStreak >= BULK_FAIL_STREAK && !b.paused) {
        pauseBulk("failures", BULK_FAIL_STREAK + " videos in a row failed, so the batch is paused to go easy on the site. Resume to continue, or cancel the rest.");
      }
    }
    const counts = bulkCounts();
    if (counts && !counts.active && !b.announced) {
      b.announced = true;
      const saved = state.jobs.filter((item) => item.bulk && (item.phase === "saved" || item.phase === "handed")).length;
      notify("Bulk download finished: " + saved + " of " + counts.total + " saved.");
    }
  }

  function bulkSummary() {
    const jobs = state.jobs.filter((job) => job.bulk);
    if (!jobs.length) return null;
    const b = state.bulk;
    const saved = jobs.filter((job) => job.phase === "saved" || job.phase === "handed").length;
    const failed = jobs.filter((job) => job.phase === "failed");
    const running = jobs.filter((job) => RUNNING.includes(job.phase) || job.phase === "stalled");
    const waiting = jobs.filter((job) => job.phase === "waiting").length;
    const finished = saved + failed.length;
    const bar = el("div", {class: "bar " + (finished === jobs.length ? "done" : "measured")});
    bar.style.width = ((finished / jobs.length) * 100).toFixed(1) + "%";
    const track = el("div", {class: "track", role: "progressbar", "aria-label": "Bulk download progress", "aria-valuemin": "0", "aria-valuemax": String(jobs.length), "aria-valuenow": String(finished)}, [bar]);
    const parts = [saved + " saved", running.length ? running.length + " downloading" : "", waiting ? waiting + " waiting" : "", failed.length ? failed.length + " failed" : ""].filter(Boolean).join(" · ");
    const box = el("div", {class: "bulk"}, [
      el("h4", {text: (b.paused && (waiting || running.length) ? "Bulk download · paused · " : "Bulk download · ") + finished + " of " + jobs.length}),
      track,
      el("p", {class: "line", "aria-live": "polite", text: parts}),
    ]);
    if (b.notice) box.append(el("p", {class: "note", role: "status", text: b.notice}));
    else if (!b.paused && jobs.some((job) => job.phase === "waiting" && job.busyWait)) {
      box.append(el("p", {class: "note", role: "status", text: "The site is busy on NSFWDL, so the batch slows down and goes on by itself. Single downloads go first."}));
    }
    const actions = el("div", {class: "row"});
    if (waiting || running.length) {
      actions.append(b.paused
        ? el("button", {class: "btn btn-primary", type: "button", text: "Resume", onclick: resumeBulk})
        : el("button", {class: "btn btn-ghost", type: "button", text: "Pause", onclick: () => pauseBulk("user", "Paused. Videos already downloading finish; the rest wait.")}));
    }
    if (waiting) actions.append(el("button", {class: "btn btn-ghost", type: "button", text: "Cancel the rest", onclick: cancelBulk}));
    const retryable = failed.filter((job) => job.retry);
    if (retryable.length) actions.append(el("button", {class: "btn btn-ghost", type: "button", text: "Retry failed (" + retryable.length + ")", onclick: () => retryBulk(retryable)}));
    if (!waiting && !running.length) actions.append(el("button", {class: "btn btn-ghost", type: "button", text: "Clear", onclick: clearFinishedBulk}));
    box.append(actions);
    box.append(...running.map(jobRow));
    if (failed.length) box.append(el("details", {}, [el("summary", {text: "Failed videos (" + failed.length + ")"}), ...failed.map(jobRow)]));
    return box;
  }

  function bulkView() {
    const b = state.bulk;
    const cfg = b.config;
    const body = el("div", {class: "body"});
    if (b.loading) {
      body.append(el("div", {class: "section"}, [el("div", {class: "spinner", "aria-hidden": "true"}), el("p", {class: "center", text: "Checking your limits on NSFWDL…"})]));
    } else if (b.error) {
      body.append(el("div", {class: "section"}, [el("div", {class: "error", role: "alert", text: b.error}), el("div", {class: "row"}, [el("button", {class: "btn btn-primary", type: "button", text: "Try again", onclick: () => { b.configAt = 0; b.config = null; startSelecting(); }})])]));
    } else if (!cfg || !cfg.parallel || !cfg.maxItems) {
      body.append(el("p", {class: "note", text: "Bulk download is switched off on NSFWDL right now. Single downloads work as usual."}));
    } else {
      const selectable = b.links.filter((entry) => !entry.skip);
      const skipped = b.links.length - selectable.length;
      const order = b.links.map((entry) => entry.url).filter((url) => b.picked.has(url));
      for (const url of b.picked) if (!order.includes(url)) order.push(url);
      const plan = planBatch(order, cfg, queuedBulkUrls());
      const quality = el("select", {"aria-label": "Quality for these videos", onchange: (event) => { b.preset = event.target.value; }},
        QUALITY_CHOICES.filter((value) => value !== "ask").map((value) => el("option", {value, text: QUALITY_LABELS[value], selected: b.preset === value})));
      const section = el("div", {class: "section"}, [
        el("p", {class: "note", text: "Click thumbnails on the page to add or remove them."}),
        el("div", {class: "row"}, [
          el("button", {class: "btn btn-ghost", type: "button", text: "Select all on this page (" + selectable.length + ")", disabled: !selectable.length, onclick: () => { for (const entry of selectable) b.picked.add(entry.url); refreshPicks(); render(); renderDock(); }}),
          b.picked.size ? el("button", {class: "btn btn-ghost", type: "button", text: "Clear", onclick: () => { b.picked.clear(); refreshPicks(); render(); renderDock(); }}) : null,
        ]),
      ]);
      if (settings.marks) {
        const skip = el("input", {type: "checkbox", checked: b.skipSaved, onchange: (event) => { b.skipSaved = event.target.checked; refreshPicks(); render(); }});
        section.append(el("label", {class: "setting check", style: "margin:12px 0 0"}, [skip, "Skip videos I downloaded before" + (skipped ? " (" + skipped + ")" : "")]));
      }
      section.append(el("label", {class: "setting", style: "margin:12px 0 0"}, ["Quality for these videos", quality]));
      section.append(el("p", {class: "count", text: b.picked.size + " selected" + (cfg.left !== null ? " · " + cfg.left + " downloads left today" : "")}));
      if (plan.over > 0) {
        const byDay = cfg.left !== null && cfg.left < cfg.maxItems;
        section.append(el("p", {class: "note", text: "Only the first " + plan.take.length + " go in this batch: " + (byDay ? "that's what is left of today's downloads." : "a batch holds up to " + cfg.maxItems + " videos.")}));
      }
      if (!supporterActive()) {
        section.append(el("p", {class: "note"}, [
          "Free: " + cfg.maxItems + " videos per batch, one at a time. A ",
          externalLink(NSFWDL + "/supporter?from=userscript-bulk", "Supporter key"), " (from $2) queues up to 100, 3 at a time, and 300 a day.",
        ]));
      }
      section.append(el("div", {class: "row"}, [el("button", {
        class: "btn btn-primary", type: "button", disabled: !plan.take.length,
        text: plan.take.length ? "⬇ Download " + plan.take.length + " video" + (plan.take.length === 1 ? "" : "s") : "⬇ Download",
        onclick: () => { if (plan.take.length) startBulk(plan.take); },
      })]));
      section.append(el("p", {class: "note", text: "Your browser may ask once to allow several downloads from this site: choose Allow. Keep this tab open while the batch runs."}));
      body.append(section);
    }
    return [header("Select videos", site.name + " · bulk download"), body, footer()];
  }

  // ── Buttons on thumbnails and the player (desktop, hover only) ─────────
  // One floating button, moved over whichever thumbnail the pointer is on,
  // or over the page's own player. Nothing is requested until it is clicked.
  const thumbHost = el("div", {id: THUMB_ID});
  for (const [prop, value] of [["position", "fixed"], ["display", "none"], ["z-index", "2147483646"]]) {
    thumbHost.style.setProperty(prop, value, "important");
  }
  const thumbShadow = thumbHost.attachShadow({mode: "open"});
  const thumbButton = el("button", {type: "button", text: "⬇ NSFWDL", title: "Download this video with NSFWDL"});
  thumbShadow.append(el("style", {text: THUMB_STYLE}), thumbButton);
  let thumbTarget = null;
  let thumbIsPage = false;
  let thumbHideTimer = 0;
  let playerCache = {at: 0, rect: null};

  function hideThumb() {
    thumbHost.style.setProperty("display", "none", "important");
    thumbTarget = null;
  }

  // The single-video URL of the link under the pointer, thumbnail or not.
  function linkUrlFor(node) {
    const anchor = node && node.closest ? node.closest("a[href]") : null;
    if (!anchor || host.contains(anchor)) return null;
    return videoLinkTarget(site, anchor.getAttribute("href"), location.href);
  }

  function thumbnailFor(node) {
    const anchor = node && node.closest ? node.closest("a[href]") : null;
    if (!anchor || host.contains(anchor)) return null;
    // The biggest image in the link: sites put small icons, badges or a
    // hidden lazy-loading copy next to the real thumbnail.
    let rect = null;
    for (const media of anchor.querySelectorAll("img, video, picture")) {
      const box = media.getBoundingClientRect();
      if (!rect || box.width * box.height > rect.width * rect.height) rect = box;
    }
    if (!rect || rect.width < 120 || rect.height < 68) return null;
    const url = videoLinkTarget(site, anchor.getAttribute("href"), location.href);
    if (!url || url === state.pageUrl) return null;
    return {url, rect};
  }

  // The page's own player: the biggest visible video, or a known player box
  // before the video element has loaded. Looked up at most every 800 ms.
  const PLAYER_SELECTORS = "video, #player, #xplayer, #video-player, .mgp_container, .video-player, .player-container, .xp-player";
  function playerRect() {
    if (Date.now() - playerCache.at < 800) return playerCache.rect;
    let best = null;
    for (const node of document.querySelectorAll(PLAYER_SELECTORS)) {
      if (host.contains(node)) continue;
      const box = node.getBoundingClientRect();
      if (box.width < 320 || box.height < 180 || box.bottom <= 0 || box.top >= window.innerHeight) continue;
      if (!best || box.width * box.height > best.width * best.height) best = box;
    }
    playerCache = {at: Date.now(), rect: best};
    return best;
  }

  function playerFor(event) {
    if (!state.pageUrl) return null;
    const rect = playerRect();
    if (!rect || event.clientX < rect.left || event.clientX > rect.right || event.clientY < rect.top || event.clientY > rect.bottom) return null;
    return {url: state.pageUrl, rect, page: true};
  }

  const canHover = window.matchMedia && window.matchMedia("(hover: hover) and (pointer: fine)").matches;
  if (inPage && canHover) {
    document.addEventListener("mouseover", (event) => {
      if (!settings.thumbs || state.bulk.selecting) return;
      if (event.target === thumbHost) { clearTimeout(thumbHideTimer); return; }
      const found = thumbnailFor(event.target) || playerFor(event);
      if (!found) {
        // XVideos and XNXX lay a second link to the same video over the
        // thumbnail; moving onto it must not hide the button.
        if (thumbTarget && linkUrlFor(event.target) === thumbTarget) clearTimeout(thumbHideTimer);
        return;
      }
      clearTimeout(thumbHideTimer);
      thumbTarget = found.url;
      thumbIsPage = Boolean(found.page);
      const again = wasDownloaded(found.url);
      thumbButton.textContent = found.page ? (again ? "✓ Again" : "⬇ Download") + " · NSFWDL" : again ? "✓ Again · NSFWDL" : "⬇ NSFWDL";
      thumbHost.style.setProperty("top", Math.max(4, found.rect.top + 8) + "px", "important");
      thumbHost.style.setProperty("left", Math.max(4, found.rect.left + 8) + "px", "important");
      thumbHost.style.setProperty("display", "block", "important");
      if (!thumbHost.isConnected) document.body.appendChild(thumbHost);
    }, true);
    document.addEventListener("mouseout", (event) => {
      if (!thumbTarget) return;
      const to = event.relatedTarget;
      if (to === thumbHost || (to && linkUrlFor(to) === thumbTarget)) return;
      clearTimeout(thumbHideTimer);
      thumbHideTimer = setTimeout(hideThumb, 250);
    }, true);
    window.addEventListener("scroll", hideThumb, {passive: true, capture: true});
    thumbButton.addEventListener("click", (event) => {
      event.preventDefault();
      event.stopPropagation();
      const url = thumbTarget;
      const isPage = thumbIsPage;
      hideThumb();
      if (!url) return;
      ensureWidget();
      if (isPage) dockAction();
      else openPanelFor(url, {oneClick: true});
    });
  }

  // ── Downloaded marks on thumbnails ─────────────────────────────────────
  // A green outline on the thumbnail of a video saved before: an attribute
  // and one style rule, so the site's layout is never changed.
  const MARK_STYLE_ID = "nsfwdl-marks-style";
  let marksTimer = 0;
  let marksObserver = null;
  let marksLastRun = 0;
  // Links already looked at (and their href then), so a busy page that
  // keeps changing its DOM costs only the new links.
  let marksSeen = new WeakMap();

  function scheduleMarks() {
    if (marksTimer) return;
    marksTimer = setTimeout(() => { marksTimer = 0; marksLastRun = Date.now(); applyMarks(); }, Math.max(400, 1500 - (Date.now() - marksLastRun)));
  }

  function biggestMedia(anchor) {
    let best = null;
    let area = 0;
    for (const media of anchor.querySelectorAll("img, video, picture")) {
      const box = media.getBoundingClientRect();
      if (box.width * box.height > area) { best = media; area = box.width * box.height; }
    }
    return area >= 120 * 68 ? best : null;
  }

  function applyMarks() {
    const enabled = settings.marks && Object.keys(history).length > 0;
    if (!enabled) {
      for (const node of document.querySelectorAll("[data-nsfwdl-saved]")) node.removeAttribute("data-nsfwdl-saved");
      return;
    }
    if (!document.getElementById(MARK_STYLE_ID) && document.head) {
      document.head.append(el("style", {id: MARK_STYLE_ID, text: "[data-nsfwdl-saved]{outline:3px solid #22c55e !important;outline-offset:-3px !important}"}));
    }
    for (const anchor of document.querySelectorAll("a[href]")) {
      const href = anchor.getAttribute("href");
      if (marksSeen.get(anchor) === href || host.contains(anchor)) continue;
      const url = videoLinkTarget(site, href, location.href);
      // Thumbnails that haven't laid out yet are looked at again later.
      if (!url || !wasDownloaded(url)) { marksSeen.set(anchor, href); continue; }
      if (!url || !wasDownloaded(url)) continue;
      const media = biggestMedia(anchor);
      if (media) marksSeen.set(anchor, href);
      if (media && !media.hasAttribute("data-nsfwdl-saved")) {
        media.setAttribute("data-nsfwdl-saved", "");
        if (!media.getAttribute("title")) media.setAttribute("title", "Downloaded before with NSFWDL");
      }
    }
    if (!marksObserver && typeof MutationObserver === "function" && document.body) {
      // Listings load more thumbnails as you scroll, and carousels reveal
      // thumbnails that were hidden (0x0) at the first look.
      marksObserver = new MutationObserver(scheduleMarks);
      marksObserver.observe(document.body, {childList: true, subtree: true});
      window.addEventListener("scroll", scheduleMarks, {passive: true});
    }
  }

  // ── Keyboard shortcut and menu ─────────────────────────────────────────
  document.addEventListener("keydown", (event) => {
    if (event.altKey && event.shiftKey && !event.ctrlKey && !event.metaKey && (event.key === "D" || event.key === "d" || event.code === "KeyD")) {
      if (!host.isConnected || !inPage) return;
      event.preventDefault();
      if (state.collapsed) { state.collapsed = false; writeValue("collapsed", false); renderDock(); }
      if (state.open) closePanel(); else dockAction();
    }
  }, true);
  shadow.addEventListener("keydown", (event) => { if (event.key === "Escape" && state.open) closePanel(); });

  try {
    if (typeof GM_registerMenuCommand === "function") {
      GM_registerMenuCommand("NSFWDL settings", () => {
        ensureWidget();
        state.collapsed = false;
        writeValue("collapsed", false);
        state.view = "settings";
        openPanel();
      });
    }
  } catch (_) { /* optional */ }

  // ── Page tracking ──────────────────────────────────────────────────────
  // The dock shows on single-video pages and while a RedGifs feed has a
  // video on screen, and also elsewhere while it has
  // downloads to show (a thumbnail started one, or the site changed pages
  // without reloading).
  function ensureWidget() {
    if (!host.isConnected && document.body) document.body.appendChild(host);
  }

  let lastHref = "";
  let lastVideo = null;
  let lastListing = false;
  function sync() {
    const video = currentVideoUrl(site, location.href, document);
    const listing = checkListing();
    if (location.href === lastHref && video === lastVideo && listing === lastListing) return;
    // The site moved to another page without reloading: the picks were for the old one.
    if (lastHref && location.href !== lastHref && state.bulk.selecting) stopSelecting(true);
    lastHref = location.href;
    lastVideo = video;
    lastListing = listing;
    const onVideo = Boolean(video);
    state.pageUrl = video;
    if (onVideo || listing || state.jobs.length || state.open) {
      ensureWidget();
      renderDock();
      if (state.open && state.view === "pick" && onVideo && state.target && state.target.url !== state.pageUrl && !state.target.loading) render();
    } else if (host.isConnected) {
      closePanel();
      host.remove();
    }
  }
  renderDock();
  sync();
  // The SPA sync runs slower while the tab is hidden and catches up as soon
  // as it is visible again. try/finally: one throwing sync() must never stop
  // the chain.
  let syncTimer = 0;
  function scheduleSync() {
    clearTimeout(syncTimer);
    syncTimer = setTimeout(() => { try { sync(); } finally { scheduleSync(); } }, syncDelay());
  }
  scheduleSync();
  document.addEventListener("visibilitychange", () => { if (!document.hidden) { try { sync(); } finally { scheduleSync(); } } });
  // Back from nsfwdl.com (say, after buying a key there): unlock an open
  // panel without a reload when the site now has a key for this browser.
  document.addEventListener("visibilitychange", () => {
    if (document.hidden || supporterToken()) return;
    siteLinkAt = 0;
    if (!state.open) return;
    linkFromSite().then((linked) => {
      if (!linked) return;
      resetTargetLocks();
      if (state.bulk.config) state.bulk.configAt = 0;
      render();
    });
  });
  scheduleMarks();
})();