New source [AnimeonlineNinja] (#614)

src/es/animeonlineninja/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="eu.kanade.tachiyomi.animeextension" />

src/es/animeonlineninja/build.gradle

@@ -0,0 +1,12 @@
+apply plugin: 'com.android.application'
+apply plugin: 'kotlin-android'
+
+ext {
+    extName = 'AnimeonlineNinja'
+    pkgNameSuffix = 'es.animeonlineninja'
+    extClass = '.AnimeonlineNinja'
+    extVersionCode = 1
+    libVersion = '12'
+}
+
+apply from: "$rootDir/common.gradle"

src/es/animeonlineninja/src/eu/kanade/tachiyomi/animeextension/es/animeonlineninja/AnimeonlineNinja.kt

@@ -0,0 +1,257 @@
+package eu.kanade.tachiyomi.animeextension.es.animeonlineninja
+
+import android.app.Application
+import android.content.SharedPreferences
+import androidx.preference.ListPreference
+import androidx.preference.PreferenceScreen
+import eu.kanade.tachiyomi.animeextension.es.animeonlineninja.extractors.DoodExtractor
+import eu.kanade.tachiyomi.animeextension.es.animeonlineninja.extractors.FembedExtractor
+import eu.kanade.tachiyomi.animeextension.es.animeonlineninja.extractors.JsUnpacker
+import eu.kanade.tachiyomi.animeextension.es.animeonlineninja.extractors.StreamSBExtractor
+import eu.kanade.tachiyomi.animeextension.es.animeonlineninja.extractors.StreamTapeExtractor
+import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.animesource.model.SEpisode
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.animesource.online.ParsedAnimeHttpSource
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.asJsoup
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import org.jsoup.nodes.Document
+import org.jsoup.nodes.Element
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import java.lang.Exception
+
+class AnimeonlineNinja : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
+
+    override val name = "AnimeOnline.Ninja"
+
+    override val baseUrl = "https://www1.animeonline.ninja"
+
+    override val lang = "es"
+
+    override val supportsLatest = true
+
+    override val client: OkHttpClient = network.cloudflareClient
+
+    private val preferences: SharedPreferences by lazy {
+        Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
+    }
+
+    override fun popularAnimeSelector(): String = "div.content.right div.items article"
+
+    override fun popularAnimeRequest(page: Int): Request = GET("https://www1.animeonline.ninja/tendencias/page/$page/")
+
+    override fun popularAnimeFromElement(element: Element): SAnime {
+        val anime = SAnime.create()
+        anime.setUrlWithoutDomain(element.select("div.data h3 a").attr("href"))
+        anime.title = element.select("div.data h3 a").text()
+        anime.thumbnail_url = element.select("div.poster img").attr("data-src").replace("-185x278", "")
+        return anime
+    }
+
+    override fun popularAnimeNextPageSelector(): String = "a.arrow_pag i#nextpagination"
+
+    override fun episodeListParse(response: Response): List<SEpisode> {
+        val episodes = mutableListOf<SEpisode>()
+        val url = response.request.url.toString()
+        if (url.contains("/pelicula/")) {
+            val episode = SEpisode.create().apply {
+                episode_number = 1.0F
+                name = "Pelicula"
+                setUrlWithoutDomain(url)
+            }
+            return listOf(episode)
+        }
+        val document = response.asJsoup()
+        document.select("div#serie_contenido div#seasons div.se-c div.se-a ul.episodios li").forEach {
+            val epTemp = it.select("div.numerando").text().substringBefore("-").replace(" ", "")
+            val epNum = it.select("div.numerando").text().substringAfter("-").replace(" ", "")
+            val epName = it.select("div.episodiotitle a").text()
+            if (epTemp.isNotBlank() && epNum.isNotBlank()) {
+                val episode = SEpisode.create().apply {
+                    episode_number = "$epTemp.$epNum".toFloat()
+                    name = "T$epTemp $epName"
+                }
+                episode.setUrlWithoutDomain(it.select("div.episodiotitle a").attr("href"))
+                episodes.add(episode)
+            }
+        }
+
+        return episodes
+    }
+
+    override fun episodeListSelector() = throw Exception("not used")
+
+    override fun episodeFromElement(element: Element) = throw Exception("not used")
+
+    override fun videoListParse(response: Response): List<Video> {
+        val document = response.asJsoup()
+        val videoList = mutableListOf<Video>()
+        if (multiserverCheck(document)) {
+            val datapost = document.selectFirst("#playeroptionsul li").attr("data-post")
+            val datatype = document.selectFirst("#playeroptionsul li").attr("data-type")
+            val apiCall = client.newCall(GET("https://www1.animeonline.ninja/wp-json/dooplayer/v1/post/$datapost?type=$datatype&source=1")).execute().asJsoup().body()
+            val iframeLink = apiCall.toString().substringAfter("{\"embed_url\":\"").substringBefore("\"")
+            val sDocument = client.newCall(GET(iframeLink)).execute().asJsoup()
+            sDocument.select("div.ODDIV div").forEach {
+                val lang = it.attr("class").toString().substringAfter("OD OD_").replace("REactiv", "")
+                it.select("li").forEach { source ->
+                    val sourceUrl = source.attr("onclick").toString().substringAfter("go_to_player('").substringBefore("')")
+                    serverslangParse(sourceUrl, lang).map { video -> videoList.add(video) }
+                }
+            }
+        } else {
+            val datapost = document.selectFirst("#playeroptionsul li").attr("data-post")
+            val datatype = document.selectFirst("#playeroptionsul li").attr("data-type")
+            document.select("#playeroptionsul li").forEach {
+                val sourceId = it.attr("data-nume")
+                val apiCall = client.newCall(GET("https://www1.animeonline.ninja/wp-json/dooplayer/v1/post/$datapost?type=$datatype&source=$sourceId")).execute().asJsoup().body()
+                val sourceUrl = apiCall.toString().substringAfter("{\"embed_url\":\"").substringBefore("\"").replace("\\/", "/")
+
+                val lang2 = preferences.getString("preferred_lang", "SUB").toString()
+                serverslangParse(sourceUrl, lang2).map { video -> videoList.add(video) }
+            }
+        }
+
+        return videoList
+    }
+
+    private fun multiserverCheck(document: Document): Boolean {
+        document.select("#playeroptionsul li").forEach {
+            val title = it.select("span.title").text()
+            val url = it.select("span.server").toString()
+            if (title.lowercase() == "multiserver" || url.contains("saidochesto.top")) {
+                return true
+            }
+        }
+        return false
+    }
+
+    private fun serverslangParse(serverUrl: String, lang: String): List<Video> {
+        val videos = mutableListOf<Video>()
+        val langSelect = preferences.getString("preferred_lang", "SUB").toString()
+        when {
+            serverUrl.contains("fembed") && lang.contains(langSelect) -> {
+                videos.addAll(FembedExtractor().videosFromUrl(serverUrl, lang))
+            }
+            serverUrl.contains("streamtape") && lang.contains(langSelect) -> {
+                StreamTapeExtractor(client).videoFromUrl(serverUrl, "$lang StreamTape")?.let { it1 -> videos.add(it1) }
+            }
+            serverUrl.contains("dood") && lang.contains(langSelect) -> {
+                DoodExtractor(client).videoFromUrl(serverUrl, "$lang DoodStream")?.let { it1 -> videos.add(it1) }
+            }
+            serverUrl.contains("sb") && lang.contains(langSelect) -> {
+                videos.addAll(StreamSBExtractor(client).videosFromUrl(serverUrl, headers, lang))
+            }
+            serverUrl.contains("mixdrop") && lang.contains(langSelect) -> {
+                val jsE = client.newCall(GET(serverUrl)).execute().asJsoup().selectFirst("script:containsData(eval)").data()
+                val url = "http:" + JsUnpacker(jsE).unpack().toString().substringAfter("MDCore.wurl=\"").substringBefore("\"")
+                videos.add(Video(url, "$lang MixDrop", url, null))
+            }
+            serverUrl.contains("wolfstream") && lang.contains(langSelect) -> {
+                val jsE = client.newCall(GET(serverUrl)).execute().asJsoup().selectFirst("script:containsData(sources)").data()
+                val url = jsE.substringAfter("{file:\"").substringBefore("\"")
+                videos.add(Video(url, "$lang WolfStream", url, null))
+            }
+        }
+
+        return videos
+    }
+
+    override fun videoListSelector() = throw Exception("not used")
+
+    override fun videoUrlParse(document: Document) = throw Exception("not used")
+
+    override fun videoFromElement(element: Element) = throw Exception("not used")
+
+    override fun List<Video>.sort(): List<Video> {
+        val quality = preferences.getString("preferred_quality", "Amazon")
+        if (quality != null) {
+            val newList = mutableListOf<Video>()
+            var preferred = 0
+            for (video in this) {
+                if (video.quality == quality) {
+                    newList.add(preferred, video)
+                    preferred++
+                } else {
+                    newList.add(video)
+                }
+            }
+            return newList
+        }
+        return this
+    }
+
+    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
+        return GET("https://www1.animeonline.ninja/?s=$query")
+    }
+    override fun searchAnimeFromElement(element: Element): SAnime {
+        val anime = SAnime.create()
+        anime.setUrlWithoutDomain(element.select("article div.details div.title a").attr("href"))
+        anime.title = element.select("article div.details div.title a").text()
+        anime.thumbnail_url = element.select("article div.image div.thumbnail.animation-2 a img").attr("data-src").replace("-150x150", "")
+        return anime
+    }
+
+    override fun searchAnimeNextPageSelector(): String = popularAnimeNextPageSelector()
+
+    override fun searchAnimeSelector(): String = "div.search-page div.result-item"
+
+    override fun animeDetailsParse(document: Document): SAnime {
+        val anime = SAnime.create()
+        anime.title = document.select("div.sheader div.data h1").text()
+        anime.genre = document.select("div.sheader div.data div.sgeneros a").joinToString { it.text() }
+        anime.description = document.selectFirst("div#info.sbox.fixidtab div.wp-content p").text()
+        anime.author = document.select("div.sheader div.data div.extra span a").text()
+        return anime
+    }
+
+    override fun latestUpdatesNextPageSelector() = popularAnimeNextPageSelector()
+
+    override fun latestUpdatesFromElement(element: Element) = popularAnimeFromElement(element)
+
+    override fun latestUpdatesRequest(page: Int) = GET("https://www1.animeonline.ninja/genero/en-emision/page/$page")
+
+    override fun latestUpdatesSelector() = popularAnimeSelector()
+
+    override fun setupPreferenceScreen(screen: PreferenceScreen) {
+        val videoQualityPref = ListPreference(screen.context).apply {
+            key = "preferred_quality"
+            title = "Preferred quality"
+            entries = arrayOf("SUB Fembed:480p", "SUB Fembed:720p", "SUB Fembed:1080p")
+            entryValues = arrayOf("SUB Fembed:480p", "SUB Fembed:720p", "SUB Fembed:1080p")
+            setDefaultValue("SUB Fembed:720p")
+            summary = "%s"
+
+            setOnPreferenceChangeListener { _, newValue ->
+                val selected = newValue as String
+                val index = findIndexOfValue(selected)
+                val entry = entryValues[index] as String
+                preferences.edit().putString(key, entry).commit()
+            }
+        }
+        val langPref = ListPreference(screen.context).apply {
+            key = "preferred_lang"
+            title = "Preferred language"
+            entries = arrayOf("SUB", "All", "ES", "LAT")
+            entryValues = arrayOf("SUB", "", "ES", "LAT")
+            setDefaultValue("SUB")
+            summary = "%s"
+
+            setOnPreferenceChangeListener { _, newValue ->
+                val selected = newValue as String
+                val index = findIndexOfValue(selected)
+                val entry = entryValues[index] as String
+                preferences.edit().putString(key, entry).commit()
+            }
+        }
+
+        screen.addPreference(videoQualityPref)
+        screen.addPreference(langPref)
+    }
+}

