moved providers

AnimeIndoProvider/build.gradle.kts

@@ -0,0 +1,27 @@
+// use an integer for version numbers
+version = 1
+
+
+cloudstream {
+    language = "id"
+    // All of these properties are optional, you can safely remove them
+
+    // description = "Lorem Ipsum"
+     authors = listOf("Hexated")
+
+    /**
+     * Status int as the following:
+     * 0: Down
+     * 1: Ok
+     * 2: Slow
+     * 3: Beta only
+     * */
+    status = 1 // will be 3 if unspecified
+    tvTypes = listOf(
+        "AnimeMovie",
+        "OVA",
+        "Anime",
+    )
+
+    iconUrl = "https://www.google.com/s2/favicons?domain=animeindo.sbs&sz=%size%"
+}

AnimeIndoProvider/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="com.hexated" />

AnimeIndoProvider/src/main/kotlin/com/hexated/AnimeIndoProvider.kt

@@ -0,0 +1,192 @@
+package com.hexated
+
+import com.lagradost.cloudstream3.*
+import com.lagradost.cloudstream3.APIHolder.getCaptchaToken
+import com.lagradost.cloudstream3.LoadResponse.Companion.addTrailer
+import com.lagradost.cloudstream3.utils.ExtractorLink
+import com.lagradost.cloudstream3.utils.loadExtractor
+import com.lagradost.nicehttp.NiceResponse
+import org.jsoup.Jsoup
+import org.jsoup.nodes.Element
+
+class AnimeIndoProvider : MainAPI() {
+    override var mainUrl = "https://animeindo.sbs"
+    override var name = "AnimeIndo"
+    override val hasMainPage = true
+    override var lang = "id"
+    override val hasDownloadSupport = true
+
+    override val supportedTypes = setOf(
+        TvType.Anime,
+        TvType.AnimeMovie,
+        TvType.OVA
+    )
+
+    companion object {
+        fun getType(t: String): TvType {
+            return if (t.contains("OVA") || t.contains("Special")) TvType.OVA
+            else if (t.contains("Movie")) TvType.AnimeMovie
+            else TvType.Anime
+        }
+
+        fun getStatus(t: String): ShowStatus {
+            return when (t) {
+                "Finished Airing" -> ShowStatus.Completed
+                "Currently Airing" -> ShowStatus.Ongoing
+                else -> ShowStatus.Completed
+            }
+        }
+
+        private suspend fun request(url: String): NiceResponse {
+            val req = app.get(
+                url,
+                cookies = mapOf("recaptcha_cookie" to "#Asia/Jakarta#-420#win32#Windows#0,false,false#Google Inc. (Intel)~ANGLE (Intel, Intel(R) HD Graphics 400 Direct3D11 vs_5_0 ps_5_0)")
+            )
+            if (req.isSuccessful) {
+                return req
+            } else {
+                val document = app.get(url).document
+                val captchaKey =
+                    document.select("script[src*=https://www.google.com/recaptcha/api.js?render=]")
+                        .attr("src").substringAfter("render=").substringBefore("&amp")
+                val token = getCaptchaToken(url, captchaKey)
+                return app.post(
+                    url,
+                    data = mapOf(
+                        "action" to "recaptcha_for_all",
+                        "token" to "$token",
+                        "sitekey" to captchaKey
+                    )
+                )
+            }
+        }
+    }
+
+    override val mainPage = mainPageOf(
+        "$mainUrl/anime-terbaru/page/" to "Anime Terbaru",
+        "$mainUrl/donghua-terbaru/page/" to "Donghua Terbaru"
+    )
+
+    override suspend fun getMainPage(
+        page: Int,
+        request: MainPageRequest
+    ): HomePageResponse {
+        val document = request(request.data + page).document
+        val home = document.select("div.post-show > article").mapNotNull {
+            it.toSearchResult()
+        }
+        return newHomePageResponse(request.name, home)
+    }
+
+    private fun getProperAnimeLink(uri: String): String {
+        return if (uri.contains("/anime/")) {
+            uri
+        } else {
+            var title = uri.substringAfter("$mainUrl/")
+            title = when {
+                (title.contains("-episode")) && !(title.contains("-movie")) -> Regex("(.+)-episode").find(
+                    title
+                )?.groupValues?.get(1).toString()
+                (title.contains("-movie")) -> Regex("(.+)-movie").find(title)?.groupValues?.get(
+                    1
+                ).toString()
+                else -> title
+            }
+            "$mainUrl/anime/$title"
+        }
+    }
+
+    private fun Element.toSearchResult(): AnimeSearchResponse? {
+        val title = this.selectFirst("div.title")?.text()?.trim() ?: return null
+        val href = getProperAnimeLink(this.selectFirst("a")!!.attr("href"))
+        val posterUrl = this.select("img[itemprop=image]").attr("src").toString()
+        val type = getType(this.select("div.type").text().trim())
+        val epNum =
+            this.selectFirst("span.episode")?.ownText()?.replace(Regex("[^0-9]"), "")?.trim()
+                ?.toIntOrNull()
+        return newAnimeSearchResponse(title, href, type) {
+            this.posterUrl = posterUrl
+            addSub(epNum)
+        }
+
+    }
+
+    override suspend fun search(query: String): List<SearchResponse> {
+        val link = "$mainUrl/?s=$query"
+        val document = request(link).document
+
+        return document.select(".site-main.relat > article").map {
+            val title = it.selectFirst("div.title > h2")!!.ownText().trim()
+            val href = it.selectFirst("a")!!.attr("href")
+            val posterUrl = it.selectFirst("img")!!.attr("src").toString()
+            val type = getType(it.select("div.type").text().trim())
+            newAnimeSearchResponse(title, href, type) {
+                this.posterUrl = posterUrl
+            }
+        }
+    }
+
+    override suspend fun load(url: String): LoadResponse {
+        val document = request(url).document
+
+        val title = document.selectFirst("h1.entry-title")?.text().toString().trim()
+        val poster = document.selectFirst("div.thumb > img[itemprop=image]")?.attr("src")
+        val tags = document.select("div.genxed > a").map { it.text() }
+        val type = getType(
+            document.selectFirst("div.info-content > div.spe > span:nth-child(6)")?.ownText()
+                .toString()
+        )
+        val year = Regex("\\d, ([0-9]*)").find(
+            document.select("div.info-content > div.spe > span:nth-child(9) > time").text()
+        )?.groupValues?.get(1)?.toIntOrNull()
+        val status = getStatus(
+            document.selectFirst("div.info-content > div.spe > span:nth-child(1)")!!.ownText()
+                .trim()
+        )
+        val description = document.select("div[itemprop=description] > p").text()
+        val trailer = document.selectFirst("div.player-embed iframe")?.attr("src")
+        val episodes = document.select("div.lstepsiode.listeps ul li").mapNotNull {
+            val header = it.selectFirst("span.lchx > a") ?: return@mapNotNull null
+            val name = header.text().trim()
+            val episode = header.text().trim().replace("Episode", "").trim().toIntOrNull()
+            val link = fixUrl(header.attr("href"))
+            Episode(link, name = name, episode = episode)
+        }.reversed()
+
+        return newAnimeLoadResponse(title, url, type) {
+            engName = title
+            posterUrl = poster
+            this.year = year
+            addEpisodes(DubStatus.Subbed, episodes)
+            showStatus = status
+            plot = description
+            this.tags = tags
+            addTrailer(trailer)
+        }
+    }
+
+    override suspend fun loadLinks(
+        data: String,
+        isCasting: Boolean,
+        subtitleCallback: (SubtitleFile) -> Unit,
+        callback: (ExtractorLink) -> Unit
+    ): Boolean {
+
+        val document = request(data).document
+        document.select("div.itemleft > .mirror > option").mapNotNull {
+            fixUrl(Jsoup.parse(base64Decode(it.attr("value"))).select("iframe").attr("src"))
+        }.apmap {
+            if (it.startsWith("https://uservideo.xyz")) {
+                app.get(it, referer = "$mainUrl/").document.select("iframe").attr("src")
+            } else {
+                it
+            }
+        }.apmap {
+            loadExtractor(it, data, subtitleCallback, callback)
+        }
+
+        return true
+    }
+
+
+}

