Split WPMangaStream Extension (#5803)

* Split WPMangaStream

* add some icons

* remove WPMangaStream

* move default_res

would be amazing

* override source id

* remove single extension

* rate limit

* add sources

Kuma Scans (Kuma Translation)
Tempest Manga

* remove multilang import

* override rate limit

* override source id

* fix class name

* remove file

multisrc/overrides/wpmangastream/boosei/src/Boosei.kt

@@ -0,0 +1,16 @@
+package eu.kanade.tachiyomi.extension.id.boosei
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
+
+class Boosei : WPMangaStream("Boosei", "https://boosei.com", "id") {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+}

multisrc/overrides/wpmangastream/chiotaku/src/ChiOtaku.kt

@@ -0,0 +1,16 @@
+package eu.kanade.tachiyomi.extension.id.chiotaku
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
+
+class ChiOtaku : WPMangaStream("ChiOtaku", "https://chiotaku.com", "id") {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+}

multisrc/overrides/wpmangastream/default/additional.gradle.kts

@@ -0,0 +1,4 @@
+
+dependencies {
+    implementation project(':lib-ratelimit')
+}

multisrc/overrides/wpmangastream/flamescans/src/FlameScans.kt

@@ -0,0 +1,16 @@
+package eu.kanade.tachiyomi.extension.en.flamescans
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
+
+class FlameScans : WPMangaStream("Flame Scans", "http://flamescans.org", "en") {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+}

multisrc/overrides/wpmangastream/gurukomik/src/GURUKomik.kt

@@ -0,0 +1,19 @@
+package eu.kanade.tachiyomi.extension.id.gurukomik
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import java.text.SimpleDateFormat
+import java.util.Locale
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import java.util.concurrent.TimeUnit
+import okhttp3.OkHttpClient
+
+class GURUKomik : WPMangaStream("GURU Komik", "https://gurukomik.com", "id", SimpleDateFormat("MMMM dd, yyyy", Locale.forLanguageTag("id"))) {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+
+}

multisrc/overrides/wpmangastream/kaisarkomik/src/KaisarKomik.kt

@@ -0,0 +1,16 @@
+package eu.kanade.tachiyomi.extension.id.kaisarkomik
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
+
+class KaisarKomik : WPMangaStream("Kaisar Komik", "https://kaisarkomik.com", "id") {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+}

multisrc/overrides/wpmangastream/kiryuu/src/Kiryuu.kt

@@ -0,0 +1,27 @@
+package eu.kanade.tachiyomi.extension.id.kiryuu
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.source.model.Page
+import org.jsoup.nodes.Document
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import java.util.concurrent.TimeUnit
+import okhttp3.OkHttpClient
+
+class Kiryuu : WPMangaStream("Kiryuu", "https://kiryuu.co", "id") {
+    // Formerly "Kiryuu (WP Manga Stream)"
+    override val id = 3639673976007021338
+
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+
+    override fun pageListParse(document: Document): List<Page> {
+        return document.select("div#readerarea img").map { it.attr("abs:src") }
+            .filterNot { it.substringAfterLast("/").contains(Regex("""(filerun|photothumb\.db)""")) }
+            .mapIndexed { i, image -> Page(i, "", image) }
+    }
+}

multisrc/overrides/wpmangastream/klankomik/src/KlanKomik.kt

@@ -0,0 +1,16 @@
+package eu.kanade.tachiyomi.extension.id.klankomik
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
+
+class KlanKomik : WPMangaStream("KlanKomik", "https://klankomik.com", "id") {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+}

multisrc/overrides/wpmangastream/komikav/src/KomikAV.kt

@@ -0,0 +1,33 @@
+package eu.kanade.tachiyomi.extension.id.komikav
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.source.model.Page
+import okhttp3.Request
+import java.text.SimpleDateFormat
+import java.util.Locale
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import java.util.concurrent.TimeUnit
+import okhttp3.OkHttpClient
+
+class KomikAV : WPMangaStream(
+    "Komik AV (WP Manga Stream)",
+    "https://komikav.com",
+    "id",
+    dateFormat = SimpleDateFormat("MMMM dd, yyyy", Locale.forLanguageTag("id"))
+) {
+    // Formerly "Komik AV (WP Manga Stream)"
+    override val id = 7875815514004535629
+
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+
+    override fun imageRequest(page: Page): Request {
+        return GET(page.imageUrl!!, headers)
+    }
+}

multisrc/overrides/wpmangastream/komikcast/src/KomikCast.kt

@@ -0,0 +1,102 @@
+package eu.kanade.tachiyomi.extension.id.komikcast
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.source.model.Filter
+import eu.kanade.tachiyomi.source.model.FilterList
+import eu.kanade.tachiyomi.source.model.Page
+import eu.kanade.tachiyomi.source.model.SManga
+import okhttp3.HttpUrl
+import okhttp3.Request
+import org.jsoup.nodes.Document
+import org.jsoup.nodes.Element
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import java.util.concurrent.TimeUnit
+import okhttp3.OkHttpClient
+
+class KomikCast : WPMangaStream("Komik Cast", "https://komikcast.com", "id") {
+    // Formerly "Komik Cast (WP Manga Stream)"
+    override val id = 972717448578983812
+
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+
+    override fun popularMangaRequest(page: Int): Request {
+        return GET("$baseUrl/daftar-komik/page/$page/?order=popular", headers)
+    }
+
+    override fun latestUpdatesRequest(page: Int): Request {
+        return GET("$baseUrl/komik/page/$page/", headers)
+    }
+
+    override fun searchMangaRequest(page: Int, query: String, filters: FilterList): Request {
+        val url = if (query.isNotBlank()) {
+            val url = HttpUrl.parse("$baseUrl/page/$page")!!.newBuilder()
+            val pattern = "\\s+".toRegex()
+            val q = query.replace(pattern, "+")
+            if (query.isNotEmpty()) {
+                url.addQueryParameter("s", q)
+            } else {
+                url.addQueryParameter("s", "")
+            }
+            url.toString()
+        } else {
+            val url = HttpUrl.parse("$baseUrl/daftar-komik/page/$page")!!.newBuilder()
+            var orderBy: String
+            (if (filters.isEmpty()) getFilterList() else filters).forEach { filter ->
+                when (filter) {
+                    is StatusFilter -> url.addQueryParameter("status", arrayOf("", "ongoing", "completed")[filter.state])
+                    is GenreListFilter -> {
+                        val genreInclude = mutableListOf<String>()
+                        filter.state.forEach {
+                            if (it.state == 1) {
+                                genreInclude.add(it.id)
+                            }
+                        }
+                        if (genreInclude.isNotEmpty()) {
+                            genreInclude.forEach { genre ->
+                                url.addQueryParameter("genre[]", genre)
+                            }
+                        }
+                    }
+                    is SortByFilter -> {
+                        orderBy = filter.toUriPart()
+                        url.addQueryParameter("order", orderBy)
+                    }
+                }
+            }
+            url.toString()
+        }
+        return GET(url, headers)
+    }
+
+    override fun popularMangaFromElement(element: Element): SManga {
+        val manga = SManga.create()
+        manga.thumbnail_url = element.select("div.limit img").attr("src")
+        element.select("div.bigor > a").first().let {
+            manga.setUrlWithoutDomain(it.attr("href"))
+            manga.title = it.attr("title")
+        }
+        return manga
+    }
+
+    override fun pageListParse(document: Document): List<Page> {
+        return document.select("div#readerarea img.size-full")
+            .mapIndexed { i, img -> Page(i, "", img.attr("abs:Src")) }
+    }
+
+    override fun getFilterList() = FilterList(
+        Filter.Header("NOTE: Ignored if using text search!"),
+        Filter.Separator(),
+        SortByFilter(),
+        Filter.Separator(),
+        StatusFilter(),
+        Filter.Separator(),
+        GenreListFilter(getGenreList())
+    )
+}

multisrc/overrides/wpmangastream/komikgo/src/KomikGo.kt

@@ -0,0 +1,238 @@
+package eu.kanade.tachiyomi.extension.id.komikgo
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.source.model.FilterList
+import eu.kanade.tachiyomi.source.model.Page
+import eu.kanade.tachiyomi.source.model.SChapter
+import eu.kanade.tachiyomi.source.model.SManga
+import okhttp3.Request
+import org.jsoup.nodes.Document
+import org.jsoup.nodes.Element
+import eu.kanade.tachiyomi.source.model.Filter
+import okhttp3.HttpUrl
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import java.util.concurrent.TimeUnit
+import okhttp3.OkHttpClient
+
+class KomikGo : WPMangaStream("Komik GO", "https://komikgo.com", "id") {
+    // Formerly "Komik GO (WP Manga Stream)"
+    override val id = 1070674823324721554
+
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+
+    override fun popularMangaRequest(page: Int): Request {
+        return GET("$baseUrl/page/$page?s&post_type=wp-manga&m_orderby=views", headers)
+    }
+
+    override fun latestUpdatesRequest(page: Int): Request {
+        return GET("$baseUrl/page/$page?s&post_type=wp-manga&m_orderby=latest", headers)
+    }
+
+    override fun popularMangaSelector() = "div.c-tabs-item__content"
+
+    override fun popularMangaFromElement(element: Element): SManga {
+        val manga = SManga.create()
+        manga.thumbnail_url = element.select("div.tab-thumb > a > img").attr("data-src")
+        element.select("div.tab-thumb > a").first().let {
+            manga.setUrlWithoutDomain(it.attr("href"))
+            manga.title = it.attr("title")
+        }
+        return manga
+    }
+
+    override fun searchMangaRequest(page: Int, query: String, filters: FilterList): Request {
+        val url = HttpUrl.parse("$baseUrl/page/$page")!!.newBuilder()
+        url.addQueryParameter("post_type", "wp-manga")
+        val pattern = "\\s+".toRegex()
+        val q = query.replace(pattern, "+")
+        if (query.isNotEmpty()) {
+            url.addQueryParameter("s", q)
+        } else {
+            url.addQueryParameter("s", "")
+        }
+
+        var orderBy: String
+
+        (if (filters.isEmpty()) getFilterList() else filters).forEach { filter ->
+            when (filter) {
+//                is Status -> url.addQueryParameter("manga_status", arrayOf("", "completed", "ongoing")[filter.state])
+                is GenreListFilter -> {
+                    val genreInclude = mutableListOf<String>()
+                    filter.state.forEach {
+                        if (it.state == 1) {
+                            genreInclude.add(it.id)
+                        }
+                    }
+                    if (genreInclude.isNotEmpty()) {
+                        genreInclude.forEach { genre ->
+                            url.addQueryParameter("genre[]", genre)
+                        }
+                    }
+                }
+                is StatusList -> {
+                    val statuses = mutableListOf<String>()
+                    filter.state.forEach {
+                        if (it.state == 1) {
+                            statuses.add(it.id)
+                        }
+                    }
+                    if (statuses.isNotEmpty()) {
+                        statuses.forEach { status ->
+                            url.addQueryParameter("status[]", status)
+                        }
+                    }
+                }
+
+                is SortBy -> {
+                    orderBy = filter.toUriPart()
+                    url.addQueryParameter("m_orderby", orderBy)
+                }
+                is TextField -> url.addQueryParameter(filter.key, filter.state)
+            }
+        }
+
+        return GET(url.toString(), headers)
+    }
+
+    override fun popularMangaNextPageSelector() = "#navigation-ajax"
+
+    override fun mangaDetailsParse(document: Document): SManga {
+        val infoElement = document.select("div.site-content").first()
+
+        val manga = SManga.create()
+        manga.author = infoElement.select("div.author-content")?.text()
+        manga.artist = infoElement.select("div.artist-content")?.text()
+
+        val genres = mutableListOf<String>()
+        infoElement.select("div.genres-content a").forEach { element ->
+            val genre = element.text()
+            genres.add(genre)
+        }
+        manga.genre = genres.joinToString(", ")
+        manga.status = parseStatus(infoElement.select("div.post-status > div:nth-child(2)  div").text())
+
+        manga.description = document.select("div.description-summary")?.text()
+        manga.thumbnail_url = document.select("div.summary_image > a > img").attr("data-src")
+
+        return manga
+    }
+
+    override fun chapterListSelector() = "li.wp-manga-chapter"
+
+    override fun chapterFromElement(element: Element): SChapter {
+        val urlElement = element.select("a").first()
+        val chapter = SChapter.create()
+        chapter.setUrlWithoutDomain(urlElement.attr("href"))
+        chapter.name = urlElement.text()
+        chapter.date_upload = parseChapterDate(element.select("span.chapter-release-date i").text())
+        return chapter
+    }
+
+    override fun pageListParse(document: Document): List<Page> {
+        return document.select("div.reading-content * img").mapIndexed { i, img ->
+            Page(i, "", img.imgAttr())
+        }
+    }
+
+    private class TextField(name: String, val key: String) : Filter.Text(name)
+
+    private class SortBy : UriPartFilter(
+        "Sort by",
+        arrayOf(
+            Pair("Relevance", ""),
+            Pair("Latest", "latest"),
+            Pair("A-Z", "alphabet"),
+            Pair("Rating", "rating"),
+            Pair("Trending", "trending"),
+            Pair("Most View", "views"),
+            Pair("New", "new-manga")
+        )
+    )
+
+    private class Status(name: String, val id: String = name) : Filter.TriState(name)
+    private class StatusList(statuses: List<Status>) : Filter.Group<Status>("Status", statuses)
+
+    override fun getFilterList() = FilterList(
+        TextField("Author", "author"),
+        TextField("Year", "release"),
+        SortBy(),
+        StatusList(getStatusList()),
+        GenreListFilter(getGenreList())
+    )
+
+    private fun getStatusList() = listOf(
+        Status("Completed", "end"),
+        Status("Ongoing", "on-going"),
+        Status("Canceled", "canceled"),
+        Status("Onhold", "on-hold")
+    )
+
+    override fun getGenreList(): List<Genre> = listOf(
+        Genre("Adventure", "Adventure"),
+        Genre("Action", "action"),
+        Genre("Adventure", "adventure"),
+        Genre("Cars", "cars"),
+        Genre("4-Koma", "4-koma"),
+        Genre("Comedy", "comedy"),
+        Genre("Completed", "completed"),
+        Genre("Cooking", "cooking"),
+        Genre("Dementia", "dementia"),
+        Genre("Demons", "demons"),
+        Genre("Doujinshi", "doujinshi"),
+        Genre("Drama", "drama"),
+        Genre("Ecchi", "ecchi"),
+        Genre("Fantasy", "fantasy"),
+        Genre("Game", "game"),
+        Genre("Gender Bender", "gender-bender"),
+        Genre("Harem", "harem"),
+        Genre("Historical", "historical"),
+        Genre("Horror", "horror"),
+        Genre("Isekai", "isekai"),
+        Genre("Josei", "josei"),
+        Genre("Kids", "kids"),
+        Genre("Magic", "magic"),
+        Genre("Manga", "manga"),
+        Genre("Manhua", "manhua"),
+        Genre("Manhwa", "manhwa"),
+        Genre("Martial Arts", "martial-arts"),
+        Genre("Mature", "mature"),
+        Genre("Mecha", "mecha"),
+        Genre("Military", "military"),
+        Genre("Music", "music"),
+        Genre("Mystery", "mystery"),
+        Genre("Old Comic", "old-comic"),
+        Genre("One Shot", "one-shot"),
+        Genre("Oneshot", "oneshot"),
+        Genre("Parodi", "parodi"),
+        Genre("Parody", "parody"),
+        Genre("Police", "police"),
+        Genre("Psychological", "psychological"),
+        Genre("Romance", "romance"),
+        Genre("Samurai", "samurai"),
+        Genre("School", "school"),
+        Genre("School Life", "school-life"),
+        Genre("Sci-Fi", "sci-fi"),
+        Genre("Seinen", "seinen"),
+        Genre("Shoujo", "shoujo"),
+        Genre("Shoujo Ai", "shoujo-ai"),
+        Genre("Shounen", "shounen"),
+        Genre("Shounen ai", "shounen-ai"),
+        Genre("Slice of Life", "slice-of-life"),
+        Genre("Sports", "sports"),
+        Genre("Super Power", "super-power"),
+        Genre("Supernatural", "supernatural"),
+        Genre("Thriller", "thriller"),
+        Genre("Tragedy", "tragedy"),
+        Genre("Vampire", "vampire"),
+        Genre("Webtoons", "webtoons"),
+        Genre("Yaoi", "yaoi"),
+        Genre("Yuri", "yuri")
+    )
+}

multisrc/overrides/wpmangastream/komikindoco/src/KomikindoCo.kt

@@ -0,0 +1,19 @@
+package eu.kanade.tachiyomi.extension.id.komikindoco
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
+
+class KomikindoCo : WPMangaStream("KomikIndo.co", "https://komikindo.co", "id") {
+    // Formerly "Komikindo.co"
+    override val id = 734619124437406170
+
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+}

multisrc/overrides/wpmangastream/komikindowpms/src/KomikIndoWPMS.kt

@@ -0,0 +1,20 @@
+package eu.kanade.tachiyomi.extension.id.komikindowpms
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import java.util.concurrent.TimeUnit
+import okhttp3.OkHttpClient
+
+class KomikIndoWPMS : WPMangaStream("Komik Indo", "https://www.komikindo.web.id", "id") {
+    // Formerly "Komik Indo (WP Manga Stream)"
+    override val id = 1481562643469779882
+
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+
+}

multisrc/overrides/wpmangastream/komikru/src/KomikRu.kt

@@ -0,0 +1,19 @@
+package eu.kanade.tachiyomi.extension.id.komikru
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import java.text.SimpleDateFormat
+import java.util.Locale
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import java.util.concurrent.TimeUnit
+import okhttp3.OkHttpClient
+
+class KomikRu : WPMangaStream("KomikRu", "https://komikru.com", "id", SimpleDateFormat("MMMM dd, yyyy", Locale.forLanguageTag("id"))) {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+
+}

multisrc/overrides/wpmangastream/komikstation/src/KomikStation.kt

@@ -0,0 +1,20 @@
+package eu.kanade.tachiyomi.extension.id.komikstation
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+
+class KomikStation : WPMangaStream("Komik Station", "https://komikstation.com", "id") {
+    // Formerly "Komik Station (WP Manga Stream)"
+    override val id = 6148605743576635261
+
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+
+}

multisrc/overrides/wpmangastream/komiktap/src/KomikTap.kt

@@ -0,0 +1,16 @@
+package eu.kanade.tachiyomi.extension.id.komiktap
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
+
+class KomikTap : WPMangaStream("KomikTap", "https://komiktap.in/", "id") {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+}

multisrc/overrides/wpmangastream/kumascans/src/KumaScans.kt

@@ -0,0 +1,16 @@
+package eu.kanade.tachiyomi.extension.en.kumascans
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
+
+class KumaScans : WPMangaStream("Kuma Scans (Kuma Translation)", "https://kumascans.com", "en") {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+}

multisrc/overrides/wpmangastream/liebeschneehiver/src/LiebeSchneeHiver.kt

@@ -0,0 +1,24 @@
+package eu.kanade.tachiyomi.extension.tr.liebeschneehiver
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import java.text.SimpleDateFormat
+import java.util.Locale
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import java.util.concurrent.TimeUnit
+import okhttp3.OkHttpClient
+
+class LiebeSchneeHiver : WPMangaStream(
+    "Liebe Schnee Hiver",
+    "https://www.liebeschneehiver.com",
+    "tr",
+    SimpleDateFormat("MMMM dd, yyyy", Locale.forLanguageTag("tr"))
+) {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+
+}

multisrc/overrides/wpmangastream/mangaindonesia/src/MangaIndonesia.kt

@@ -0,0 +1,53 @@
+package eu.kanade.tachiyomi.extension.id.mangaindonesia
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.source.model.FilterList
+import eu.kanade.tachiyomi.source.model.SChapter
+import eu.kanade.tachiyomi.source.model.SManga
+import okhttp3.Request
+import org.jsoup.nodes.Element
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import java.util.concurrent.TimeUnit
+import okhttp3.OkHttpClient
+
+class MangaIndonesia : WPMangaStream("MangaIndonesia", "https://mangaindonesia.net", "id") {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+
+    override fun popularMangaRequest(page: Int): Request {
+//        return GET("$baseUrl/popular" + if (page > 1) "/${(page - 1) * 30}" else "", headers)
+//        return GET("$baseUrl/$popularPath" + if (page > 1) "?page=$page" else "", headers)
+        return GET("$baseUrl/update/" + if (page > 1) "?page=$page" else "", headers)
+    }
+    override fun latestUpdatesRequest(page: Int): Request {
+        return GET(baseUrl, headers)
+    }
+    override fun latestUpdatesSelector() = ".listupd:not(.project) .uta .imgu"
+    override fun latestUpdatesFromElement(element: Element): SManga {
+        val manga = SManga.create()
+        manga.thumbnail_url = element.select("a img").imgAttr()
+        element.select("a").first().let {
+            manga.setUrlWithoutDomain(it.attr("href"))
+            manga.title = it.attr("title")
+        }
+        return manga
+    }
+    override fun latestUpdatesNextPageSelector(): String? = null
+    override fun searchMangaRequest(page: Int, query: String, filters: FilterList): Request {
+        return GET("$baseUrl/page/$page/$query", headers)
+    }
+    override fun chapterListSelector() = "div.bxcl ul li:has(span)"
+    override fun chapterFromElement(element: Element): SChapter {
+        val chapter = SChapter.create()
+        chapter.setUrlWithoutDomain(element.select("a").attr("href"))
+        chapter.name = element.select("a").text()
+        chapter.date_upload = element.select("span.dt").firstOrNull()?.text()?.let { parseChapterDate(it) } ?: 0
+        return chapter
+    }
+}

multisrc/overrides/wpmangastream/mangakyo/src/Mangakyo.kt

@@ -0,0 +1,16 @@
+package eu.kanade.tachiyomi.extension.id.mangakyo
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
+
+class Mangakyo : WPMangaStream("Mangakyo", "https://www.mangakyo.me", "id") {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+}

multisrc/overrides/wpmangastream/mangap/src/MangaP.kt

@@ -0,0 +1,16 @@
+package eu.kanade.tachiyomi.extension.ar.mangap
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
+
+class MangaP : WPMangaStream("MangaP", "https://mangap.me", "ar") {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+}

multisrc/overrides/wpmangastream/mangaproz/src/MangaProZ.kt

@@ -0,0 +1,20 @@
+package eu.kanade.tachiyomi.extension.ar.mangaproz
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.source.model.SChapter
+import org.jsoup.nodes.Element
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import java.util.concurrent.TimeUnit
+import okhttp3.OkHttpClient
+
+class MangaProZ : WPMangaStream("Manga Pro Z", "https://mangaproz.com", "ar") {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+
+    override fun chapterFromElement(element: Element): SChapter = super.chapterFromElement(element).apply { name = name.removeSuffix(" free") }
+}

multisrc/overrides/wpmangastream/mangaraw/src/MangaRaw.kt

@@ -0,0 +1,61 @@
+package eu.kanade.tachiyomi.extension.ja.mangaraw
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.source.model.FilterList
+import eu.kanade.tachiyomi.source.model.Page
+import eu.kanade.tachiyomi.source.model.SChapter
+import eu.kanade.tachiyomi.source.model.SManga
+import okhttp3.Request
+import okhttp3.Response
+import org.jsoup.nodes.Document
+import org.jsoup.nodes.Element
+import eu.kanade.tachiyomi.network.asObservableSuccess
+import eu.kanade.tachiyomi.util.asJsoup
+import rx.Observable
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import java.util.concurrent.TimeUnit
+import okhttp3.OkHttpClient
+
+class MangaRaw : WPMangaStream("Manga Raw", "https://mangaraw.org", "ja") {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+
+    override fun popularMangaRequest(page: Int): Request = GET("$baseUrl/search?order=popular&page=$page", headers)
+    override fun popularMangaSelector() = "div.bsx"
+    override fun popularMangaFromElement(element: Element): SManga {
+        return SManga.create().apply {
+            element.select("div.bigor > a").let {
+                setUrlWithoutDomain(it.attr("href"))
+                title = it.text()
+            }
+            thumbnail_url = element.select("img").attr("abs:src")
+        }
+    }
+    override fun popularMangaNextPageSelector() = "a[rel=next]"
+    override fun latestUpdatesRequest(page: Int): Request = GET("$baseUrl/search?order=update&page=$page", headers)
+    override fun searchMangaRequest(page: Int, query: String, filters: FilterList): Request =
+        GET("$baseUrl/search?s=$query&page=$page")
+    override fun searchMangaFromElement(element: Element): SManga = popularMangaFromElement(element)
+    override fun mangaDetailsParse(document: Document): SManga = super.mangaDetailsParse(document)
+        .apply { description = document.select("div.bottom").firstOrNull()?.ownText() }
+    override fun fetchPageList(chapter: SChapter): Observable<List<Page>> {
+        return client.newCall(pageListRequest(chapter))
+            .asObservableSuccess()
+            .map { response ->
+                pageListParse(response, baseUrl + chapter.url.removeSuffix("/"))
+            }
+    }
+    private fun pageListParse(response: Response, chapterUrl: String): List<Page> {
+        return response.asJsoup().select("span.page-link").first().ownText().substringAfterLast(" ").toInt()
+            .let { lastNum -> IntRange(1, lastNum) }
+            .map { num -> Page(num, "$chapterUrl/$num") }
+    }
+    override fun imageUrlParse(document: Document): String = document.select("a.img-block img").attr("abs:src")
+    override fun getFilterList(): FilterList = FilterList()
+}

multisrc/overrides/wpmangastream/mangashiro/src/MangaShiro.kt

@@ -0,0 +1,16 @@
+package eu.kanade.tachiyomi.extension.id.mangashiro
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
+
+class MangaShiro : WPMangaStream("MangaShiro", "https://mangashiro.co", "id") {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+}

multisrc/overrides/wpmangastream/mangaswat/src/MangaSwat.kt

@@ -0,0 +1,112 @@
+package eu.kanade.tachiyomi.extension.ar.mangaswat
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.source.model.FilterList
+import eu.kanade.tachiyomi.source.model.SChapter
+import eu.kanade.tachiyomi.source.model.SManga
+import okhttp3.Headers
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import org.jsoup.nodes.Document
+import okhttp3.Interceptor
+import java.io.IOException
+
+class MangaSwat : WPMangaStream("MangaSwat", "https://mangaswat.com", "ar") {
+    /**
+     * Use IOException or the app crashes!
+     * x-sucuri-cache header is never present on images; specify webpages or glide won't load images!
+     */
+    private class Sucuri : Interceptor {
+        override fun intercept(chain: Interceptor.Chain): Response {
+            val response = chain.proceed(chain.request())
+            if (response.header("x-sucuri-cache").isNullOrEmpty() && response.request().url().toString().contains("//mangaswat.com"))
+                throw IOException("Site protected, open webview | موقع محمي ، عرض ويب مفتوح")
+            return response
+        }
+    }
+    override val client: OkHttpClient = super.client.newBuilder().addInterceptor(Sucuri()).build()
+
+    override fun headersBuilder(): Headers.Builder = Headers.Builder()
+        .add("Referer", baseUrl)
+        .add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:76.0) Gecko/20100101 Firefox/76.0")
+        .add("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3")
+
+    override fun mangaDetailsParse(document: Document): SManga {
+        return SManga.create().apply {
+            document.select("div.bigcontent").firstOrNull()?.let { infoElement ->
+                genre = infoElement.select("span:contains(التصنيف) a").joinToString { it.text() }
+                status = parseStatus(infoElement.select("span:contains(الحالة)").firstOrNull()?.ownText())
+                author = infoElement.select("span:contains(المؤلف) i").firstOrNull()?.ownText()
+                artist = author
+                description = infoElement.select("div.desc").text()
+                thumbnail_url = infoElement.select("img").imgAttr()
+            }
+        }
+    }
+    override fun pageListRequest(chapter: SChapter): Request {
+        return GET(baseUrl + chapter.url + "?/", headers) // Bypass "linkvertise" ads
+    }
+
+    override fun getFilterList() = FilterList(
+        StatusFilter(),
+        TypeFilter(),
+        SortByFilter(),
+        GenreListFilter(getGenrePairs())
+    )
+
+    private class GenreListFilter(pairs: Array<Pair<String, String>>) : UriPartFilter("Genre", pairs)
+
+    private fun getGenrePairs() = arrayOf(
+        Pair("<--->", ""),
+        Pair("آلات", "%d8%a2%d9%84%d8%a7%d8%aa"),
+        Pair("أكشن", "%d8%a3%d9%83%d8%b4%d9%86"),
+        Pair("إثارة", "%d8%a5%d8%ab%d8%a7%d8%b1%d8%a9"),
+        Pair("إعادة", "%d8%a5%d8%b9%d8%a7%d8%af%d8%a9-%d8%a5%d8%ad%d9%8a%d8%a7%d8%a1"),
+        Pair("الحياة", "%d8%a7%d9%84%d8%ad%d9%8a%d8%a7%d8%a9-%d8%a7%d9%84%d9%85%d8%af%d8%b1%d8%b3%d9%8a%d8%a9"),
+        Pair("الحياة", "%d8%a7%d9%84%d8%ad%d9%8a%d8%a7%d8%a9-%d8%a7%d9%84%d9%8a%d9%88%d9%85%d9%8a%d8%a9"),
+        Pair("العاب", "%d8%a7%d9%84%d8%b9%d8%a7%d8%a8-%d9%81%d9%8a%d8%af%d9%8a%d9%88"),
+        Pair("ايتشي", "%d8%a7%d9%8a%d8%aa%d8%b4%d9%8a"),
+        Pair("ايسكاي", "%d8%a7%d9%8a%d8%b3%d9%83%d8%a7%d9%8a"),
+        Pair("بالغ", "%d8%a8%d8%a7%d9%84%d8%ba"),
+        Pair("تاريخي", "%d8%aa%d8%a7%d8%b1%d9%8a%d8%ae%d9%8a"),
+        Pair("تراجيدي", "%d8%aa%d8%b1%d8%a7%d8%ac%d9%8a%d8%af%d9%8a"),
+        Pair("جوسيه", "%d8%ac%d9%88%d8%b3%d9%8a%d9%87"),
+        Pair("جيندر", "%d8%ac%d9%8a%d9%86%d8%af%d8%b1-%d8%a8%d9%86%d8%af%d8%b1"),
+        Pair("حربي", "%d8%ad%d8%b1%d8%a8%d9%8a"),
+        Pair("حريم", "%d8%ad%d8%b1%d9%8a%d9%85"),
+        Pair("خارق", "%d8%ae%d8%a7%d8%b1%d9%82-%d9%84%d9%84%d8%b7%d8%a8%d9%8a%d8%b9%d8%a9"),
+        Pair("خيال", "%d8%ae%d9%8a%d8%a7%d9%84"),
+        Pair("خيال", "%d8%ae%d9%8a%d8%a7%d9%84-%d8%b9%d9%84%d9%85%d9%8a"),
+        Pair("دراما", "%d8%af%d8%b1%d8%a7%d9%85%d8%a7"),
+        Pair("دموي", "%d8%af%d9%85%d9%88%d9%8a"),
+        Pair("رعب", "%d8%b1%d8%b9%d8%a8"),
+        Pair("رومانسي", "%d8%b1%d9%88%d9%85%d8%a7%d9%86%d8%b3%d9%8a"),
+        Pair("رياضة", "%d8%b1%d9%8a%d8%a7%d8%b6%d8%a9"),
+        Pair("زمكاني", "%d8%b2%d9%85%d9%83%d8%a7%d9%86%d9%8a"),
+        Pair("زومبي", "%d8%b2%d9%88%d9%85%d8%a8%d9%8a"),
+        Pair("سحر", "%d8%b3%d8%ad%d8%b1"),
+        Pair("سينين", "%d8%b3%d9%8a%d9%86%d9%8a%d9%86"),
+        Pair("شريحة", "%d8%b4%d8%b1%d9%8a%d8%ad%d8%a9-%d9%85%d9%86-%d8%a7%d9%84%d8%ad%d9%8a%d8%a7%d8%a9"),
+        Pair("شوجو", "%d8%b4%d9%88%d8%ac%d9%88"),
+        Pair("شونين", "%d8%b4%d9%88%d9%86%d9%8a%d9%86"),
+        Pair("شياطين", "%d8%b4%d9%8a%d8%a7%d8%b7%d9%8a%d9%86"),
+        Pair("طبخ", "%d8%b7%d8%a8%d8%ae"),
+        Pair("طبي", "%d8%b7%d8%a8%d9%8a"),
+        Pair("غموض", "%d8%ba%d9%85%d9%88%d8%b6"),
+        Pair("فانتازي", "%d9%81%d8%a7%d9%86%d8%aa%d8%a7%d8%b2%d9%8a"),
+        Pair("فنون", "%d9%81%d9%86%d9%88%d9%86-%d9%82%d8%aa%d8%a7%d9%84%d9%8a%d8%a9"),
+        Pair("فوق", "%d9%81%d9%88%d9%82-%d8%a7%d9%84%d8%b7%d8%a8%d9%8a%d8%b9%d8%a9"),
+        Pair("قوى", "%d9%82%d9%88%d9%89-%d8%ae%d8%a7%d8%b1%d9%82%d8%a9"),
+        Pair("كوميدي", "%d9%83%d9%88%d9%85%d9%8a%d8%af%d9%8a"),
+        Pair("لعبة", "%d9%84%d8%b9%d8%a8%d8%a9"),
+        Pair("مافيا", "%d9%85%d8%a7%d9%81%d9%8a%d8%a7"),
+        Pair("مصاصى", "%d9%85%d8%b5%d8%a7%d8%b5%d9%89-%d8%a7%d9%84%d8%af%d9%85%d8%a7%d8%a1"),
+        Pair("مغامرات", "%d9%85%d8%ba%d8%a7%d9%85%d8%b1%d8%a7%d8%aa"),
+        Pair("ميكا", "%d9%85%d9%8a%d9%83%d8%a7"),
+        Pair("نفسي", "%d9%86%d9%81%d8%b3%d9%8a"),
+        Pair("وحوش", "%d9%88%d8%ad%d9%88%d8%b4"),
+        Pair("ويب-تون", "%d9%88%d9%8a%d8%a8-%d8%aa%d9%88%d9%86")
+    )
+}