src/es/animeonlineninja/src/eu/kanade/tachiyomi/animeextension/es/animeonlineninja/extractors/DoodExtractor.kt

@@ -0,0 +1,40 @@
+package eu.kanade.tachiyomi.animeextension.es.animeonlineninja.extractors
+
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.network.GET
+import okhttp3.Headers
+import okhttp3.OkHttpClient
+
+class DoodExtractor(private val client: OkHttpClient) {
+    fun videoFromUrl(url: String, quality: String): Video? {
+        val response = client.newCall(GET(url)).execute()
+        val doodTld = url.substringAfter("https://dood.").substringBefore("/")
+        val content = response.body!!.string()
+        if (!content.contains("'/pass_md5/")) return null
+        val md5 = content.substringAfter("'/pass_md5/").substringBefore("',")
+        val token = md5.substringAfterLast("/")
+        val randomString = getRandomString()
+        val expiry = System.currentTimeMillis()
+        val videoUrlStart = client.newCall(
+            GET(
+                "https://dood.$doodTld/pass_md5/$md5",
+                Headers.headersOf("referer", url)
+            )
+        ).execute().body!!.string()
+        val videoUrl = "$videoUrlStart$randomString?token=$token&expiry=$expiry"
+
+        return Video(url, quality, videoUrl, null, doodHeaders(doodTld))
+    }
+
+    private fun getRandomString(length: Int = 10): String {
+        val allowedChars = ('A'..'Z') + ('a'..'z') + ('0'..'9')
+        return (1..length)
+            .map { allowedChars.random() }
+            .joinToString("")
+    }
+
+    private fun doodHeaders(tld: String) = Headers.Builder().apply {
+        add("User-Agent", "Aniyomi")
+        add("Referer", "https://dood.$tld/")
+    }.build()
+}