AnimeIndoProvider/src/main/kotlin/com/hexated/AnimeIndoProviderPlugin.kt

@@ -0,0 +1,14 @@
+
+package com.hexated
+
+import com.lagradost.cloudstream3.plugins.CloudstreamPlugin
+import com.lagradost.cloudstream3.plugins.Plugin
+import android.content.Context
+
+@CloudstreamPlugin
+class AnimeIndoProviderPlugin: Plugin() {
+    override fun load(context: Context) {
+        // All providers should be added in this manner. Please don't edit the providers list directly.
+        registerMainAPI(AnimeIndoProvider())
+    }
+}

AnimeSailProvider/build.gradle.kts

@@ -0,0 +1,27 @@
+// use an integer for version numbers
+version = 2
+
+
+cloudstream {
+    language = "id"
+    // All of these properties are optional, you can safely remove them
+
+    // description = "Lorem Ipsum"
+     authors = listOf("Hexated")
+
+    /**
+     * Status int as the following:
+     * 0: Down
+     * 1: Ok
+     * 2: Slow
+     * 3: Beta only
+     * */
+    status = 1 // will be 3 if unspecified
+    tvTypes = listOf(
+        "AnimeMovie",
+        "Anime",
+        "OVA",
+    )
+
+    iconUrl = "https://www.google.com/s2/favicons?domain=111.90.143.42&sz=%size%"
+}

AnimeSailProvider/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="com.hexated" />

AnimeSailProvider/src/main/kotlin/com/hexated/AnimeSailProvider.kt