multisrc/overrides/wpmangastream/masterkomik/src/MasterKomik.kt

@@ -0,0 +1,16 @@
+package eu.kanade.tachiyomi.extension.id.masterkomik
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
+
+class MasterKomik : WPMangaStream("MasterKomik", "https://masterkomik.com", "id") {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+}

multisrc/overrides/wpmangastream/matakomik/src/Matakomik.kt

@@ -0,0 +1,24 @@
+package eu.kanade.tachiyomi.extension.id.matakomik
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.source.model.Page
+import org.jsoup.nodes.Document
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import java.util.concurrent.TimeUnit
+import okhttp3.OkHttpClient
+
+class Matakomik : WPMangaStream("Matakomik", "https://matakomik.com", "id") {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+
+    override fun pageListParse(document: Document): List<Page> {
+        return document.select("div#readerarea a").mapIndexed { i, a ->
+            Page(i, "", a.attr("abs:href"))
+        }
+    }
+}

multisrc/overrides/wpmangastream/nonstopscans/src/NonStopScans.kt

@@ -0,0 +1,16 @@
+package eu.kanade.tachiyomi.extension.en.nonstopscans
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
+
+class NonStopScans : WPMangaStream("Non-Stop Scans", "https://www.nonstopscans.com", "en") {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+}