src/es/animeonlineninja/src/eu/kanade/tachiyomi/animeextension/es/animeonlineninja/extractors/FembedExtractor.kt

@@ -0,0 +1,30 @@
+package eu.kanade.tachiyomi.animeextension.es.animeonlineninja.extractors
+
+import eu.kanade.tachiyomi.animesource.model.Video
+import org.json.JSONObject
+import org.jsoup.Connection
+import org.jsoup.Jsoup
+
+class FembedExtractor {
+    fun videosFromUrl(url: String, lang: String): List<Video> {
+        val videoApi = url.replace("/v/", "/api/source/")
+        val json = JSONObject(Jsoup.connect(videoApi).ignoreContentType(true).method(Connection.Method.POST).execute().body())
+        val videoList = mutableListOf<Video>()
+        if (json.getBoolean("success")) {
+            val videoList = mutableListOf<Video>()
+            val jsonArray = json.getJSONArray("data")
+            for (i in 0 until jsonArray.length()) {
+                val `object` = jsonArray.getJSONObject(i)
+                val videoUrl = `object`.getString("file")
+                val quality = "$lang Fembed:" + `object`.getString("label")
+                videoList.add(Video(videoUrl, quality, videoUrl, null))
+            }
+            return videoList
+        } else {
+            val videoUrl = "not used"
+            val quality = "Video taken down for dmca"
+            videoList.add(Video(videoUrl, quality, videoUrl, null))
+        }
+        return videoList
+    }
+}