@@ -0,0 +1,195 @@
+package com.hexated
+
+import com.lagradost.cloudstream3.*
+import com.lagradost.cloudstream3.mvvm.safeApiCall
+import com.lagradost.cloudstream3.utils.ExtractorLink
+import com.lagradost.cloudstream3.utils.Qualities
+import com.lagradost.cloudstream3.utils.loadExtractor
+import com.lagradost.nicehttp.NiceResponse
+import org.jsoup.Jsoup
+import org.jsoup.nodes.Element
+
+class AnimeSailProvider : MainAPI() {
+    override var mainUrl = "https://111.90.143.42"
+    override var name = "AnimeSail"
+    override val hasMainPage = true
+    override var lang = "id"
+    override val hasDownloadSupport = true
+
+    override val supportedTypes = setOf(
+        TvType.Anime,
+        TvType.AnimeMovie,
+        TvType.OVA
+    )
+
+    companion object {
+        fun getType(t: String): TvType {
+            return if (t.contains("OVA") || t.contains("Special")) TvType.OVA
+            else if (t.contains("Movie")) TvType.AnimeMovie
+            else TvType.Anime
+        }
+
+        fun getStatus(t: String): ShowStatus {
+            return when (t) {
+                "Completed" -> ShowStatus.Completed
+                "Ongoing" -> ShowStatus.Ongoing
+                else -> ShowStatus.Completed
+            }
+        }
+    }
+
+    private suspend fun request(url: String, ref: String? = null): NiceResponse {
+        return app.get(
+            url,
+            headers = mapOf("Accept" to "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8"),
+            cookies = mapOf("_as_ipin_ct" to "ID"),
+            referer = ref
+        )
+    }
+
+    override val mainPage = mainPageOf(
+        "$mainUrl/page/" to "Episode Terbaru",
+        "$mainUrl/movie-terbaru/page/" to "Movie Terbaru",
+        "$mainUrl/genres/donghua/page/" to "Donghua"
+    )
+
+    override suspend fun getMainPage(page: Int, request: MainPageRequest): HomePageResponse {
+        val document = request(request.data + page).document
+        val home = document.select("article").map {
+            it.toSearchResult()
+        }
+        return newHomePageResponse(request.name, home)
+    }
+
+    private fun getProperAnimeLink(uri: String): String {
+        return if (uri.contains("/anime/")) {
+            uri
+        } else {
+            var title = uri.substringAfter("$mainUrl/")
+            title = when {
+                (title.contains("-episode")) && !(title.contains("-movie")) -> title.substringBefore(
+                    "-episode"
+                )
+                (title.contains("-movie")) -> title.substringBefore("-movie")
+                else -> title
+            }
+
+            "$mainUrl/anime/$title"
+        }
+    }
+
+    private fun Element.toSearchResult(): AnimeSearchResponse {
+        val href = getProperAnimeLink(fixUrlNull(this.selectFirst("a")?.attr("href")).toString())
+        val title = this.select(".tt > h2").text().trim()
+        val posterUrl = fixUrlNull(this.selectFirst("div.limit img")?.attr("src"))
+        val epNum = this.selectFirst(".tt > h2")?.text()?.let {
+            Regex("Episode\\s?([0-9]+)").find(it)?.groupValues?.getOrNull(1)?.toIntOrNull()
+        }
+        return newAnimeSearchResponse(title, href, TvType.Anime) {
+            this.posterUrl = posterUrl
+            addSub(epNum)
+        }
+
+    }
+
+    override suspend fun search(query: String): List<SearchResponse> {
+        val link = "$mainUrl/?s=$query"
+        val document = request(link).document
+
+        return document.select("div.listupd article").map {
+            it.toSearchResult()
+        }
+    }
+
+    override suspend fun load(url: String): LoadResponse {
+        val document = request(url).document
+
+        val title = document.selectFirst("h1.entry-title")?.text().toString().trim()
+        val type = getType(
+            document.select("tbody th:contains(Tipe)").next().text()
+        )
+        val episodes = document.select("ul.daftar > li").map {
+            val header = it.select("a").text().trim()
+            val name =
+                Regex("(Episode\\s?[0-9]+)").find(header)?.groupValues?.getOrNull(0) ?: header
+            val link = fixUrl(it.select("a").attr("href"))
+            Episode(link, name = name)
+        }.reversed()
+
+        return newAnimeLoadResponse(title, url, type) {
+            posterUrl = document.selectFirst("div.entry-content > img")?.attr("src")
+            this.year =
+                document.select("tbody th:contains(Dirilis)").next().text().trim().toIntOrNull()
+            addEpisodes(DubStatus.Subbed, episodes)
+            showStatus =
+                getStatus(document.select("tbody th:contains(Status)").next().text().trim())
+            plot = document.selectFirst("div.entry-content > p")?.text()
+            this.tags =
+                document.select("tbody th:contains(Genre)").next().select("a").map { it.text() }
+        }
+    }
+
+    override suspend fun loadLinks(
+        data: String,
+        isCasting: Boolean,
+        subtitleCallback: (SubtitleFile) -> Unit,
+        callback: (ExtractorLink) -> Unit
+    ): Boolean {
+
+        val document = request(data).document
+
+        document.select(".mobius > .mirror > option").apmap {
+            safeApiCall {
+                val iframe = fixUrl(
+                    Jsoup.parse(base64Decode(it.attr("data-em"))).select("iframe").attr("src")
+                        ?: throw ErrorLoadingException("No iframe found")
+                )
+
+                when {
+                    iframe.startsWith("$mainUrl/utils/player/arch/") || iframe.startsWith(
+                        "$mainUrl/utils/player/race/"
+                    ) -> request(iframe, ref = data).document.select("source").attr("src")
+                        .let { link ->
+                            val source =
+                                when {
+                                    iframe.contains("/arch/") -> "Arch"
+                                    iframe.contains("/race/") -> "Race"
+                                    else -> this.name
+                                }
+                            val quality =
+                                Regex("\\.([0-9]{3,4})\\.").find(link)?.groupValues?.get(1)
+                            callback.invoke(
+                                ExtractorLink(
+                                    source = source,
+                                    name = source,
+                                    url = link,
+                                    referer = mainUrl,
+                                    quality = quality?.toIntOrNull() ?: Qualities.Unknown.value
+                                )
+                            )
+                        }
+//                    skip for now
+//                    iframe.startsWith("$mainUrl/utils/player/fichan/") -> ""
+//                    iframe.startsWith("$mainUrl/utils/player/blogger/") -> ""
+                    iframe.startsWith("https://aghanim.xyz/tools/redirect/") -> {
+                        val link = "https://rasa-cintaku-semakin-berantai.xyz/v/${iframe.substringAfter("id=").substringBefore("&token")}"
+                        loadExtractor(link, mainUrl, subtitleCallback, callback)
+                    }
+                    iframe.startsWith("$mainUrl/utils/player/framezilla/") || iframe.startsWith("https://uservideo.xyz") -> {
+                        request(iframe, ref = data).document.select("iframe").attr("src")
+                            .let { link ->
+                                loadExtractor(fixUrl(link), mainUrl, subtitleCallback, callback)
+                            }
+                    }
+                    else -> {
+                        loadExtractor(iframe, mainUrl, subtitleCallback, callback)
+                    }
+                }
+            }
+        }
+
+        return true
+    }
+
+
+}

AnimeSailProvider/src/main/kotlin/com/hexated/AnimeSailProviderPlugin.kt

@@ -0,0 +1,14 @@
+
+package com.hexated
+
+import com.lagradost.cloudstream3.plugins.CloudstreamPlugin
+import com.lagradost.cloudstream3.plugins.Plugin
+import android.content.Context
+
+@CloudstreamPlugin
+class AnimeSailProviderPlugin: Plugin() {
+    override fun load(context: Context) {
+        // All providers should be added in this manner. Please don't edit the providers list directly.
+        registerMainAPI(AnimeSailProvider())
+    }
+}

Anizm/build.gradle.kts

@@ -0,0 +1,27 @@
+// use an integer for version numbers
+version = 1
+
+
+cloudstream {
+    language = "tr"
+    // All of these properties are optional, you can safely remove them
+
+    // description = "Lorem Ipsum"
+     authors = listOf("Hexated")
+
+    /**
+     * Status int as the following:
+     * 0: Down
+     * 1: Ok
+     * 2: Slow
+     * 3: Beta only
+     * */
+    status = 1 // will be 3 if unspecified
+    tvTypes = listOf(
+        "AnimeMovie",
+        "Anime",
+        "OVA",
+    )
+
+    iconUrl = "https://www.google.com/s2/favicons?domain=anizm.net&sz=%size%"
+}

Anizm/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="com.hexated" />

Anizm/src/main/kotlin/com/hexated/Anizm.kt