multisrc/overrides/wpmangastream/rawkuma/src/Rawkuma.kt

@@ -0,0 +1,16 @@
+package eu.kanade.tachiyomi.extension.ja.rawkuma
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
+
+class Rawkuma : WPMangaStream("Rawkuma", "https://rawkuma.com/", "ja") {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+}

multisrc/overrides/wpmangastream/readkomik/src/ReadKomik.kt

@@ -0,0 +1,16 @@
+package eu.kanade.tachiyomi.extension.en.readkomik
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
+
+class ReadKomik : WPMangaStream("Readkomik", "https://readkomik.com", "en") {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+}

multisrc/overrides/wpmangastream/resetscans/src/ResetScans.kt

@@ -0,0 +1,16 @@
+package eu.kanade.tachiyomi.extension.en.resetscans
+
+import eu.kanade.tachiyomi.multisrc.wpmangastream.WPMangaStream
+import eu.kanade.tachiyomi.lib.ratelimit.RateLimitInterceptor
+import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
+
+class ResetScans : WPMangaStream("Reset Scans", "https://reset-scans.com", "en") {
+    private val rateLimitInterceptor = RateLimitInterceptor(4)
+
+    override val client: OkHttpClient = network.cloudflareClient.newBuilder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .addNetworkInterceptor(rateLimitInterceptor)
+        .build()
+}