src/es/animeonlineninja/src/eu/kanade/tachiyomi/animeextension/es/animeonlineninja/extractors/JsUnpacker.kt

@@ -0,0 +1,214 @@
+package eu.kanade.tachiyomi.animeextension.es.animeonlineninja.extractors
+
+import java.util.regex.Pattern
+import kotlin.math.pow
+
+// https://github.com/cylonu87/JsUnpacker
+class JsUnpacker(packedJS: String?) {
+    private var packedJS: String? = null
+
+    /**
+     * Detects whether the javascript is P.A.C.K.E.R. coded.
+     *
+     * @return true if it's P.A.C.K.E.R. coded.
+     */
+    fun detect(): Boolean {
+        val js = packedJS!!.replace(" ", "")
+        val p = Pattern.compile("eval\\(function\\(p,a,c,k,e,[rd]")
+        val m = p.matcher(js)
+        return m.find()
+    }
+
+    /**
+     * Unpack the javascript
+     *
+     * @return the javascript unpacked or null.
+     */
+    fun unpack(): String? {
+        val js = packedJS
+        try {
+            var p =
+                Pattern.compile("""\}\s*\('(.*)',\s*(.*?),\s*(\d+),\s*'(.*?)'\.split\('\|'\)""", Pattern.DOTALL)
+            var m = p.matcher(js)
+            if (m.find() && m.groupCount() == 4) {
+                val payload = m.group(1).replace("\\'", "'")
+                val radixStr = m.group(2)
+                val countStr = m.group(3)
+                val symtab = m.group(4).split("\\|".toRegex()).toTypedArray()
+                var radix = 36
+                var count = 0
+                try {
+                    radix = radixStr.toInt()
+                } catch (e: Exception) {
+                }
+                try {
+                    count = countStr.toInt()
+                } catch (e: Exception) {
+                }
+                if (symtab.size != count) {
+                    throw Exception("Unknown p.a.c.k.e.r. encoding")
+                }
+                val unbase = Unbase(radix)
+                p = Pattern.compile("\\b\\w+\\b")
+                m = p.matcher(payload)
+                val decoded = StringBuilder(payload)
+                var replaceOffset = 0
+                while (m.find()) {
+                    val word = m.group(0)
+                    val x = unbase.unbase(word)
+                    var value: String? = null
+                    if (x < symtab.size && x >= 0) {
+                        value = symtab[x]
+                    }
+                    if (value != null && value.isNotEmpty()) {
+                        decoded.replace(m.start() + replaceOffset, m.end() + replaceOffset, value)
+                        replaceOffset += value.length - word.length
+                    }
+                }
+                return decoded.toString()
+            }
+        } catch (e: Exception) {
+        }
+        return null
+    }
+
+    private inner class Unbase(private val radix: Int) {
+        private val ALPHABET_62 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+        private val ALPHABET_95 =
+            " !\"#$%&\\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
+        private var alphabet: String? = null
+        private var dictionary: HashMap<String, Int>? = null
+        fun unbase(str: String): Int {
+            var ret = 0
+            if (alphabet == null) {
+                ret = str.toInt(radix)
+            } else {
+                val tmp = StringBuilder(str).reverse().toString()
+                for (i in tmp.indices) {
+                    ret += (radix.toDouble().pow(i.toDouble()) * dictionary!![tmp.substring(i, i + 1)]!!).toInt()
+                }
+            }
+            return ret
+        }
+
+        init {
+            if (radix > 36) {
+                when {
+                    radix < 62 -> {
+                        alphabet = ALPHABET_62.substring(0, radix)
+                    }
+                    radix in 63..94 -> {
+                        alphabet = ALPHABET_95.substring(0, radix)
+                    }
+                    radix == 62 -> {
+                        alphabet = ALPHABET_62
+                    }
+                    radix == 95 -> {
+                        alphabet = ALPHABET_95
+                    }
+                }
+                dictionary = HashMap(95)
+                for (i in 0 until alphabet!!.length) {
+                    dictionary!![alphabet!!.substring(i, i + 1)] = i
+                }
+            }
+        }
+    }
+
+    /**
+     * @param packedJS javascript P.A.C.K.E.R. coded.
+     */
+    init {
+        this.packedJS = packedJS
+    }
+
+    companion object {
+        val c =
+            listOf(
+                0x63,
+                0x6f,
+                0x6d,
+                0x2e,
+                0x67,
+                0x6f,
+                0x6f,
+                0x67,
+                0x6c,
+                0x65,
+                0x2e,
+                0x61,
+                0x6e,
+                0x64,
+                0x72,
+                0x6f,
+                0x69,
+                0x64,
+                0x2e,
+                0x67,
+                0x6d,
+                0x73,
+                0x2e,
+                0x61,
+                0x64,
+                0x73,
+                0x2e,
+                0x4d,
+                0x6f,
+                0x62,
+                0x69,
+                0x6c,
+                0x65,
+                0x41,
+                0x64,
+                0x73
+            )
+        val z =
+            listOf(
+                0x63,
+                0x6f,
+                0x6d,
+                0x2e,
+                0x66,
+                0x61,
+                0x63,
+                0x65,
+                0x62,
+                0x6f,
+                0x6f,
+                0x6b,
+                0x2e,
+                0x61,
+                0x64,
+                0x73,
+                0x2e,
+                0x41,
+                0x64
+            )
+
+        fun String.load(): String? {
+            return try {
+                var load = this
+
+                for (q in c.indices) {
+                    if (c[q % 4] > 270) {
+                        load += c[q % 3]
+                    } else {
+                        load += c[q].toChar()
+                    }
+                }
+
+                Class.forName(load.substring(load.length - c.size, load.length)).name
+            } catch (_: Exception) {
+                try {
+                    var f = c[2].toChar().toString()
+                    for (w in z.indices) {
+                        f += z[w].toChar()
+                    }
+                    return Class.forName(f.substring(0b001, f.length)).name
+                } catch (_: Exception) {
+                    null
+                }
+            }
+        }
+    }
+}