@@ -0,0 +1,195 @@
+package com.hexated
+
+import android.util.Log
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.lagradost.cloudstream3.*
+import com.lagradost.cloudstream3.LoadResponse.Companion.addTrailer
+import com.lagradost.cloudstream3.mvvm.safeApiCall
+import com.lagradost.cloudstream3.utils.*
+import org.jsoup.Jsoup
+import org.jsoup.nodes.Element
+
+
+class Anizm : MainAPI() {
+    override var mainUrl = "https://anizm.net"
+    override var name = "Anizm"
+    override val hasMainPage = true
+    override var lang = "tr"
+    override val hasDownloadSupport = true
+
+    override val supportedTypes = setOf(
+        TvType.Anime,
+        TvType.AnimeMovie,
+        TvType.OVA
+    )
+
+    companion object {
+        private const val mainServer = "https://anizmplayer.com"
+    }
+
+    override val mainPage = mainPageOf(
+        "$mainUrl/anime-izle?sayfa=" to "Son Eklenen Animeler",
+    )
+
+    override suspend fun getMainPage(
+        page: Int,
+        request: MainPageRequest
+    ): HomePageResponse {
+        val document = app.get(request.data + page).document
+        val home = document.select("div.restrictedWidth div#episodesMiddle").mapNotNull {
+            it.toSearchResult()
+        }
+        return newHomePageResponse(request.name, home)
+    }
+
+    private fun getProperAnimeLink(uri: String): String {
+        return if (uri.contains("-bolum")) {
+            "$mainUrl/${uri.substringAfter("$mainUrl/").replace(Regex("-[0-9]+-bolum.*"), "")}"
+        } else {
+            uri
+        }
+    }
+
+    private fun Element.toSearchResult(): AnimeSearchResponse? {
+        val href = getProperAnimeLink(this.selectFirst("a")!!.attr("href"))
+        val title = this.selectFirst("div.title, h5.animeTitle a")?.text() ?: return null
+        val posterUrl = fixUrlNull(this.selectFirst("img")?.attr("src"))
+        val episode = this.selectFirst("div.truncateText")?.text()?.let {
+            Regex("([0-9]+).\\s?Bölüm").find(it)?.groupValues?.getOrNull(1)?.toIntOrNull()
+        }
+
+        return newAnimeSearchResponse(title, href, TvType.Anime) {
+            this.posterUrl = posterUrl
+            addSub(episode)
+        }
+    }
+
+    override suspend fun search(query: String): List<SearchResponse> {
+        val document = app.get(
+            "$mainUrl/fullViewSearch?search=$query&skip=0",
+            headers = mapOf("X-Requested-With" to "XMLHttpRequest")
+        ).document
+
+        return document.select("div.searchResultItem").mapNotNull {
+            it.toSearchResult()
+        }
+    }
+
+    override suspend fun load(url: String): LoadResponse {
+        val document = app.get(url).document
+
+        val title = document.selectFirst("h2.anizm_pageTitle a")!!.text().trim()
+        val type =
+            if (document.select("div.ui.grid div.four.wide").size == 1) TvType.Movie else TvType.Anime
+        val trailer = document.select("div.yt-hd-thumbnail-inner-container iframe").attr("src")
+        val episodes = document.select("div.ui.grid div.four.wide").map {
+            val name = it.select("div.episodeBlock").text()
+            val link = fixUrl(it.selectFirst("a")?.attr("href").toString())
+            Episode(link, name)
+        }
+        return newAnimeLoadResponse(title, url, type) {
+            posterUrl = fixUrlNull(document.selectFirst("div.infoPosterImg > img")?.attr("src"))
+            this.year = document.select("div.infoSta ul li:first-child").text().trim().toIntOrNull()
+            addEpisodes(DubStatus.Subbed, episodes)
+            plot = document.select("div.infoDesc").text().trim()
+            this.tags = document.select("span.dataValue span.ui.label").map { it.text() }
+            addTrailer(trailer)
+        }
+    }
+
+    private suspend fun invokeLokalSource(
+        url: String,
+        translator: String,
+        sourceCallback: (ExtractorLink) -> Unit
+    ) {
+        app.get(url, referer = "$mainUrl/").document.select("script").find { script ->
+            script.data().contains("eval(function(p,a,c,k,e,d)")
+        }?.let {
+            val key = getAndUnpack(it.data()).substringAfter("FirePlayer(\"").substringBefore("\",")
+            val referer = "$mainServer/video/$key"
+            val link = "$mainServer/player/index.php?data=$key&do=getVideo"
+            Log.i("hexated", link)
+            app.post(
+                link,
+                data = mapOf("hash" to key, "r" to "$mainUrl/"),
+                referer = referer,
+                headers = mapOf(
+                    "Accept" to "*/*",
+                    "Origin" to mainServer,
+                    "Content-Type" to "application/x-www-form-urlencoded; charset=UTF-8",
+                    "X-Requested-With" to "XMLHttpRequest"
+                )
+            ).parsedSafe<Source>()?.videoSource?.let { m3uLink ->
+                M3u8Helper.generateM3u8(
+                    "${this.name} ($translator)",
+                    m3uLink,
+                    referer
+                ).forEach(sourceCallback)
+            }
+        }
+    }
+
+    override suspend fun loadLinks(
+        data: String,
+        isCasting: Boolean,
+        subtitleCallback: (SubtitleFile) -> Unit,
+        callback: (ExtractorLink) -> Unit
+    ): Boolean {
+        val document = app.get(data).document
+        document.select("div.episodeTranslators div#fansec").map {
+            Pair(it.select("a").attr("translator"), it.select("div.title").text())
+        }.apmap { (url, translator) ->
+            safeApiCall {
+                app.get(
+                    url,
+                    referer = data,
+                    headers = mapOf(
+                        "Accept" to "application/json, text/javascript, */*; q=0.01",
+                        "X-Requested-With" to "XMLHttpRequest"
+                    )
+                ).parsedSafe<Translators>()?.data?.let {
+                    Jsoup.parse(it).select("a").apmap { video ->
+                        app.get(
+                            video.attr("video"),
+                            referer = data,
+                            headers = mapOf(
+                                "Accept" to "application/json, text/javascript, */*; q=0.01",
+                                "X-Requested-With" to "XMLHttpRequest"
+                            )
+                        ).parsedSafe<Videos>()?.player?.let { iframe ->
+                            Jsoup.parse(iframe).select("iframe").attr("src").let { link ->
+                                when {
+                                    link.startsWith(mainServer) -> {
+                                        invokeLokalSource(link, translator, callback)
+                                    }
+                                    else -> {
+                                        loadExtractor(
+                                            fixUrl(link),
+                                            "$mainUrl/",
+                                            subtitleCallback,
+                                            callback
+                                        )
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return true
+    }
+
+    data class Source(
+        @JsonProperty("videoSource") val videoSource: String?,
+    )
+
+    data class Videos(
+        @JsonProperty("player") val player: String?,
+    )
+
+    data class Translators(
+        @JsonProperty("data") val data: String?,
+    )
+
+}

Anizm/src/main/kotlin/com/hexated/AnizmPlugin.kt

@@ -1,13 +1,14 @@
-package com.example
+
+package com.hexated
 
 import com.lagradost.cloudstream3.plugins.CloudstreamPlugin
 import com.lagradost.cloudstream3.plugins.Plugin
 import android.content.Context
 
 @CloudstreamPlugin
-class TestPlugin: Plugin() {
+class AnizmPlugin: Plugin() {
     override fun load(context: Context) {
         // All providers should be added in this manner. Please don't edit the providers list directly.
-        registerMainAPI(ExampleProvider())
+        registerMainAPI(Anizm())
     }
 }

DramaidProvider/build.gradle.kts

@@ -0,0 +1,26 @@
+// use an integer for version numbers
+version = 2
+
+
+cloudstream {
+    language = "id"
+    // All of these properties are optional, you can safely remove them
+
+    // description = "Lorem Ipsum"
+     authors = listOf("Hexated")
+
+    /**
+     * Status int as the following:
+     * 0: Down
+     * 1: Ok
+     * 2: Slow
+     * 3: Beta only
+     * */
+    status = 1 // will be 3 if unspecified
+    tvTypes = listOf(
+        "AsianDrama",
+        "Movie",
+    )
+
+    iconUrl = "https://www.google.com/s2/favicons?domain=dramaid.asia&sz=%size%"
+}

DramaidProvider/src/main/AndroidManifest.xml

@@ -1,2 +1,2 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest package="com.example"/>
+<manifest package="com.hexated"/>

DramaidProvider/src/main/kotlin/com/hexated/DramaidProvider.kt

@@ -0,0 +1,213 @@
+package com.hexated
+
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.lagradost.cloudstream3.*
+import com.lagradost.cloudstream3.utils.AppUtils.tryParseJson
+import com.lagradost.cloudstream3.utils.ExtractorLink
+import com.lagradost.cloudstream3.utils.getQualityFromName
+import com.lagradost.cloudstream3.utils.loadExtractor
+import org.jsoup.Jsoup
+import org.jsoup.nodes.Element
+
+class DramaidProvider : MainAPI() {
+    override var mainUrl = "https://dramaid.asia"
+    override var name = "DramaId"
+    override val hasQuickSearch = false
+    override val hasMainPage = true
+    override var lang = "id"
+    override val hasDownloadSupport = true
+    override val hasChromecastSupport = false
+    override val supportedTypes = setOf(TvType.AsianDrama)
+
+    companion object {
+        fun getStatus(t: String): ShowStatus {
+            return when (t) {
+                "Completed" -> ShowStatus.Completed
+                "Ongoing" -> ShowStatus.Ongoing
+                else -> ShowStatus.Completed
+            }
+        }
+    }
+
+    override val mainPage = mainPageOf(
+        "&status=&type=&order=update" to "Drama Terbaru",
+        "&order=latest" to "Baru Ditambahkan",
+        "&status=&type=&order=popular" to "Drama Popular",
+    )
+
+    override suspend fun getMainPage(page: Int, request: MainPageRequest): HomePageResponse {
+        val document = app.get("$mainUrl/series/?page=$page${request.data}").document
+        val home = document.select("article[itemscope=itemscope]").mapNotNull {
+            it.toSearchResult()
+        }
+        return newHomePageResponse(request.name, home)
+    }
+
+    private fun getProperDramaLink(uri: String): String {
+        return if (uri.contains("/series/")) {
+            uri
+        } else {
+            "$mainUrl/series/" + Regex("$mainUrl/(.+)-ep.+").find(uri)?.groupValues?.get(1)
+                .toString()
+        }
+    }
+
+    private fun Element.toSearchResult(): SearchResponse? {
+        val href = getProperDramaLink(this.selectFirst("a.tip")!!.attr("href"))
+        val title = this.selectFirst("h2[itemprop=headline]")?.text()?.trim() ?: return null
+        val posterUrl = fixUrlNull(this.selectFirst(".limit > noscript > img")?.attr("src"))
+
+        return newTvSeriesSearchResponse(title, href, TvType.AsianDrama) {
+            this.posterUrl = posterUrl
+        }
+    }
+
+    override suspend fun search(query: String): List<SearchResponse> {
+        val link = "$mainUrl/?s=$query"
+        val document = app.get(link).document
+
+        return document.select("article[itemscope=itemscope]").map {
+            val title = it.selectFirst("h2[itemprop=headline]")!!.text().trim()
+            val poster = it.selectFirst(".limit > noscript > img")!!.attr("src")
+            val href = it.selectFirst("a.tip")!!.attr("href")
+
+            newTvSeriesSearchResponse(title, href, TvType.AsianDrama) {
+                this.posterUrl = poster
+            }
+        }
+    }
+
+    override suspend fun load(url: String): LoadResponse {
+        val document = app.get(url).document
+
+        val title = document.selectFirst("h1.entry-title")!!.text().trim()
+        val poster = document.select(".thumb > noscript > img").attr("src")
+        val tags = document.select(".genxed > a").map { it.text() }
+
+        val year = Regex("\\d, ([0-9]*)").find(
+            document.selectFirst(".info-content > .spe > span > time")!!.text().trim()
+        )?.groupValues?.get(1).toString().toIntOrNull()
+        val status = getStatus(
+            document.select(".info-content > .spe > span:nth-child(1)")
+                .text().trim().replace("Status: ", "")
+        )
+        val description = document.select(".entry-content > p").text().trim()
+
+        val episodes = document.select(".eplister > ul > li").map {
+            val name = it.selectFirst("a > .epl-title")!!.text().trim()
+            val link = it.select("a").attr("href")
+            val epNum = it.selectFirst("a > .epl-num")!!.text().trim().toIntOrNull()
+            newEpisode(link) {
+                this.name = name
+                this.episode = epNum
+            }
+        }.reversed()
+
+        val recommendations =
+            document.select(".listupd > article[itemscope=itemscope]").map { rec ->
+                val epTitle = rec.selectFirst("h2[itemprop=headline]")!!.text().trim()
+                val epPoster = rec.selectFirst(".limit > noscript > img")!!.attr("src")
+                val epHref = fixUrl(rec.selectFirst("a.tip")!!.attr("href"))
+
+                newTvSeriesSearchResponse(epTitle, epHref, TvType.AsianDrama) {
+                    this.posterUrl = epPoster
+                }
+            }
+
+        if (episodes.size == 1) {
+            return newMovieLoadResponse(title, url, TvType.Movie, episodes[0].data) {
+                posterUrl = poster
+                this.year = year
+                plot = description
+                this.tags = tags
+                this.recommendations = recommendations
+            }
+        } else {
+            return newTvSeriesLoadResponse(title, url, TvType.AsianDrama, episodes = episodes) {
+                posterUrl = poster
+                this.year = year
+                showStatus = status
+                plot = description
+                this.tags = tags
+                this.recommendations = recommendations
+            }
+        }
+
+    }
+
+    private data class Sources(
+        @JsonProperty("file") val file: String,
+        @JsonProperty("label") val label: String,
+        @JsonProperty("type") val type: String,
+        @JsonProperty("default") val default: Boolean?
+    )
+
+    private data class Tracks(
+        @JsonProperty("file") val file: String,
+        @JsonProperty("label") val label: String,
+        @JsonProperty("kind") val type: String,
+        @JsonProperty("default") val default: Boolean?
+    )
+
+    private suspend fun invokeDriveSource(
+        url: String,
+        name: String,
+        subCallback: (SubtitleFile) -> Unit,
+        sourceCallback: (ExtractorLink) -> Unit
+    ) {
+        val server = app.get(url).document.selectFirst(".picasa")?.nextElementSibling()?.data()
+
+        val source = "[${server!!.substringAfter("sources: [").substringBefore("],")}]".trimIndent()
+        val trackers = server.substringAfter("tracks:[").substringBefore("],")
+            .replace("//language", "")
+            .replace("file", "\"file\"")
+            .replace("label", "\"label\"")
+            .replace("kind", "\"kind\"").trimIndent()
+
+        tryParseJson<List<Sources>>(source)?.map {
+            sourceCallback(
+                ExtractorLink(
+                    name,
+                    "Drive",
+                    fixUrl(it.file),
+                    referer = "https://motonews.club/",
+                    quality = getQualityFromName(it.label)
+                )
+            )
+        }
+
+        tryParseJson<Tracks>(trackers)?.let {
+            subCallback.invoke(
+                SubtitleFile(
+                    if (it.label.contains("Indonesia")) "${it.label}n" else it.label,
+                    it.file
+                )
+            )
+        }
+
+    }
+
+    override suspend fun loadLinks(
+        data: String,
+        isCasting: Boolean,
+        subtitleCallback: (SubtitleFile) -> Unit,
+        callback: (ExtractorLink) -> Unit
+    ): Boolean {
+        val document = app.get(data).document
+        val sources = document.select(".mobius > .mirror > option").mapNotNull {
+            fixUrl(Jsoup.parse(base64Decode(it.attr("value"))).select("iframe").attr("src"))
+        }
+
+        sources.map {
+            it.replace("https://ndrama.xyz", "https://www.fembed.com")
+        }.apmap {
+            when {
+                it.contains("motonews.club") -> invokeDriveSource(it, this.name, subtitleCallback, callback)
+                else -> loadExtractor(it, data, subtitleCallback, callback)
+            }
+        }
+
+        return true
+    }
+
+}

DramaidProvider/src/main/kotlin/com/hexated/DramaidProviderPlugin.kt

@@ -0,0 +1,14 @@
+
+package com.hexated
+
+import com.lagradost.cloudstream3.plugins.CloudstreamPlugin
+import com.lagradost.cloudstream3.plugins.Plugin
+import android.content.Context
+
+@CloudstreamPlugin
+class DramaidProviderPlugin: Plugin() {
+    override fun load(context: Context) {
+        // All providers should be added in this manner. Please don't edit the providers list directly.
+        registerMainAPI(DramaidProvider())
+    }
+}

DubokuProvider/build.gradle.kts

@@ -0,0 +1,27 @@
+// use an integer for version numbers
+version = 1
+
+
+cloudstream {
+    language = "zh"
+    // All of these properties are optional, you can safely remove them
+
+    // description = "Lorem Ipsum"
+    authors = listOf("Hexated")
+
+    /**
+     * Status int as the following:
+     * 0: Down
+     * 1: Ok
+     * 2: Slow
+     * 3: Beta only
+     * */
+    status = 1 // will be 3 if unspecified
+    tvTypes = listOf(
+        "AsianDrama",
+        "TvSeries",
+        "Movie",
+    )
+
+    iconUrl = "https://www.google.com/s2/favicons?domain=www.duboku.tv&sz=%size%"
+}

DubokuProvider/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="com.hexated"/>

DubokuProvider/src/main/kotlin/com/hexated/DubokuProvider.kt

@@ -0,0 +1,133 @@
+package com.hexated
+
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.lagradost.cloudstream3.*
+import com.lagradost.cloudstream3.LoadResponse.Companion.addActors
+import com.lagradost.cloudstream3.utils.AppUtils.tryParseJson
+import com.lagradost.cloudstream3.utils.ExtractorLink
+import com.lagradost.cloudstream3.utils.M3u8Helper
+import org.jsoup.nodes.Element
+
+class DubokuProvider : MainAPI() {
+    override var mainUrl = "https://www.duboku.tv"
+    override var name = "Duboku"
+    override val hasMainPage = true
+    override var lang = "zh"
+    override val hasDownloadSupport = true
+    override val supportedTypes = setOf(
+        TvType.Movie,
+        TvType.TvSeries,
+        TvType.AsianDrama,
+    )
+
+    override val mainPage = mainPageOf(
+        "$mainUrl/vodshow/2--time------" to "连续剧 时间",
+        "$mainUrl/vodshow/2--hits------" to "连续剧 人气",
+        "$mainUrl/vodshow/13--time------" to "陆剧 时间",
+        "$mainUrl/vodshow/13--hits------" to "陆剧 人气",
+        "$mainUrl/vodshow/15--time------" to "日韩剧 时间",
+        "$mainUrl/vodshow/15--hits------" to "日韩剧 人气",
+        "$mainUrl/vodshow/21--time------" to "短剧 时间",
+        "$mainUrl/vodshow/21--hits------" to "短剧 人气",
+        "$mainUrl/vodshow/16--time------" to "英美剧 时间",
+        "$mainUrl/vodshow/16--hits------" to "英美剧 人气",
+        "$mainUrl/vodshow/14--time------" to "台泰剧 时间",
+        "$mainUrl/vodshow/14--hits------" to "台泰剧 人气",
+        "$mainUrl/vodshow/20--time------" to "港剧 时间",
+        "$mainUrl/vodshow/20--hits------" to "港剧 人气",
+    )
+
+    override suspend fun getMainPage(
+        page: Int,
+        request: MainPageRequest
+    ): HomePageResponse {
+        val document = app.get("${request.data}$page---.html").document
+        val home = document.select("ul.myui-vodlist.clearfix li").mapNotNull {
+            it.toSearchResult()
+        }
+        return newHomePageResponse(request.name, home)
+    }
+
+    private fun Element.toSearchResult(): SearchResponse? {
+        val title = this.selectFirst("h4.title a")?.text()?.trim() ?: return null
+        val href = fixUrl(this.selectFirst("a")?.attr("href").toString())
+        val posterUrl = fixUrlNull(this.selectFirst("a")?.attr("data-original"))
+        val episode = this.selectFirst("span.pic-text.text-right")?.text()?.filter { it.isDigit() }
+            ?.toIntOrNull()
+
+        return newAnimeSearchResponse(title, href, TvType.Movie) {
+            this.posterUrl = posterUrl
+            addSub(episode)
+        }
+    }
+
+    override suspend fun search(query: String): List<SearchResponse> {
+        val document = app.get("$mainUrl/vodsearch/-------------.html?wd=$query&submit=").document
+
+        return document.select("ul#searchList li").mapNotNull {
+            it.toSearchResult()
+        }
+    }
+
+    override suspend fun load(url: String): LoadResponse? {
+        val document = app.get(url).document
+
+        val title = document.selectFirst("h1.title")?.text()?.trim() ?: return null
+        val tvType = if (document.select("ul.myui-content__list li").size == 1
+        ) TvType.Movie else TvType.TvSeries
+        val actors = document.select("p.data")[2].select("a").map { it.text() }
+
+        val episodes = document.select("ul.myui-content__list li").map {
+            val href = fixUrl(it.select("a").attr("href"))
+            val name = it.select("a").text().trim()
+            Episode(
+                data = href,
+                name = name,
+            )
+        }
+        return newTvSeriesLoadResponse(title, url, tvType, episodes) {
+            this.posterUrl = fixUrlNull(
+                document.selectFirst("a.myui-vodlist__thumb.picture img")?.attr("data-original")
+            )
+            this.year =
+                document.select("p.data")[0].select("a").last()?.text()?.trim()?.toIntOrNull()
+            this.plot = document.selectFirst("span.sketch.content")?.text()?.trim()
+            this.tags = document.select("p.data")[0].select("a").map { it.text() }
+            this.rating = document.select("div#rating span.branch").text().toRatingInt()
+            addActors(actors)
+        }
+
+    }
+
+    override suspend fun loadLinks(
+        data: String,
+        isCasting: Boolean,
+        subtitleCallback: (SubtitleFile) -> Unit,
+        callback: (ExtractorLink) -> Unit
+    ): Boolean {
+
+        app.get(data).document.select("script").map { script ->
+            if (script.data().contains("var player_data={")) {
+                val dataJson =
+                    script.data().substringAfter("var player_data={").substringBefore("}")
+                tryParseJson<Sources>("{$dataJson}")?.let { source ->
+                    M3u8Helper.generateM3u8(
+                        this.name,
+                        source.url ?: return@map,
+                        referer = "https://w.duboku.io/",
+                        headers = mapOf("Origin" to "https://w.duboku.io")
+                    ).forEach(callback)
+                }
+            }
+        }
+
+
+        return true
+    }
+
+    data class Sources(
+        @JsonProperty("url") val url: String?,
+    )
+
+
+}

DubokuProvider/src/main/kotlin/com/hexated/DubokuProviderPlugin.kt

@@ -0,0 +1,14 @@
+
+package com.hexated
+
+import com.lagradost.cloudstream3.plugins.CloudstreamPlugin
+import com.lagradost.cloudstream3.plugins.Plugin
+import android.content.Context
+
+@CloudstreamPlugin
+class DubokuProviderPlugin: Plugin() {
+    override fun load(context: Context) {
+        // All providers should be added in this manner. Please don't edit the providers list directly.
+        registerMainAPI(DubokuProvider())
+    }
+}

ExampleProvider/build.gradle.kts

@@ -1,24 +0,0 @@
-// use an integer for version numbers
-version = 1
-
-
-cloudstream {
-    // All of these properties are optional, you can safely remove them
-
-    description = "Lorem Ipsum"
-    authors = listOf("Cloudburst")
-
-    /**
-    * Status int as the following:
-    * 0: Down
-    * 1: Ok
-    * 2: Slow
-    * 3: Beta only
-    * */
-    status = 1 // will be 3 if unspecified
-
-    // List of video source types. Users are able to filter for extensions in a given category.
-    // You can find a list of avaliable types here:
-    // https://recloudstream.github.io/cloudstream/html/app/com.lagradost.cloudstream3/-tv-type/index.html
-    tvTypes = listOf("Others")
-}

ExampleProvider/src/main/kotlin/com/example/ExampleProvider.kt

@@ -1,21 +0,0 @@
-package com.example
-
-import com.lagradost.cloudstream3.TvType
-import com.lagradost.cloudstream3.MainAPI
-import com.lagradost.cloudstream3.SearchResponse
-
-class ExampleProvider : MainAPI() { // all providers must be an instance of MainAPI
-    override var mainUrl = "https://example.com/" 
-    override var name = "Example provider"
-    override val supportedTypes = setOf(TvType.Movie)
-
-    override var lang = "en"
-
-    // enable this when your provider has a main page
-    override val hasMainPage = true
-
-    // this function gets called when you search for something
-    override suspend fun search(query: String): List<SearchResponse> {
-        return listOf<SearchResponse>()
-    }
-}

GomunimeProvider/build.gradle.kts

@@ -0,0 +1,27 @@
+// use an integer for version numbers
+version = 2
+
+
+cloudstream {
+    language = "id"
+    // All of these properties are optional, you can safely remove them
+
+//     description = "Lorem Ipsum"
+     authors = listOf("Hexated")
+
+    /**
+     * Status int as the following:
+     * 0: Down
+     * 1: Ok
+     * 2: Slow
+     * 3: Beta only
+     * */
+    status = 0 // will be 3 if unspecified
+    tvTypes = listOf(
+        "AnimeMovie",
+        "Anime",
+        "OVA",
+    )
+
+    iconUrl = "https://www.google.com/s2/favicons?domain=185.231.223.76&sz=%size%"
+}

GomunimeProvider/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="com.hexated"/>

GomunimeProvider/src/main/kotlin/com/hexated/GomunimeProvider.kt

@@ -0,0 +1,238 @@
+package com.hexated
+
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.lagradost.cloudstream3.*
+import com.lagradost.cloudstream3.LoadResponse.Companion.addTrailer
+import com.lagradost.cloudstream3.mvvm.safeApiCall
+import com.lagradost.cloudstream3.utils.AppUtils.parseJson
+import com.lagradost.cloudstream3.utils.ExtractorLink
+import com.lagradost.cloudstream3.utils.M3u8Helper
+import com.lagradost.cloudstream3.utils.Qualities
+import com.lagradost.cloudstream3.utils.loadExtractor
+import org.jsoup.Jsoup
+
+class GomunimeProvider : MainAPI() {
+    override var mainUrl = "https://185.231.223.76"
+    override var name = "Gomunime"
+    override val hasMainPage = true
+    override var lang = "id"
+    override val hasDownloadSupport = true
+
+    override val supportedTypes = setOf(
+        TvType.Anime,
+        TvType.AnimeMovie,
+        TvType.OVA
+    )
+
+    companion object {
+
+        private const val mainServer = "https://path.onicdn.xyz/app/rapi.php"
+
+        fun getType(t: String): TvType {
+            return if (t.contains("OVA") || t.contains("Special")) TvType.OVA
+            else if (t.contains("Movie")) TvType.AnimeMovie
+            else TvType.Anime
+        }
+
+        fun getStatus(t: String): ShowStatus {
+            return when (t) {
+                "Completed" -> ShowStatus.Completed
+                "Ongoing" -> ShowStatus.Ongoing
+                else -> ShowStatus.Completed
+            }
+        }
+    }
+
+    override val mainPage = mainPageOf(
+        "e" to "Episode Baru",
+        "c" to "Completed",
+        "la" to "Live Action",
+        "t" to "Trending"
+    )
+
+    override suspend fun getMainPage(
+        page: Int,
+        request: MainPageRequest
+    ): HomePageResponse {
+        val home = Jsoup.parse(
+            (app.post(
+                url = "$mainUrl/wp-admin/admin-ajax.php/wp-admin/admin-ajax.php",
+                headers = mapOf("Referer" to mainUrl),
+                data = mapOf(
+                    "action" to "home_ajax",
+                    "fungsi" to request.data,
+                    "pag" to "$page"
+                )
+            ).parsedSafe<Response>()?.html ?: throw ErrorLoadingException("Invalid Json reponse"))
+        ).select("li").mapNotNull {
+            val title = it.selectFirst("a.name")?.text()?.trim() ?: return@mapNotNull null
+            val href = getProperAnimeLink(it.selectFirst("a")!!.attr("href"))
+            val posterUrl = it.selectFirst("img")?.attr("src")
+            val type = getType(it.selectFirst(".taglist > span")!!.text().trim())
+            val epNum = it.select(".tag.ep").text().replace(Regex("[^0-9]"), "").trim()
+                .toIntOrNull()
+            newAnimeSearchResponse(title, href, type) {
+                this.posterUrl = posterUrl
+                addSub(epNum)
+            }
+        }
+
+        return newHomePageResponse(request.name, home)
+    }
+
+    private fun getProperAnimeLink(uri: String): String {
+        return if (uri.contains("-episode")) {
+            val href =
+                "$mainUrl/anime/" + Regex("\\w\\d/(.*)-episode.*").find(uri)?.groupValues?.get(1)
+                    .toString()
+            when {
+                href.contains("pokemon") -> href.replace(Regex("-[0-9]+"), "")
+                else -> href
+            }
+        } else {
+            uri
+        }
+    }
+
+    override suspend fun search(query: String): List<SearchResponse> {
+        val link = "$mainUrl/?s=$query"
+        val document = app.get(link).document
+
+        return document.select(".anime-list > li").map {
+            val title = it.selectFirst("a.name")!!.text()
+            val poster = it.selectFirst("img")!!.attr("src")
+            val tvType = getType(it.selectFirst(".taglist > span")?.text().toString())
+            val href = fixUrl(it.selectFirst("a.name")!!.attr("href"))
+
+            newAnimeSearchResponse(title, href, tvType) {
+                this.posterUrl = poster
+                addDubStatus(dubExist = false, subExist = true)
+            }
+        }
+    }
+
+    override suspend fun load(url: String): LoadResponse {
+        val document = app.get(url).document
+
+        val title = document.selectFirst(".entry-title")?.text().toString()
+        val poster = document.selectFirst(".thumbposter > img")?.attr("data-lazy-src")
+        val tags = document.select(".genxed > a").map { it.text() }
+
+        val year = Regex("\\d, ([0-9]*)").find(
+            document.select("time[itemprop = datePublished]").text()
+        )?.groupValues?.get