src/es/animeonlineninja/src/eu/kanade/tachiyomi/animeextension/es/animeonlineninja/extractors/OkruExtractor.kt

@@ -0,0 +1,26 @@
+package eu.kanade.tachiyomi.animeextension.es.animeonlineninja.extractors
+
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.asJsoup
+import okhttp3.OkHttpClient
+
+class OkruExtractor(private val client: OkHttpClient) {
+    fun videosFromUrl(url: String): List<Video> {
+        val document = client.newCall(GET(url)).execute().asJsoup()
+        val videoList = mutableListOf<Video>()
+        val videosString = document.select("div[data-options]").attr("data-options")
+            .substringAfter("\\\"videos\\\":[{\\\"name\\\":\\\"")
+            .substringBefore("]")
+        videosString.split("{\\\"name\\\":\\\"").reversed().forEach {
+            val videoUrl = it.substringAfter("url\\\":\\\"")
+                .substringBefore("\\\"")
+                .replace("\\\\u0026", "&")
+            val videoQuality = "Okru: " + it.substringBefore("\\\"")
+            if (videoUrl.startsWith("https://")) {
+                videoList.add(Video(videoUrl, videoQuality, videoUrl, null))
+            }
+        }
+        return videoList
+    }
+}

src/es/animeonlineninja/src/eu/kanade/tachiyomi/animeextension/es/animeonlineninja/extractors/SolidFilesExtractor.kt

@@ -0,0 +1,23 @@
+package eu.kanade.tachiyomi.animeextension.es.animeonlineninja.extractors
+
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.asJsoup
+import okhttp3.OkHttpClient
+
+class SolidFilesExtractor(private val client: OkHttpClient) {
+    fun videosFromUrl(url: String): List<Video> {
+        val document = client.newCall(GET(url)).execute().asJsoup()
+        val videoList = mutableListOf<Video>()
+        document.select("script").forEach { script ->
+            if (script.data().contains("\"downloadUrl\":")) {
+                val data = script.data().substringAfter("\"downloadUrl\":").substringBefore(",")
+                val url = data.replace("\"", "")
+                val videoUrl = url
+                val quality = "SolidFiles"
+                videoList.add(Video(videoUrl, quality, videoUrl, null))
+            }
+        }
+        return videoList
+    }
+}

src/es/animeonlineninja/src/eu/kanade/tachiyomi/animeextension/es/animeonlineninja/extractors/StreamSBExtractor.kt

@@ -0,0 +1,48 @@
+package eu.kanade.tachiyomi.animeextension.es.animeonlineninja.extractors
+
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.network.GET
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.jsonObject
+import okhttp3.Headers
+import okhttp3.OkHttpClient
+
+class StreamSBExtractor(private val client: OkHttpClient) {
+
+    private val hexArray = "0123456789ABCDEF".toCharArray()
+
+    private fun bytesToHex(bytes: ByteArray): String {
+        val hexChars = CharArray(bytes.size * 2)
+        for (j in bytes.indices) {
+            val v = bytes[j].toInt() and 0xFF
+
+            hexChars[j * 2] = hexArray[v ushr 4]
+            hexChars[j * 2 + 1] = hexArray[v and 0x0F]
+        }
+        return String(hexChars)
+    }
+
+    fun videosFromUrl(url: String, headers: Headers, lang: String): List<Video> {
+        val id = url.substringAfter("embed-").substringBefore(".html").substringAfter("/e/")
+        val bytes = id.toByteArray()
+        val bytesToHex = bytesToHex(bytes)
+        val master =
+            "https://embedsb.com/sources43/566d337678566f743674494a7c7c${bytesToHex}7c7c346b6767586d6934774855537c7c73747265616d7362/6565417268755339773461447c7c346133383438333436313335376136323337373433383634376337633465366534393338373136643732373736343735373237613763376334363733353737303533366236333463353333363534366137633763373337343732363536313664373336327c7c6b586c3163614468645a47617c7c73747265616d7362"
+        val json = Json.decodeFromString<JsonObject>(
+            client.newCall(GET(master, headers))
+                .execute().body!!.string()
+        )
+        val masterUrl = json["stream_data"]!!.jsonObject["file"].toString().trim('"')
+        val masterPlaylist = client.newCall(GET(masterUrl, headers)).execute().body!!.string()
+        val videoList = mutableListOf<Video>()
+        masterPlaylist.substringAfter("#EXT-X-STREAM-INF:").split("#EXT-X-STREAM-INF:").forEach {
+            val quality = "$lang StreamSB:" + it.substringAfter("RESOLUTION=").substringAfter("x")
+                .substringBefore(",") + "p"
+            val videoUrl = it.substringAfter("\n").substringBefore("\n")
+            videoList.add(Video(videoUrl, quality, videoUrl, null, headers))
+        }
+        return videoList
+    }
+}

src/es/animeonlineninja/src/eu/kanade/tachiyomi/animeextension/es/animeonlineninja/extractors/StreamTapeExtractor.kt

@@ -0,0 +1,18 @@
+package eu.kanade.tachiyomi.animeextension.es.animeonlineninja.extractors
+
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.asJsoup
+import okhttp3.OkHttpClient
+
+class StreamTapeExtractor(private val client: OkHttpClient) {
+    fun videoFromUrl(url: String, quality: String): Video? {
+        val document = client.newCall(GET(url)).execute().asJsoup()
+        val script = document.select("script:containsData(document.getElementById('robotlink'))")
+            .firstOrNull()?.data()?.substringAfter("document.getElementById('robotlink').innerHTML = '")
+            ?: return null
+        val videoUrl = "https:" + script.substringBefore("'") +
+            script.substringAfter("+ ('xcd").substringBefore("'")
+        return Video(url, quality, videoUrl, null)
+    }
+}