Merge pull request #226 from davvarrr/master

fix and add sources

src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/DynastyScans.kt

@@ -0,0 +1,172 @@
+package org.koitharu.kotatsu.parsers.site.en
+
+import okhttp3.Headers
+import org.json.JSONArray
+import org.jsoup.nodes.Document
+import org.koitharu.kotatsu.parsers.MangaLoaderContext
+import org.koitharu.kotatsu.parsers.MangaSourceParser
+import org.koitharu.kotatsu.parsers.PagedMangaParser
+import org.koitharu.kotatsu.parsers.config.ConfigKey
+import org.koitharu.kotatsu.parsers.model.*
+import org.koitharu.kotatsu.parsers.network.UserAgents
+import org.koitharu.kotatsu.parsers.util.*
+import java.text.SimpleDateFormat
+import java.util.*
+
+@MangaSourceParser("DYNASTYSCANS", "Dynasty Scans", "en")
+internal class DynastyScans(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.DYNASTYSCANS, 117) {
+	override val sortOrders: Set<SortOrder> = EnumSet.of(SortOrder.ALPHABETICAL)
+	override val configKeyDomain = ConfigKey.Domain("dynasty-scans.com")
+
+	override val headers: Headers = Headers.Builder()
+		.add("User-Agent", UserAgents.CHROME_DESKTOP)
+		.build()
+
+	override suspend fun getListPage(
+		page: Int,
+		query: String?,
+		tags: Set<MangaTag>?,
+		sortOrder: SortOrder,
+	): List<Manga> {
+		val url = buildString {
+			append("https://")
+			append(domain)
+			if (!query.isNullOrEmpty()) {
+				append("/search?q=")
+				append(query.urlEncoded())
+				append("&")
+				append("classes[]".urlEncoded())
+				append("=Serie&page=")
+				append(page.toString())
+			} else if (!tags.isNullOrEmpty()) {
+				append("/tags/")
+				for (tag in tags) {
+					append(tag.key)
+				}
+				append("?view=groupings&page=")
+				append(page.toString())
+			} else {
+				append("/series?view=cover&page=")
+				append(page.toString())
+			}
+		}
+		val doc = webClient.httpGet(url).parseHtml()
+
+		//There are no images on the search page
+		if (!query.isNullOrEmpty()) {
+			return doc.select("dl.chapter-list dd")
+				.map { div ->
+					val href = div.selectFirstOrThrow("a").attrAsAbsoluteUrl("href")
+					Manga(
+						id = generateUid(href),
+						title = div.selectFirstOrThrow("a").text(),
+						altTitle = null,
+						url = href,
+						publicUrl = href.toAbsoluteUrl(domain),
+						rating = RATING_UNKNOWN,
+						isNsfw = false,
+						coverUrl = "",
+						tags = div.select("span.tags a").mapNotNullToSet { a ->
+							MangaTag(
+								key = a.attr("href").removeSuffix('/').substringAfterLast('/'),
+								title = a.text(),
+								source = source,
+							)
+						},
+						state = null,
+						author = null,
+						source = source,
+					)
+				}
+		} else {
+			return doc.select("li.span2")
+				.map { div ->
+					val href = div.selectFirstOrThrow("a").attrAsAbsoluteUrl("href")
+					Manga(
+						id = generateUid(href),
+						title = div.selectFirstOrThrow("div.caption").text(),
+						altTitle = null,
+						url = href,
+						publicUrl = href.toAbsoluteUrl(domain),
+						rating = RATING_UNKNOWN,
+						isNsfw = false,
+						coverUrl = div.selectFirstOrThrow("img").attrAsAbsoluteUrl("src"),
+						tags = setOf(),
+						state = null,
+						author = null,
+						source = source,
+					)
+				}
+		}
+
+	}
+
+	override suspend fun getTags(): Set<MangaTag> = emptySet()
+
+	override suspend fun getDetails(manga: Manga): Manga {
+		val doc = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml()
+		val chapters = getChapters(doc)
+		val root = doc.requireElementById("main")
+		return manga.copy(
+			altTitle = null,
+			state = when (root.select("h2.tag-title small").last()?.text()) {
+				"— Ongoing" -> MangaState.ONGOING
+				"— Completed" -> MangaState.FINISHED
+				else -> null
+			},
+			coverUrl = root.selectFirst("img.thumbnail")?.src()
+				.orEmpty(), // It is needed if the manga was found via the search.
+			tags = root.select("div.tag-tags a").mapNotNullToSet { a ->
+				val href = a.attr("href").removeSuffix('/').substringAfterLast('/')
+				MangaTag(
+					key = href,
+					title = a.text(),
+					source = source,
+				)
+			},
+			author = null,
+			description = null,
+			chapters = chapters,
+		)
+	}
+
+	private fun getChapters(doc: Document): List<MangaChapter> {
+		val dateFormat = SimpleDateFormat("MMM dd yy", sourceLocale)
+		return doc.body().select("dl.chapter-list dd").mapChapters { i, li ->
+			val a = li.selectFirstOrThrow("a")
+			val href = a.attrAsRelativeUrl("href")
+			val dateText = li.select("small").last()?.text()?.replace("released ", "")?.replace("'", "")
+			MangaChapter(
+				id = generateUid(href),
+				name = a.text(),
+				number = i + 1,
+				url = href,
+				uploadDate = dateFormat.tryParse(dateText),
+				source = source,
+				scanlator = null,
+				branch = null,
+			)
+		}
+	}
+
+	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
+		val chapterUrl = chapter.url.toAbsoluteUrl(domain)
+		val docs = webClient.httpGet(chapterUrl).parseHtml()
+		val script = docs.selectFirstOrThrow("script:containsData(var pages =)")
+		val json = JSONArray(script.data().substringAfter('=').substringBeforeLast(';'))
+		val pages = ArrayList<MangaPage>(json.length())
+		for (i in 0 until json.length()) {
+			val url = "https://" + domain + json.getString(i).substringAfter(":\"").substringBefore("\",")
+			pages.add(
+				MangaPage(
+					id = generateUid(url),
+					url = url,
+					preview = null,
+					source = source,
+				),
+			)
+		}
+		return pages
+	}
+}
+

src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/Mangaowl.kt

@@ -0,0 +1,199 @@
+package org.koitharu.kotatsu.parsers.site.en
+
+import kotlinx.coroutines.coroutineScope
+import okhttp3.Headers
+import org.jsoup.nodes.Document
+import org.koitharu.kotatsu.parsers.MangaLoaderContext
+import org.koitharu.kotatsu.parsers.MangaSourceParser
+import org.koitharu.kotatsu.parsers.PagedMangaParser
+import org.koitharu.kotatsu.parsers.config.ConfigKey
+import org.koitharu.kotatsu.parsers.model.*
+import org.koitharu.kotatsu.parsers.network.UserAgents
+import org.koitharu.kotatsu.parsers.util.*
+import org.koitharu.kotatsu.parsers.util.json.mapJSON
+import java.text.SimpleDateFormat
+import java.util.*
+
+@MangaSourceParser("MANGAOWL", "Mangaowl", "en")
+internal class Mangaowl(context: MangaLoaderContext) :
+	PagedMangaParser(context, MangaSource.MANGAOWL, pageSize = 24) {
+
+	override val sortOrders: Set<SortOrder> = EnumSet.of(
+		SortOrder.POPULARITY,
+		SortOrder.NEWEST,
+		SortOrder.UPDATED,
+		SortOrder.RATING,
+	)
+
+	override val configKeyDomain = ConfigKey.Domain("mangaowl.to")
+
+	override val headers: Headers = Headers.Builder()
+		.add("User-Agent", UserAgents.CHROME_DESKTOP)
+		.build()
+
+	override suspend fun getListPage(
+		page: Int,
+		query: String?,
+		tags: Set<MangaTag>?,
+		sortOrder: SortOrder,
+	): List<Manga> {
+		val sort = when (sortOrder) {
+			SortOrder.POPULARITY -> "view_count"
+			SortOrder.UPDATED -> "-modified_at"
+			SortOrder.NEWEST -> "created_at"
+			SortOrder.RATING -> "rating"
+			else -> "modified_at"
+		}
+		val url = buildString {
+			append("https://")
+			append(domain)
+			when {
+				!query.isNullOrEmpty() -> {
+					append("/8-search")
+					append("?q=")
+					append(query.urlEncoded())
+					append("&page=")
+					append(page.toString())
+				}
+
+				!tags.isNullOrEmpty() -> {
+					append("/8-genres/")
+					for (tag in tags) {
+						append(tag.key)
+					}
+					append("?page=")
+					append(page.toString())
+				}
+
+				else -> {
+
+					append("/8-comics")
+					append("?page=")
+					append(page.toString())
+					append("&ordering=")
+					append(sort)
+				}
+			}
+		}
+		val doc = webClient.httpGet(url).parseHtml()
+		return doc.select("div.manga-item.column").map { div ->
+			val href = div.selectFirstOrThrow("a").attrAsRelativeUrl("href")
+			Manga(
+				id = generateUid(href),
+				url = href,
+				publicUrl = href.toAbsoluteUrl(div.host ?: domain),
+				coverUrl = div.selectFirst("img")?.src().orEmpty(),
+				title = div.selectFirst("a.one-line")?.text().orEmpty(),
+				altTitle = null,
+				rating = div.select("span").last()?.text()?.toFloatOrNull()?.div(5f) ?: RATING_UNKNOWN,
+				tags = emptySet(),
+				author = null,
+				state = null,
+				source = source,
+				isNsfw = false,
+			)
+		}
+	}
+
+	override suspend fun getTags(): Set<MangaTag> {
+		val doc = webClient.httpGet("https://$domain/8-genres").parseHtml()
+		return doc.select("div.genres-container span.genre-item a").mapNotNullToSet { a ->
+			val key = a.attr("href").substringAfterLast("/")
+			MangaTag(
+				key = key,
+				title = a.text(),
+				source = source,
+			)
+		}
+	}
+
+	override suspend fun getDetails(manga: Manga): Manga = coroutineScope {
+		val fullUrl = manga.url.toAbsoluteUrl(domain)
+		val doc = webClient.httpGet(fullUrl).parseHtml()
+		manga.copy(
+			tags = doc.body().select("div.comic-attrs div.column.my-2:contains(Genres) a").mapNotNullToSet { a ->
+				MangaTag(
+					key = a.attr("href").removeSuffix("/").substringAfterLast('/'),
+					title = a.text().toTitleCase().replace(",", ""),
+					source = source,
+				)
+			},
+			description = doc.select("span.story-desc").html(),
+			state = when (doc.select("div.section-status:contains(Status) span").last()?.text()) {
+				"Ongoing" -> MangaState.ONGOING
+				"Completed" -> MangaState.FINISHED
+				else -> null
+			},
+			chapters = getChapters(manga.url, doc),
+		)
+	}
+
+	private fun getChapters(mangaUrl: String, doc: Document): List<MangaChapter> {
+
+		val dateFormat = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSSSS'Z'", sourceLocale)
+
+		val script = doc.selectFirstOrThrow("script:containsData(chapters:)")
+		val json =
+			script.data().substringAfter("chapters:[").substringBeforeLast(')').substringBefore("],latest_chapter:")
+				.split("},")
+		val slug = mangaUrl.substringAfterLast("/")
+
+		val chapter = ArrayList<MangaChapter>()
+		val num = 0
+		json.map { t ->
+			if (t.contains("Chapter")) {
+				val id = t.substringAfter("id:").substringBefore(",created_at")
+				val url = "/reading/$slug/$id"
+
+				val date = t.substringAfter("created_at:\"").substringBefore("\"")
+				val name = t.substringAfter("name:\"").substringBefore("\"")
+				chapter.add(
+					MangaChapter(
+						id = generateUid(url),
+						name = name,
+						number = num + 1,
+						url = url,
+						uploadDate = dateFormat.tryParse(date),
+						source = source,
+						scanlator = null,
+						branch = null,
+					),
+				)
+			}
+		}
+
+		// last chapter
+		val id = script.data().substringAfter("Sign in\",").substringBefore(",\"").split(",").last()
+		val url = "/reading/$slug/$id"
+		val date = script.data().substringAfter("$id,\"").substringBefore("\",")
+		val name = script.data().substringAfter("$date\",\"").substringBefore("\",")
+		chapter.add(
+			MangaChapter(
+				id = generateUid(url),
+				name = name,
+				number = num + 1,
+				url = url,
+				uploadDate = dateFormat.tryParse(date),
+				source = source,
+				scanlator = null,
+				branch = null,
+			),
+		)
+
+		return chapter
+	}
+
+	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
+		val id = chapter.url.substringAfterLast("/")
+
+		val json = webClient.httpGet("https://api.mangaowl.to/v1/chapters/$id/images?page_size=100").parseJson()
+		return json.getJSONArray("results").mapJSON { jo ->
+			MangaPage(
+				id = generateUid(jo.getString("image")),
+				preview = null,
+				source = chapter.source,
+				url = jo.getString("image"),
+			)
+		}
+	}
+}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/en/TempleScan.kt

@@ -0,0 +1,133 @@
+package org.koitharu.kotatsu.parsers.site.en
+
+import kotlinx.coroutines.coroutineScope
+import okhttp3.Headers
+import org.jsoup.nodes.Document
+import org.koitharu.kotatsu.parsers.MangaLoaderContext
+import org.koitharu.kotatsu.parsers.MangaSourceParser
+import org.koitharu.kotatsu.parsers.PagedMangaParser
+import org.koitharu.kotatsu.parsers.config.ConfigKey
+import org.koitharu.kotatsu.parsers.model.*
+import org.koitharu.kotatsu.parsers.network.UserAgents
+import org.koitharu.kotatsu.parsers.util.*
+import java.util.*
+
+@MangaSourceParser("TEMPLESCAN", "TempleScan", "en")
+internal class TempleScan(context: MangaLoaderContext) :
+	PagedMangaParser(context, MangaSource.TEMPLESCAN, pageSize = 15) {
+
+	override val sortOrders: Set<SortOrder> = EnumSet.of(SortOrder.NEWEST, SortOrder.UPDATED)
+
+	override val configKeyDomain = ConfigKey.Domain("templescan.net")
+
+	override val headers: Headers = Headers.Builder()
+		.add("User-Agent", UserAgents.CHROME_DESKTOP)
+		.build()
+
+	override suspend fun getListPage(
+		page: Int,
+		query: String?,
+		tags: Set<MangaTag>?,
+		sortOrder: SortOrder,
+	): List<Manga> {
+		val url = buildString {
+			append("https://")
+			append(domain)
+			if (sortOrder == SortOrder.NEWEST) {
+				append("/comics")
+				append("?page=")
+				append(page.toString())
+			} else {
+				if (page > 1) {
+					return emptyList()
+				}
+			}
+		}
+
+		val doc = webClient.httpGet(url).parseHtml()
+		return doc.select("div.grid figure").ifEmpty {
+			doc.requireElementById("projectsDiv").select("figure")
+		}.map { div ->
+			val href = div.selectFirstOrThrow("a").attrAsRelativeUrl("href")
+			Manga(
+				id = generateUid(href),
+				url = href,
+				publicUrl = href.toAbsoluteUrl(div.host ?: domain),
+				coverUrl = div.selectFirst("img")?.src().orEmpty(),
+				title = div.selectFirst("figcaption")?.text().orEmpty(),
+				altTitle = null,
+				rating = RATING_UNKNOWN,
+				tags = emptySet(),
+				author = null,
+				state = null,
+				source = source,
+				isNsfw = false,
+			)
+		}
+	}
+
+	override suspend fun getTags(): Set<MangaTag> = emptySet()
+
+	override suspend fun getDetails(manga: Manga): Manga = coroutineScope {
+		val fullUrl = manga.url.toAbsoluteUrl(domain)
+		val doc = webClient.httpGet(fullUrl).parseHtml()
+		val chaptersDeferred = getChapters(doc)
+		manga.copy(
+			description = doc.requireElementById("section-sinopsis").html(),
+			chapters = chaptersDeferred,
+			isNsfw = false,
+		)
+	}
+
+	private fun getChapters(doc: Document): List<MangaChapter> {
+		return doc.body().select("div.grid-capitulos div.contenedor-capitulo-miniatura")
+			.mapChapters(reversed = true) { i, div ->
+				val href = div.selectFirstOrThrow("a").attrAsRelativeUrl("href")
+				val date = parseUploadDate(div.selectFirstOrThrow("time").text())
+				MangaChapter(
+					id = generateUid(href),
+					name = div.requireElementById("name").text(),
+					number = i + 1,
+					url = href,
+					uploadDate = date,
+					source = source,
+					scanlator = null,
+					branch = null,
+				)
+			}
+	}
+
+	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
+		val fullUrl = chapter.url.toAbsoluteUrl(domain)
+		val doc = webClient.httpGet(fullUrl).parseHtml()
+		return doc.select("main.contenedor-imagen img").map { url ->
+			val img = url.src()?.toRelativeUrl(domain) ?: url.parseFailed("Image src not found")
+			MangaPage(
+				id = generateUid(img),
+				url = img,
+				preview = null,
+				source = source,
+			)
+		}
+	}
+
+	private fun parseUploadDate(timeStr: String?): Long {
+		timeStr ?: return 0
+		val timeWords = timeStr.split(' ')
+		if (timeWords.size != 3) return 0
+		val timeWord = timeWords[1]
+		val timeAmount = timeWords[0].toIntOrNull() ?: return 0
+		val timeUnit = when (timeWord) {
+			"minute", "minutes" -> Calendar.MINUTE
+			"hour", "hours" -> Calendar.HOUR
+			"day", "days" -> Calendar.DAY_OF_YEAR
+			"week", "weeks" -> Calendar.WEEK_OF_YEAR
+			"month", "months" -> Calendar.MONTH
+			"year", "years" -> Calendar.YEAR
+			else -> return 0
+		}
+		val cal = Calendar.getInstance()
+		cal.add(timeUnit, -timeAmount)
+		return cal.time.time
+	}
+}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/fr/BentomangaParser.kt

@@ -116,7 +116,7 @@ internal class BentomangaParser(context: MangaLoaderContext) : PagedMangaParser(
 					coroutineScope {
 						val result = ArrayList(parseChapters(root))
 						result.ensureCapacity(result.size * max)
-						(2..max).map { i ->
+						(1..max).map { i ->
 							async {
 								loadChapters(mangaUrl, i)
 							}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/fr/FuryoSociety.kt

@@ -0,0 +1,158 @@
+package org.koitharu.kotatsu.parsers.site.fr
+
+import kotlinx.coroutines.coroutineScope
+import okhttp3.Headers
+import org.jsoup.nodes.Document
+import org.koitharu.kotatsu.parsers.MangaLoaderContext
+import org.koitharu.kotatsu.parsers.MangaSourceParser
+import org.koitharu.kotatsu.parsers.PagedMangaParser
+import org.koitharu.kotatsu.parsers.config.ConfigKey
+import org.koitharu.kotatsu.parsers.model.*
+import org.koitharu.kotatsu.parsers.network.UserAgents
+import org.koitharu.kotatsu.parsers.util.*
+import java.text.DateFormat
+import java.text.SimpleDateFormat
+import java.util.*
+
+@MangaSourceParser("FURYOSOCIETY", "Furyo Society", "fr")
+internal class FuryoSociety(context: MangaLoaderContext) :
+	PagedMangaParser(context, MangaSource.FURYOSOCIETY, 0) {
+
+	override val sortOrders: Set<SortOrder> = EnumSet.of(SortOrder.ALPHABETICAL, SortOrder.UPDATED)
+
+	override val configKeyDomain = ConfigKey.Domain("furyosociety.com")
+
+	override val headers: Headers = Headers.Builder()
+		.add("User-Agent", UserAgents.CHROME_DESKTOP)
+		.build()
+
+	override suspend fun getFavicons(): Favicons {
+		return Favicons(
+			listOf(
+				Favicon("https://$domain/fs_favicon/favicon-32x32.png", 32, null),
+			),
+			domain,
+		)
+	}
+
+	override suspend fun getListPage(
+		page: Int,
+		query: String?,
+		tags: Set<MangaTag>?,
+		sortOrder: SortOrder,
+	): List<Manga> {
+		val url = buildString {
+			append("https://")
+			append(domain)
+			if (page == 1) {
+				if (sortOrder == SortOrder.ALPHABETICAL) {
+					append("/mangas")
+				}
+			} else {
+				return emptyList()
+			}
+		}
+
+		val doc = webClient.httpGet(url).parseHtml()
+		return doc.select("div.fs-card-container div.grid-item-container").ifEmpty {
+			doc.select("div.container-tight.latest table tr")
+		}.map { div ->
+			val href = div.selectFirstOrThrow("a").attrAsRelativeUrl("href")
+			Manga(
+				id = generateUid(href),
+				url = href,
+				publicUrl = href.toAbsoluteUrl(div.host ?: domain),
+				coverUrl = div.selectFirst("img")?.src().orEmpty(),
+				title = (div.selectFirst("div.media-body") ?: div.selectFirst("a"))?.text().orEmpty(),
+				altTitle = null,
+				rating = RATING_UNKNOWN,
+				tags = emptySet(),
+				author = null,
+				state = null,
+				source = source,
+				isNsfw = false,
+			)
+		}
+	}
+
+
+	override suspend fun getTags(): Set<MangaTag> = emptySet()
+
+
+	override suspend fun getDetails(manga: Manga): Manga = coroutineScope {
+		val fullUrl = manga.url.toAbsoluteUrl(domain)
+		val doc = webClient.httpGet(fullUrl).parseHtml()
+		val chaptersDeferred = getChapters(doc)
+		manga.copy(
+			description = doc.selectFirstOrThrow("div.fs-comic-description").html(),
+			chapters = chaptersDeferred,
+			isNsfw = doc.selectFirst(".adult-text") != null,
+		)
+	}
+
+
+	private fun getChapters(doc: Document): List<MangaChapter> {
+		return doc.body().select("div.list.fs-chapter-list div.element").mapChapters(reversed = true) { i, div ->
+			val a = div.selectFirstOrThrow("div.title a")
+			val href = a.attrAsRelativeUrl("href")
+			val dateFormat = SimpleDateFormat("dd/MM/yyyy", sourceLocale)
+			val dateText = div.selectFirstOrThrow("div.meta_r").text().replace("Hier", "1 jour")
+			MangaChapter(
+				id = generateUid(href),
+				name = div.selectFirstOrThrow("div.title").text() + " : " + div.selectFirstOrThrow("div.name").text(),
+				number = i + 1,
+				url = href,
+				uploadDate = parseChapterDate(
+					dateFormat,
+					dateText,
+				),
+				source = source,
+				scanlator = null,
+				branch = null,
+			)
+		}
+	}
+
+	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
+		val fullUrl = chapter.url.toAbsoluteUrl(domain)
+		val doc = webClient.httpGet(fullUrl).parseHtml()
+		return doc.select("div.main-img img").map { url ->
+			val img = url.src()?.toRelativeUrl(domain) ?: url.parseFailed("Image src not found")
+			MangaPage(
+				id = generateUid(img),
+				url = img,
+				preview = null,
+				source = source,
+			)
+		}
+	}
+
+	private fun parseChapterDate(dateFormat: DateFormat, date: String?): Long {
+		val d = date?.lowercase() ?: return 0
+		return when {
+			d.startsWith("il y a") || // Handle translated 'ago' in French.
+					d.endsWith(" an") || d.endsWith(" ans") ||
+					d.endsWith(" mois") ||
+					d.endsWith(" jour") || d.endsWith(" jours") ||
+					d.endsWith(" heure") || d.endsWith(" heures") ||
+					d.endsWith(" seconde") || d.endsWith(" secondes") ||
+					d.endsWith(" minute") || d.endsWith(" minutes") -> parseRelativeDate(date)
+
+			else -> dateFormat.tryParse(date)
+		}
+	}
+
+	private fun parseRelativeDate(date: String): Long {
+		val number = Regex("""(\d+)""").find(date)?.value?.toIntOrNull() ?: return 0
+		val cal = Calendar.getInstance()
+		return when {
+			WordSet("seconde", "secondes").anyWordIn(date) -> cal.apply { add(Calendar.SECOND, -number) }.timeInMillis
+			WordSet("minute", "minutes").anyWordIn(date) -> cal.apply { add(Calendar.MINUTE, -number) }.timeInMillis
+			WordSet("heure", "heures").anyWordIn(date) -> cal.apply { add(Calendar.HOUR, -number) }.timeInMillis
+			WordSet("jour", "jours").anyWordIn(date) -> cal.apply { add(Calendar.DAY_OF_MONTH, -number) }.timeInMillis
+			WordSet("mois").anyWordIn(date) -> cal.apply { add(Calendar.MONTH, -number) }.timeInMillis
+			WordSet("an", "ans").anyWordIn(date) -> cal.apply { add(Calendar.YEAR, -number) }.timeInMillis
+			else -> 0
+		}
+	}
+}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/MadaraParser.kt

@@ -97,6 +97,7 @@ internal abstract class MadaraParser(
 	@JvmField
 	protected val finished: Set<String> = hashSetOf(
 		"Completed",
+		"Complete",
 		"Completo",
 		"Complété",
 		"Fini",
@@ -108,6 +109,7 @@ internal abstract class MadaraParser(
 		"Hoàn Thành",
 		"مكتملة",
 		"Завершено",
+		"Завершен",
 		"Finished",
 		"Finalizado",
 		"Completata",
@@ -211,7 +213,8 @@ internal abstract class MadaraParser(
 				url = href,
 				publicUrl = href.toAbsoluteUrl(div.host ?: domain),
 				coverUrl = div.selectFirst("img")?.src().orEmpty(),
-				title = (summary?.selectFirst("h3") ?: summary?.selectFirst("h4"))?.text().orEmpty(),
+				title = (summary?.selectFirst("h3") ?: summary?.selectFirst("h4")
+				?: div.selectFirst(".manga-name"))?.text().orEmpty(),
 				altTitle = null,
 				rating = div.selectFirst("span.total_votes")?.ownText()?.toFloatOrNull()?.div(5f) ?: -1f,
 				tags = summary?.selectFirst(".mg_genres")?.select("a")?.mapNotNullToSet { a ->
@@ -384,6 +387,7 @@ internal abstract class MadaraParser(
 		}
 	}
 
+	protected open val selectBodyPage = "div.main-col-inner div.reading-content"
 	protected open val selectPage = "div.page-break"
 
 	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
@@ -392,7 +396,7 @@ internal abstract class MadaraParser(
 
 		val chapterProtector = doc.getElementById("chapter-protector-data")
 		if (chapterProtector == null) {
-			val root = doc.body().selectFirstOrThrow("div.main-col-inner").selectFirstOrThrow("div.reading-content")
+			val root = doc.body().selectFirstOrThrow(selectBodyPage)
 			return root.select(selectPage).map { div ->
 				val img = div.selectFirstOrThrow("img")
 				val url = img.src()?.toRelativeUrl(domain) ?: div.parseFailed("Image src not found")

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/Azoranov.kt

@@ -9,6 +9,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 @MangaSourceParser("AZORANOV", "Azoranov", "ar")
 internal class Azoranov(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.AZORANOV, "azoranov.com", pageSize = 10) {
-
+	override val tagPrefix = "series-genre/"
-	override val tagPrefix = "novel-genre/"
+	override val listUrl = "series/"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/GateManga.kt

@@ -12,4 +12,5 @@ internal class GateManga(context: MangaLoaderContext) :
 
 	override val postreq = true
 	override val datePattern = "d MMMM، yyyy"
+	override val listUrl = "ar/"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ar/WebtoonEmpire.kt

@@ -9,5 +9,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 internal class WebtoonEmpire(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.WEBTOONEMPIRE, "webtoonempire.org", pageSize = 10) {
 
+	override val listUrl = "webtoon/"
 	override val datePattern = "d MMMM yyyy"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/BestManhuaCom.kt

@@ -0,0 +1,125 @@
+package org.koitharu.kotatsu.parsers.site.madara.en
+
+import org.koitharu.kotatsu.parsers.MangaLoaderContext
+import org.koitharu.kotatsu.parsers.MangaSourceParser
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaChapter
+import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.model.MangaTag
+import org.koitharu.kotatsu.parsers.model.SortOrder
+import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
+import org.koitharu.kotatsu.parsers.util.*
+
+@MangaSourceParser("BESTMANHUACOM", "BestManhua Com", "en")
+internal class BestManhuaCom(context: MangaLoaderContext) :
+	MadaraParser(context, MangaSource.BESTMANHUACOM, "bestmanhua.com", 20) {
+	override val datePattern = "dd MMMM yyyy"
+	override val tagPrefix = "genres/"
+	override val listUrl = "all-manga/"
+	override val withoutAjax = true
+	override val selectDesc = "div.dsct"
+	override val selectTestAsync = "div.panel-manga-chapter"
+	override val selectDate = "span.chapter-time"
+	override val selectChapter = "li.a-h"
+	override val selectBodyPage = "div.manga-content div.read-content"
+	override val selectPage = "div.image-placeholder"
+
+	override suspend fun getListPage(
+		page: Int,
+		query: String?,
+		tags: Set<MangaTag>?,
+		sortOrder: SortOrder,
+	): List<Manga> {
+
+		val url = buildString {
+			append("https://")
+			append(domain)
+			val pages = page + 1
+			when {
+				!query.isNullOrEmpty() -> {
+					append("/page/")
+					append(pages.toString())
+					append("/?s=")
+					append(query.urlEncoded())
+					append("&post_type=wp-manga&")
+				}
+
+				!tags.isNullOrEmpty() -> {
+					append("/$tagPrefix")
+					for (tag in tags) {
+						append(tag.key)
+					}
+					append("/")
+					append(pages.toString())
+					append("?")
+				}
+
+				else -> {
+					append("/$listUrl")
+					append(pages.toString())
+					append("?")
+				}
+			}
+			append("sort=")
+			when (sortOrder) {
+				SortOrder.POPULARITY -> append("most-viewd")
+				SortOrder.UPDATED -> append("latest-updated")
+				SortOrder.NEWEST -> append("release-date")
+				SortOrder.ALPHABETICAL -> append("name-az")
+				else -> append("latest")
+			}
+		}
+		val doc = webClient.httpGet(url).parseHtml()
+
+		return doc.select("div.page-item").map { div ->
+			val href = div.selectFirst("a")?.attrAsRelativeUrlOrNull("href") ?: div.parseFailed("Link not found")
+			val summary = div.selectFirstOrThrow(".bigor-manga")
+			Manga(
+				id = generateUid(href),
+				url = href,
+				publicUrl = href.toAbsoluteUrl(div.host ?: domain),
+				coverUrl = div.selectFirst("img")?.src().orEmpty(),
+				title = summary.selectFirst("h3")?.text().orEmpty(),
+				altTitle = null,
+				rating = div.selectFirstOrThrow("div.item-rate span").ownText().toFloatOrNull()?.div(5f) ?: -1f,
+				tags = emptySet(),
+				author = null,
+				state = null,
+				source = source,
+				isNsfw = isNsfwSource,
+			)
+		}
+	}
+
+	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
+		val fullUrl = chapter.url.toAbsoluteUrl(domain)
+		val doc = webClient.httpGet(fullUrl).parseHtml()
+
+		val chapterId =
+			doc.selectFirst("script:containsData(chapter_id = )")?.toString()?.substringAfter("chapter_id = ")
+				?.substringBefore(",")
+
+		val json =
+			webClient.httpGet("https://$domain/ajax/image/list/chap/$chapterId?mode=vertical&quality=high").parseJson()
+
+		val html = json.getString("html").split("/div>")
+
+		val pages = ArrayList<MangaPage>()
+
+		html.map { t ->
+			if (t.contains("data-src=")) {
+				val url = t.substringAfter("data-src=\"").substringBefore("\"")
+				pages.add(
+					MangaPage(
+						id = generateUid(url),
+						url = url,
+						preview = null,
+						source = source,
+					),
+				)
+			}
+		}
+		return pages
+	}
+}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/BoysLove.kt

@@ -11,5 +11,6 @@ internal class BoysLove(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.BOYS_LOVE, "boyslove.me", 20) {
 
 	override val tagPrefix = "boyslove-genre/"
+	override val listUrl = "boyslove/"
 	override val postreq = true
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/DarkScans.kt

@@ -7,4 +7,7 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 
 @MangaSourceParser("DARK_SCANS", "DarkScans", "en")
 internal class DarkScans(context: MangaLoaderContext) :
-	MadaraParser(context, MangaSource.DARK_SCANS, "darkscans.com", 18)
+	MadaraParser(context, MangaSource.DARK_SCANS, "darkscans.com", 18) {
+	override val listUrl = "mangas/"
+	override val tagPrefix = "mangas-genre/"
+}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/DrakeScans.kt

@@ -11,4 +11,5 @@ internal class DrakeScans(context: MangaLoaderContext) :
 
 	override val datePattern = "dd/MM/yyyy"
 	override val tagPrefix = "series-genre/"
+	override val listUrl = "series/"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/FreeWebtoonCoins.kt

@@ -10,4 +10,5 @@ internal class FreeWebtoonCoins(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.FREEWEBTOONCOINS, "freewebtooncoins.com") {
 
 	override val tagPrefix = "webtoon-genre/"
+	override val listUrl = "webtoon/"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/GourmetScans.kt

@@ -5,10 +5,11 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 
-@MangaSourceParser("TEMPLESCAN", "TempleScan", "en")
+@MangaSourceParser("GOURMETSCANS", "Gourmet Scans", "en")
-internal class TempleScan(context: MangaLoaderContext) :
+internal class GourmetScans(context: MangaLoaderContext) :
-	MadaraParser(context, MangaSource.TEMPLESCAN, "templescan.net") {
+	MadaraParser(context, MangaSource.GOURMETSCANS, "gourmetscans.net") {
 
-	override val datePattern = "dd.MM.yyyy"
+	override val listUrl = "project/"
 	override val tagPrefix = "genre/"
+	override val stylepage = ""
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Grabber.kt

@@ -10,5 +10,6 @@ internal class Grabber(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.GRABBER, "grabber.zone", 20) {
 
 	override val tagPrefix = "type/"
+	override val listUrl = "comics/"
 	override val datePattern = "dd.MM.yyyy"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/HManhwa.kt

@@ -11,7 +11,7 @@ internal class HManhwa(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.HMANHWA, "hmanhwa.com") {
 
 	override val tagPrefix = "manhwa-genre/"
+	override val listUrl = "manhwa/"
 	override val datePattern = "dd MMM"
 	override val postreq = true
-
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Hentai4Free.kt

@@ -4,14 +4,106 @@ package org.koitharu.kotatsu.parsers.site.madara.en
 import org.koitharu.kotatsu.parsers.MangaLoaderContext
 import org.koitharu.kotatsu.parsers.MangaSourceParser
 import org.koitharu.kotatsu.parsers.model.ContentType
+import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.model.MangaState
+import org.koitharu.kotatsu.parsers.model.MangaTag
+import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
+import org.koitharu.kotatsu.parsers.util.*
 
 @MangaSourceParser("HENTAI_4FREE", "Hentai4Free", "en", ContentType.HENTAI)
 internal class Hentai4Free(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.HENTAI_4FREE, "hentai4free.net", pageSize = 24) {
 
 	override val tagPrefix = "hentai-tag/"
+	override val listUrl = ""
+	override val withoutAjax = true
 	override val datePattern = "MMMM dd, yyyy"
 
+
+	override suspend fun getListPage(
+		page: Int,
+		query: String?,
+		tags: Set<MangaTag>?,
+		sortOrder: SortOrder,
+	): List<Manga> {
+		val url = buildString {
+			append("https://")
+			append(domain)
+			val pages = page + 1
+			when {
+				!query.isNullOrEmpty() -> {
+					append("/page/")
+					append(pages.toString())
+					append("/?s=")
+					append(query.urlEncoded())
+					append("&post_type=wp-manga&")
+				}
+
+				!tags.isNullOrEmpty() -> {
+					append("/$tagPrefix")
+					for (tag in tags) {
+						append(tag.key)
+					}
+					append("/")
+					if (pages > 1) {
+						append("page/")
+						append(pages.toString())
+					}
+				}
+
+				else -> {
+
+					if (pages > 1) {
+						append("/page/")
+						append(pages.toString())
+					}
+					append("/?m_orderby=")
+					when (sortOrder) {
+						SortOrder.POPULARITY -> append("views")
+						SortOrder.UPDATED -> append("latest")
+						SortOrder.NEWEST -> append("new-manga")
+						SortOrder.ALPHABETICAL -> append("alphabet")
+						else -> append("latest")
+					}
+				}
+			}
+
+		}
+		val doc = webClient.httpGet(url).parseHtml()
+
+		return doc.select("div.row.c-tabs-item__content").ifEmpty {
+			doc.select("div.page-item-detail")
+		}.map { div ->
+			val href = div.selectFirst("a")?.attrAsRelativeUrlOrNull("href") ?: div.parseFailed("Link not found")
+			val summary = div.selectFirst(".tab-summary") ?: div.selectFirst(".item-summary")
+			Manga(
+				id = generateUid(href),
+				url = href,
+				publicUrl = href.toAbsoluteUrl(div.host ?: domain),
+				coverUrl = div.selectFirst("img")?.src().orEmpty(),
+				title = (summary?.selectFirst("h3") ?: summary?.selectFirst("h4")
+				?: div.selectFirst(".manga-name"))?.text().orEmpty(),
+				altTitle = null,
+				rating = div.selectFirst("span.total_votes")?.ownText()?.toFloatOrNull()?.div(5f) ?: -1f,
+				tags = summary?.selectFirst(".mg_genres")?.select("a")?.mapNotNullToSet { a ->
+					MangaTag(
+						key = a.attr("href").removeSuffix('/').substringAfterLast('/'),
+						title = a.text().ifEmpty { return@mapNotNullToSet null }.toTitleCase(),
+						source = source,
+					)
+				}.orEmpty(),
+				author = summary?.selectFirst(".mg_author")?.selectFirst("a")?.ownText(),
+				state = when (summary?.selectFirst(".mg_status")?.selectFirst(".summary-content")?.ownText()
+					?.lowercase()) {
+					in ongoing -> MangaState.ONGOING
+					in finished -> MangaState.FINISHED
+					else -> null
+				},
+				source = source,
+				isNsfw = isNsfwSource,
+			)
+		}
+	}
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ImmortalUpdates.kt

@@ -7,4 +7,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 
 @MangaSourceParser("IMMORTALUPDATES", "Immortal Updates", "en")
 internal class ImmortalUpdates(context: MangaLoaderContext) :
-	MadaraParser(context, MangaSource.IMMORTALUPDATES, "immortalupdates.com")
+	MadaraParser(context, MangaSource.IMMORTALUPDATES, "immortalupdates.com") {
+	override val listUrl = "mangas/"
+}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/IsekaiScan.kt

@@ -14,6 +14,7 @@ internal class IsekaiScan(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.ISEKAISCAN, "isekaiscan.top", 16) {
 
 	override val tagPrefix = "mangas/"
+	override val listUrl = "latest-manga/"
 	override val datePattern = "MMMM d, HH:mm"
 
 	override val sortOrders: Set<SortOrder> = EnumSet.of(
@@ -67,6 +68,9 @@ internal class IsekaiScan(context: MangaLoaderContext) :
 			}
 		}
 		val doc = webClient.httpGet(url).parseHtml()
+		if (url != "ursdvsdvl") {
+			throw Exception(doc.toString())
+		}
 		return doc.select("div.row.c-tabs-item__content").ifEmpty {
 			doc.select("div.page-item-detail.manga")
 		}.map { div ->

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/KissManga.kt

@@ -8,4 +8,5 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 @MangaSourceParser("KISSMANGA", "KissManga", "en")
 internal class KissManga(context: MangaLoaderContext) : MadaraParser(context, MangaSource.KISSMANGA, "kissmanga.in") {
 	override val datePattern = "MMMM dd, yyyy"
+	override val listUrl = "mangalist/"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/LilyManga.kt

@@ -11,5 +11,6 @@ internal class LilyManga(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.LILYMANGA, "lilymanga.net") {
 
 	override val tagPrefix = "ys-genre/"
+	override val listUrl = "ys/"
 	override val datePattern = "yyyy-MM-dd"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaBaz.kt

@@ -7,4 +7,7 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 
 @MangaSourceParser("MANGABAZ", "MangaBaz", "en")
 internal class MangaBaz(context: MangaLoaderContext) :
-	MadaraParser(context, MangaSource.MANGABAZ, "mangabaz.net")
+	MadaraParser(context, MangaSource.MANGABAZ, "mangabaz.net") {
+	override val listUrl = "all-series/"
+	override val tagPrefix = "mangas-genre/"
+}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaDistrict.kt

@@ -17,7 +17,6 @@ internal class MangaDistrict(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.MANGA_DISTRICT, "mangadistrict.com", pageSize = 30) {
 
 	override val tagPrefix = "publication-genre/"
-
 	override val datePattern = "MMM dd,yyyy"
 
 	override suspend fun getChapters(manga: Manga, doc: Document): List<MangaChapter> {

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaHentai.kt

@@ -11,4 +11,5 @@ internal class MangaHentai(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.MANGAHENTAI, "mangahentai.me", 20) {
 
 	override val tagPrefix = "manga-hentai-genre/"
+	override val listUrl = "manga-hentai/"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/MangaLeveling.kt

@@ -11,6 +11,6 @@ internal class MangaLeveling(context: MangaLoaderContext) :
 
 	override val postreq = true
 	override val tagPrefix = "comics-genre/"
+	override val listUrl = "comics/"
 	override val datePattern = "MM/dd/yyyy"
-
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuamix.kt

@@ -10,4 +10,5 @@ internal class Manhuamix(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.MANHUAMIX, "manhuamix.com", 20) {
 
 	override val tagPrefix = "manhua-genre/"
+	override val listUrl = "manhua/"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Manhuasy.kt

@@ -11,5 +11,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 internal class Manhuasy(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.MANHUASY, "www.manhuasy.com") {
 
+	override val listUrl = "manhua/"
 	override val tagPrefix = "manhua-genre/"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhwaFull.kt

@@ -9,5 +9,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 internal class ManhwaFull(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.MANHWAFULL, "manhwafull.com") {
 
+	override val listUrl = "manga-all-manhwa/"
 	override val datePattern = "MM/dd/yyyy"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManhwaHentai.kt

@@ -11,4 +11,5 @@ internal class ManhwaHentai(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.MANHWAHENTAI, "manhwahentai.me", 20) {
 
 	override val tagPrefix = "webtoon-genre/"
+	override val listUrl = "webtoon/"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManyToon.kt

@@ -8,4 +8,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 
 @MangaSourceParser("MANYTOON", "Many Toon", "en", ContentType.HENTAI)
 internal class ManyToon(context: MangaLoaderContext) :
-	MadaraParser(context, MangaSource.MANYTOON, "manytoon.com", 20)
+	MadaraParser(context, MangaSource.MANYTOON, "manytoon.com", 20) {
+	override val listUrl = "comic/"
+}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ManyToonMe.kt

@@ -8,4 +8,7 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 
 @MangaSourceParser("MANYTOONME", "Many Toon Me", "en", ContentType.HENTAI)
 internal class ManyToonMe(context: MangaLoaderContext) :
-	MadaraParser(context, MangaSource.MANYTOONME, "manytoon.me", 20)
+	MadaraParser(context, MangaSource.MANYTOONME, "manytoon.me", 20) {
+	override val listUrl = "manhwa/"
+	override val tagPrefix = "manhwa-genre/"
+}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ReadFreeComics.kt

@@ -11,4 +11,5 @@ internal class ReadFreeComics(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.READFREECOMICS, "readfreecomics.com") {
 
 	override val tagPrefix = "webtoon-comic-genre/"
+	override val listUrl = "webtoon-comic/"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/SleepyTranslations.kt

@@ -10,5 +10,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 internal class SleepyTranslations(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.SLEEPYTRANSLATIONS, "sleepytranslations.com", 16) {
 
+	override val listUrl = "series/"
 	override val tagPrefix = "genre/"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Toonily.kt

@@ -9,6 +9,7 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 internal class Toonily(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.TOONILY, "toonily.com", pageSize = 18) {
 
+	override val listUrl = "webtoon/"
 	override val tagPrefix = "webtoon-genre/"
 	override val datePattern = "MMMM dd, yyyy"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/WebtoonXyz.kt

@@ -12,5 +12,6 @@ internal class WebtoonXyz(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.WEBTOONXYZ, "www.webtoon.xyz", 20) {
 
 	override val tagPrefix = "webtoon-genre/"
+	override val listUrl = "read/"
 	override val datePattern = "d MMM yyyy"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Webtoons.kt

@@ -10,5 +10,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 internal class Webtoons(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.WEBTOONS, "webtoons.top", 20) {
 
+	override val listUrl = "read/"
 	override val postreq = true
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/Woopread.kt

@@ -9,5 +9,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 internal class Woopread(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.WOOPREAD, "woopread.com", 10) {
 
+	override val listUrl = "series/"
 	override val tagPrefix = "series-genres/"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/en/ZandynoFansub.kt

@@ -9,5 +9,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 internal class ZandynoFansub(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.ZANDYNOFANSUB, "zandynofansub.aishiteru.org", 20) {
 
+	override val listUrl = "series/"
 	override val datePattern = "dd.MM.yyyy"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/AiyuMangaScanlation.kt

@@ -5,9 +5,9 @@ import org.koitharu.kotatsu.parsers.MangaSourceParser
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 
-@MangaSourceParser("AIYUMANGASCANLATION", "AiyuMangaScanlation", "es")
+@MangaSourceParser("AIYUMANGASCANLATION", "Aiyu Manga", "es")
 internal class AiyuMangaScanlation(context: MangaLoaderContext) :
-	MadaraParser(context, MangaSource.AIYUMANGASCANLATION, "aiyumangascanlation.com") {
+	MadaraParser(context, MangaSource.AIYUMANGASCANLATION, "aiyumanga.com") {
-
 	override val datePattern = "MM/dd/yyyy"
+	override val listUrl = "series/"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/DoujinHentaiNet.kt

@@ -0,0 +1,40 @@
+package org.koitharu.kotatsu.parsers.site.madara.es
+
+import org.koitharu.kotatsu.parsers.MangaLoaderContext
+import org.koitharu.kotatsu.parsers.MangaSourceParser
+import org.koitharu.kotatsu.parsers.model.ContentType
+import org.koitharu.kotatsu.parsers.model.MangaChapter
+import org.koitharu.kotatsu.parsers.model.MangaPage
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
+import org.koitharu.kotatsu.parsers.util.*
+import java.util.Locale
+
+@MangaSourceParser("DOUJIN_HENTAI_NET", "Doujin Hentai Net", "es", ContentType.HENTAI)
+internal class DoujinHentaiNet(context: MangaLoaderContext) :
+	MadaraParser(context, MangaSource.DOUJIN_HENTAI_NET, "doujinhentai.net", 18) {
+	override val datePattern = "dd MMM. yyyy"
+	override val sourceLocale: Locale = Locale.ENGLISH
+	override val listUrl = "lista-manga-hentai/"
+	override val tagPrefix = "lista-manga-hentai/category/"
+	override val selectTestAsync = "div.listing-chapters_wrap"
+	override val selectChapter = "li.wp-manga-chapter:contains(Capitulo)"
+	override val selectPage = "div#all img"
+
+
+	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
+		val fullUrl = chapter.url.toAbsoluteUrl(domain)
+		val doc = webClient.httpGet(fullUrl).parseHtml()
+		return doc.select(selectPage).map { div ->
+			val img = div.selectFirstOrThrow("img")
+			val url = img.src()?.toRelativeUrl(domain) ?: div.parseFailed("Image src not found")
+			MangaPage(
+				id = generateUid(url),
+				url = url,
+				preview = null,
+				source = source,
+			)
+		}
+	}
+
+}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/MangaMundoDrama.kt

@@ -7,4 +7,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 
 @MangaSourceParser("MANGAMUNDODRAMA", "Manga Mundo Drama", "es")
 internal class MangaMundoDrama(context: MangaLoaderContext) :
-	MadaraParser(context, MangaSource.MANGAMUNDODRAMA, "inmortalscan.com")
+	MadaraParser(context, MangaSource.MANGAMUNDODRAMA, "manga.mundodrama.site") {
+	override val listUrl = "mg/"
+}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/es/RagnarokScan.kt

@@ -10,6 +10,6 @@ internal class RagnarokScan(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.RAGNAROKSCAN, "ragnarokscan.com") {
 
 	override val stylepage = ""
+	override val listUrl = "series/"
 	override val tagPrefix = "genero/"
-
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/FrScan.kt

@@ -7,4 +7,4 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 
 @MangaSourceParser("FRSCAN", "FrScan", "fr")
 internal class FrScan(context: MangaLoaderContext) :
-	MadaraParser(context, MangaSource.FRSCAN, "fr-scan.com")
+	MadaraParser(context, MangaSource.FRSCAN, "fr-scan.cc")

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/KaratcamScans.kt

@@ -10,5 +10,6 @@ internal class KaratcamScans(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.KARATCAMSCANS, "karatcam-scans.fr") {
 
 	override val tagPrefix = "webtoon-genre/"
+	override val listUrl = "webtoon/"
 	override val datePattern = "dd/MM/yyyy"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/MangasOrigines.kt

@@ -10,4 +10,6 @@ internal class MangasOrigines(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.MANGASORIGINES, "mangas-origines.fr") {
 
 	override val datePattern = "dd/MM/yyyy"
+	override val tagPrefix = "manga-genres/"
+	override val listUrl = "oeuvre/"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/fr/ToonFr.kt

@@ -15,6 +15,7 @@ internal class ToonFr(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.TOONFR, "toonfr.com") {
 
 	override val tagPrefix = "webtoon-genre/"
+	override val listUrl = "webtoon/"
 	override val datePattern = "MMM d"
 
 	override suspend fun loadChapters(mangaUrl: String, document: Document): List<MangaChapter> {

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/GourmetScansId.kt

@@ -0,0 +1,15 @@
+package org.koitharu.kotatsu.parsers.site.madara.id
+
+import org.koitharu.kotatsu.parsers.MangaLoaderContext
+import org.koitharu.kotatsu.parsers.MangaSourceParser
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
+
+@MangaSourceParser("GOURMETSCANS_ID", "Gourmet Scans Id", "id")
+internal class GourmetScansId(context: MangaLoaderContext) :
+	MadaraParser(context, MangaSource.GOURMETSCANS_ID, "id.gourmetscans.net") {
+
+	override val listUrl = "project/"
+	override val tagPrefix = "genre/"
+	override val stylepage = ""
+}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/Komiksay.kt

@@ -11,6 +11,7 @@ internal class Komiksay(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.KOMIKSA, "komiksay.site") {
 
 	override val tagPrefix = "komik-genre/"
+	override val listUrl = "komik/"
 	override val datePattern = "MMMM d"
 	override val sourceLocale: Locale = Locale.ENGLISH
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/Mgkomik.kt

@@ -11,6 +11,7 @@ internal class Mgkomik(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.MGKOMIK, "mgkomik.com", 20) {
 
 	override val tagPrefix = "genres/"
+	override val listUrl = "komik/"
 	override val datePattern = "dd MMM yy"
 	override val sourceLocale: Locale = Locale.ENGLISH
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/PojokManga.kt

@@ -11,6 +11,7 @@ internal class PojokManga(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.POJOKMANGA, "pojokmanga.net") {
 
 	override val tagPrefix = "komik-genre/"
+	override val listUrl = "komik/"
 	override val datePattern = "MMM d, yyyy"
 	override val sourceLocale: Locale = Locale.ENGLISH
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/id/Shinigami.kt

@@ -11,5 +11,6 @@ internal class Shinigami(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.SHINIGAMI, "shinigami.id", 10) {
 
 	override val tagPrefix = "genre/"
+	override val listUrl = "series/"
 	override val sourceLocale: Locale = Locale.ENGLISH
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/WickedWitchScan.kt

@@ -0,0 +1,13 @@
+package org.koitharu.kotatsu.parsers.site.madara.pt
+
+
+import org.koitharu.kotatsu.parsers.MangaLoaderContext
+import org.koitharu.kotatsu.parsers.MangaSourceParser
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
+
+@MangaSourceParser("WICKEDWITCHSCAN", "WickedWitch Scan", "pt")
+internal class WickedWitchScan(context: MangaLoaderContext) :
+	MadaraParser(context, MangaSource.WICKEDWITCHSCAN, "wickedwitchscan.com", pageSize = 10) {
+	override val postreq = true
+}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/pt/YugenMangas.kt

@@ -8,4 +8,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 
 @MangaSourceParser("YUGENMANGAS", "Yugen Mangas", "pt")
 internal class YugenMangas(context: MangaLoaderContext) :
-	MadaraParser(context, MangaSource.YUGENMANGAS, "yugenmangas.com.br", 10)
+	MadaraParser(context, MangaSource.YUGENMANGAS, "yugenmangas.com.br", 10) {
+	override val listUrl = "series/"
+}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ru/Mangazavr.kt

@@ -12,5 +12,6 @@ import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
 internal class Mangazavr(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.MANGAZAVR, "mangazavr.ru") {
 
+	override val listUrl = "/?s=&post_type=wp-manga"
 	override val datePattern = "dd.MM.yyyy"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Cizgiromanarsivi.kt

@@ -13,7 +13,6 @@ internal class Cizgiromanarsivi(context: MangaLoaderContext) :
 
 	override val stylepage = ""
 	override val tagPrefix = "kategori/"
+	override val listUrl = "seri/"
 	override val datePattern = "dd.MM.yyyy"
-
-
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/DiamondFansub.kt

@@ -12,5 +12,6 @@ internal class DiamondFansub(context: MangaLoaderContext) :
 	MadaraParser(context, MangaSource.DIAMONDFANSUB, "diamondfansub.com", 10) {
 
 	override val datePattern = "d MMMM"
+	override val listUrl = "seri/"
 	override val tagPrefix = "seri-turu/"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/tr/Mangabilgini.kt

@@ -1,17 +0,0 @@
-package org.koitharu.kotatsu.parsers.site.madara.tr
-
-
-import org.koitharu.kotatsu.parsers.MangaLoaderContext
-import org.koitharu.kotatsu.parsers.MangaSourceParser
-import org.koitharu.kotatsu.parsers.model.MangaSource
-import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
-
-
-@MangaSourceParser("MANGABILGINI", "Mangabilgini", "tr")
-internal class Mangabilgini(context: MangaLoaderContext) :
-	MadaraParser(context, MangaSource.MANGABILGINI, "mangabilgini.com", 44) {
-
-	override val selectDesc = "div.ozet__icerik"
-	override val postreq = true
-	override val datePattern = "d MMMM yyyy"
-}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt

@@ -5,7 +5,6 @@ import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import org.json.JSONObject
 import org.jsoup.nodes.Document
-import org.jsoup.nodes.Element
 import org.koitharu.kotatsu.parsers.MangaLoaderContext
 import org.koitharu.kotatsu.parsers.PagedMangaParser
 import org.koitharu.kotatsu.parsers.config.ConfigKey
@@ -126,8 +125,8 @@ internal abstract class MangaReaderParser(
 			?: docs.selectFirst(".tsinfo div:contains(Durum)")?.lastElementChild()?.text()
 
 		val nsfw = docs.selectFirst(".restrictcontainer") != null
-			|| docs.selectFirst(".info-right .alr") != null
+				|| docs.selectFirst(".info-right .alr") != null
-			|| docs.selectFirst(".postbody .alr") != null
+				|| docs.selectFirst(".postbody .alr") != null
 
 		return manga.copy(
 			description = docs.selectFirst("div.entry-content")?.text(),
@@ -193,6 +192,7 @@ internal abstract class MangaReaderParser(
 
 	protected open val selectMangalist = ".postbody .listupd .bs .bsx"
 	protected open val selectMangaListImg = "img.ts-post-image"
+	protected open val selectMangaListTitle = "div.tt"
 
 	protected open fun parseMangaList(docs: Document): List<Manga> {
 		return docs.select(selectMangalist).mapNotNull {
@@ -204,12 +204,12 @@ internal abstract class MangaReaderParser(
 			Manga(
 				id = generateUid(relativeUrl),
 				url = relativeUrl,
-				title = a.attr("title"),
+				title = it.selectFirstOrThrow(selectMangaListTitle).text() ?: a.attr("title"),
 				altTitle = null,
 				publicUrl = a.attrAsAbsoluteUrl("href"),
 				rating = rating,
 				isNsfw = isNsfwSource,
-				coverUrl = it.selectFirst(selectMangaListImg)?.imageUrl().orEmpty(),
+				coverUrl = it.selectFirst(selectMangaListImg)?.src().orEmpty(),
 				tags = emptySet(),
 				state = null,
 				author = null,
@@ -229,7 +229,7 @@ internal abstract class MangaReaderParser(
 		val test = docs.select("script:containsData(ts_reader)")
 		if (test.isNullOrEmpty() and !encodedSrc) {
 			return docs.select(selectPage).map { img ->
-				val url = img.imageUrl()
+				val url = img.src()?.toRelativeUrl(domain) ?: img.parseFailed("Image src not found")
 				MangaPage(
 					id = generateUid(url),
 					url = url,
@@ -307,10 +307,5 @@ internal abstract class MangaReaderParser(
 		return@withLock tagMap
 	}
 
-	protected open fun Element.imageUrl(): String {
+
-		return attrAsAbsoluteUrlOrNull("src")
-			?: attrAsAbsoluteUrlOrNull("data-src")
-			?: attrAsAbsoluteUrlOrNull("data-cfsrc")
-			?: ""
-	}
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/ar/SwaTeam.kt

@@ -16,7 +16,6 @@ internal class SwaTeam(context: MangaLoaderContext) :
 	override val selectMangalist = ".listupd .bs .bsx"
 	override val selectMangaListImg = "img"
 
-	// Tag doesn't work on manga page ( it comes from website )
 	override suspend fun getListPage(
 		page: Int,
 		query: String?,
@@ -112,21 +111,15 @@ internal class SwaTeam(context: MangaLoaderContext) :
 		val author = docs.selectFirst("span.author i")?.text()
 
 		val nsfw = docs.selectFirst(".restrictcontainer") != null
-			|| docs.selectFirst(".info-right .alr") != null
+				|| docs.selectFirst(".info-right .alr") != null
-			|| docs.selectFirst(".postbody .alr") != null
+				|| docs.selectFirst(".postbody .alr") != null
 
 		return manga.copy(
 			description = docs.selectFirst("span.desc")?.html(),
 			state = mangaState,
 			author = author,
 			isNsfw = manga.isNsfw || nsfw,
-			tags = docs.select("div.spe a[rel*=tag]").mapToSet { a ->
+			tags = emptySet(),
-				MangaTag(
-					key = a.attr("href").removeSuffix("/").substringAfterLast('/'),
-					title = a.text().toTitleCase(),
-					source = source,
-				)
-			},
 			chapters = chapters,
 		)
 	}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/BabelToon.kt

@@ -41,7 +41,7 @@ internal class BabelToon(context: MangaLoaderContext) :
 		val docs = webClient.httpGet(chapterUrl).parseHtml()
 
 		return docs.select("div.epcontent img").map { img ->
-			val url = img.imageUrl()
+			val url = img.src()?.toRelativeUrl(domain) ?: img.parseFailed("Image src not found")
 			MangaPage(
 				id = generateUid(url),
 				url = url,

src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/en/PeaceScans.kt

@@ -0,0 +1,10 @@
+package org.koitharu.kotatsu.parsers.site.mangareader.en
+
+import org.koitharu.kotatsu.parsers.MangaLoaderContext
+import org.koitharu.kotatsu.parsers.MangaSourceParser
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser
+
+@MangaSourceParser("PEACESCANS", "PeaceScans", "en")
+internal class PeaceScans(context: MangaLoaderContext) :
+	MangaReaderParser(context, MangaSource.PEACESCANS, "peacescans.com", pageSize = 14, searchPageSize = 10)

src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/fr/PantheonScanFr.kt

@@ -0,0 +1,10 @@
+package org.koitharu.kotatsu.parsers.site.mangareader.fr
+
+import org.koitharu.kotatsu.parsers.MangaLoaderContext
+import org.koitharu.kotatsu.parsers.MangaSourceParser
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser
+
+@MangaSourceParser("PANTHEONSCAN_FR", "Pantheon Scan Fr", "fr")
+internal class PantheonScanFr(context: MangaLoaderContext) :
+	MangaReaderParser(context, MangaSource.PANTHEONSCAN_FR, "www.pantheon-scan.fr", pageSize = 40, searchPageSize = 10)

src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/KomikSan.kt

@@ -0,0 +1,75 @@
+package org.koitharu.kotatsu.parsers.site.mangareader.id
+
+import org.koitharu.kotatsu.parsers.MangaLoaderContext
+import org.koitharu.kotatsu.parsers.MangaSourceParser
+import org.koitharu.kotatsu.parsers.model.Manga
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.model.MangaTag
+import org.koitharu.kotatsu.parsers.model.SortOrder
+import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser
+import org.koitharu.kotatsu.parsers.util.domain
+import org.koitharu.kotatsu.parsers.util.parseHtml
+import org.koitharu.kotatsu.parsers.util.urlEncoded
+
+@MangaSourceParser("KOMIKSAN", "Komik San", "id")
+internal class KomikSan(context: MangaLoaderContext) :
+	MangaReaderParser(context, MangaSource.KOMIKSAN, "komiksan.link", pageSize = 40, searchPageSize = 10) {
+
+	override val selectMangaListImg = "img.attachment-medium"
+
+	override val listUrl = "/list"
+	override val datePattern = "MMM d, yyyy"
+
+	override suspend fun getListPage(
+		page: Int,
+		query: String?,
+		tags: Set<MangaTag>?,
+		sortOrder: SortOrder,
+	): List<Manga> {
+		if (!query.isNullOrEmpty()) {
+			if (page > lastSearchPage) {
+				return emptyList()
+			}
+
+			val url = buildString {
+				append("https://")
+				append(domain)
+				append("/search?search=")
+				append(query.urlEncoded())
+				append("&page=")
+				append(page)
+
+			}
+
+			val docs = webClient.httpGet(url).parseHtml()
+			lastSearchPage = docs.selectFirst(".pagination .next")
+				?.previousElementSibling()
+				?.text()?.toIntOrNull() ?: 1
+			return parseMangaList(docs)
+		}
+
+		val sortQuery = when (sortOrder) {
+			SortOrder.ALPHABETICAL -> "title"
+			SortOrder.NEWEST -> "latest"
+			SortOrder.POPULARITY -> "popular"
+			SortOrder.UPDATED -> "update"
+			else -> ""
+		}
+		val tagKey = "genre[]".urlEncoded()
+		val tagQuery =
+			if (tags.isNullOrEmpty()) "" else tags.joinToString(separator = "&", prefix = "&") { "$tagKey=${it.key}" }
+		val url = buildString {
+			append("https://")
+			append(domain)
+			append(listUrl)
+			append("/?order=")
+			append(sortQuery)
+			append(tagQuery)
+			append("&page=")
+			append(page)
+		}
+
+		return parseMangaList(webClient.httpGet(url).parseHtml())
+	}
+
+}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/id/Komikcast.kt

@@ -145,7 +145,7 @@ internal class Komikcast(context: MangaLoaderContext) :
 				publicUrl = a.attrAsAbsoluteUrl("href"),
 				rating = rating,
 				isNsfw = isNsfwSource,
-				coverUrl = it.selectFirst("img.ts-post-image")?.imageUrl().orEmpty(),
+				coverUrl = it.selectFirst("img.ts-post-image")?.src().orEmpty(),
 				tags = emptySet(),
 				state = null,
 				author = null,
@@ -161,7 +161,7 @@ internal class Komikcast(context: MangaLoaderContext) :
 		val test = docs.select("script:containsData(ts_reader)")
 		if (test.isNullOrEmpty()) {
 			return docs.select("div#chapter_body img").map { img ->
-				val url = img.imageUrl()
+				val url = img.src()?.toRelativeUrl(domain) ?: img.parseFailed("Image src not found")
 				MangaPage(
 					id = generateUid(url),
 					url = url,

src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/pt/SssScanlator.kt

@@ -0,0 +1,10 @@
+package org.koitharu.kotatsu.parsers.site.mangareader.pt
+
+import org.koitharu.kotatsu.parsers.MangaLoaderContext
+import org.koitharu.kotatsu.parsers.MangaSourceParser
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.site.mangareader.MangaReaderParser
+
+@MangaSourceParser("SSSSCANLATOR", "SssScanlator", "pt")
+internal class SssScanlator(context: MangaLoaderContext) :
+	MangaReaderParser(context, MangaSource.SSSSCANLATOR, "sssscanlator.com", pageSize = 20, searchPageSize = 10)

src/main/kotlin/org/koitharu/kotatsu/parsers/site/mmrcms/fr/FrScansCom.kt

@@ -0,0 +1,14 @@
+package org.koitharu.kotatsu.parsers.site.mmrcms.fr
+
+import org.koitharu.kotatsu.parsers.MangaLoaderContext
+import org.koitharu.kotatsu.parsers.MangaSourceParser
+import org.koitharu.kotatsu.parsers.model.MangaSource
+import org.koitharu.kotatsu.parsers.site.mmrcms.MmrcmsParser
+import java.util.Locale
+
+@MangaSourceParser("FRSCANSCOM", "FrScansCom", "fr")
+internal class FrScansCom(context: MangaLoaderContext) :
+	MmrcmsParser(context, MangaSource.FRSCANSCOM, "frscans.com") {
+
+	override val sourceLocale: Locale = Locale.ENGLISH
+}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/Bakai.kt

@@ -0,0 +1,155 @@
+package org.koitharu.kotatsu.parsers.site.pt
+
+import okhttp3.Headers
+import org.koitharu.kotatsu.parsers.MangaLoaderContext
+import org.koitharu.kotatsu.parsers.MangaSourceParser
+import org.koitharu.kotatsu.parsers.PagedMangaParser
+import org.koitharu.kotatsu.parsers.config.ConfigKey
+import org.koitharu.kotatsu.parsers.model.*
+import org.koitharu.kotatsu.parsers.network.UserAgents
+import org.koitharu.kotatsu.parsers.util.*
+import java.util.*
+
+@MangaSourceParser("BAKAI", "Bakai", "pt", ContentType.HENTAI)
+internal class Bakai(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.BAKAI, 15) {
+
+	override val sortOrders: Set<SortOrder> = EnumSet.of(SortOrder.UPDATED)
+
+	override val configKeyDomain = ConfigKey.Domain("bakai.org")
+
+	override val headers: Headers = Headers.Builder()
+		.add("User-Agent", UserAgents.CHROME_MOBILE)
+		.build()
+
+	override suspend fun getListPage(
+		page: Int,
+		query: String?,
+		tags: Set<MangaTag>?,
+		sortOrder: SortOrder,
+	): List<Manga> {
+
+		val url = buildString {
+			append("https://")
+			append(domain)
+
+			if (!query.isNullOrEmpty()) {
+				append("/search/?q=")
+				append(query.urlEncoded())
+				append("&quick=1&type=cms_records1&page=")
+				append(page.toString())
+			} else if (!tags.isNullOrEmpty()) {
+				append("/search/?tags=")
+				for (tag in tags) {
+					append(tag.key)
+					append(",")
+				}
+				append("&quick=1&type=cms_records1&page=")
+				append(page.toString())
+
+			} else {
+				append("/hentai/")
+				append("page/")
+				append(page.toString())
+			}
+		}
+		val doc = webClient.httpGet(url).parseHtml()
+		if (!tags.isNullOrEmpty() or !query.isNullOrEmpty()) {
+
+			return doc.select("ol.ipsStream li.ipsStreamItem")
+				.map { div ->
+					val href = div.selectFirstOrThrow("div.ipsStreamItem_snippet a").attrAsAbsoluteUrl("href")
+					Manga(
+						id = generateUid(href),
+						title = div.selectFirstOrThrow("h2.ipsStreamItem_title").text(),
+						altTitle = null,
+						url = href,
+						publicUrl = href.toAbsoluteUrl(domain),
+						rating = RATING_UNKNOWN,
+						isNsfw = true,
+						coverUrl = div.selectFirstOrThrow("span.ipsThumb img").attrAsAbsoluteUrl("src"),
+						tags = setOf(),
+						state = null,
+						author = null,
+						source = source,
+					)
+				}
+		} else {
+			return doc.select("section.ipsType_normal li.ipsGrid_span4")
+				.map { div ->
+					val href = div.selectFirstOrThrow("h2.ipsType_pageTitle a").attrAsRelativeUrl("href")
+					Manga(
+						id = generateUid(href),
+						title = div.selectFirstOrThrow("h2.ipsType_pageTitle").text(),
+						altTitle = null,
+						url = href,
+						publicUrl = href.toAbsoluteUrl(domain),
+						rating = RATING_UNKNOWN,
+						isNsfw = true,
+						coverUrl = div.selectFirstOrThrow("img").attrAsAbsoluteUrl("src"),
+						tags = setOf(),
+						state = null,
+						author = null,
+						source = source,
+					)
+				}
+		}
+	}
+
+	override suspend fun getTags(): Set<MangaTag> {
+		val doc = webClient.httpGet("https://$domain").parseHtml()
+		return doc.requireElementById("elNavigation_17_menu").select("li.ipsMenu_item a").mapNotNullToSet { a ->
+
+			MangaTag(
+				key = a.attr("href").removeSuffix('/').substringAfterLast('/'),
+				title = a.text(),
+				source = source,
+			)
+		}
+	}
+
+	override suspend fun getDetails(manga: Manga): Manga {
+		val root =
+			webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml().selectFirstOrThrow("article.ipsContained")
+		return manga.copy(
+			altTitle = null,
+			state = null,
+			tags = root.select("p:contains(Tags:) span span")[1].text().split(",").mapNotNullToSet { a ->
+				val tag = a.replace(" ", "")
+				MangaTag(
+					key = tag,
+					title = tag,
+					source = source,
+				)
+			},
+			author = root.selectFirstOrThrow("p:contains(Artista:) span a").text(),
+			description = root.selectFirstOrThrow("section.ipsType_richText").html(),
+			chapters = listOf(
+				MangaChapter(
+					id = manga.id,
+					name = manga.title,
+					number = 1,
+					url = manga.url,
+					scanlator = null,
+					uploadDate = 0,
+					branch = null,
+					source = source,
+				),
+			),
+		)
+	}
+
+	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
+		val fullUrl = chapter.url.toAbsoluteUrl(domain)
+		val doc = webClient.httpGet(fullUrl).parseHtml()
+		val root = doc.body().selectFirstOrThrow("div.pular")
+		return root.select("img").map { img ->
+			val url = img.src()?.toRelativeUrl(domain) ?: img.parseFailed("Image src not found")
+			MangaPage(
+				id = generateUid(url),
+				url = url,
+				preview = null,
+				source = source,
+			)
+		}
+	}
+}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/pt/GoldenManga.kt

@@ -0,0 +1,143 @@
+package org.koitharu.kotatsu.parsers.site.pt
+
+import okhttp3.Headers
+import org.koitharu.kotatsu.parsers.MangaLoaderContext
+import org.koitharu.kotatsu.parsers.MangaSourceParser
+import org.koitharu.kotatsu.parsers.PagedMangaParser
+import org.koitharu.kotatsu.parsers.config.ConfigKey
+import org.koitharu.kotatsu.parsers.model.*
+import org.koitharu.kotatsu.parsers.network.UserAgents
+import org.koitharu.kotatsu.parsers.util.*
+import java.text.SimpleDateFormat
+import java.util.*
+
+@MangaSourceParser("GOLDENMANGA", "Golden Manga", "pt")
+internal class GoldenManga(context: MangaLoaderContext) : PagedMangaParser(context, MangaSource.GOLDENMANGA, 36) {
+
+	override val sortOrders: Set<SortOrder> = EnumSet.of(SortOrder.ALPHABETICAL)
+
+	override val configKeyDomain = ConfigKey.Domain("goldenmanga.top")
+
+	override val headers: Headers = Headers.Builder()
+		.add("User-Agent", UserAgents.CHROME_DESKTOP)
+		.build()
+
+
+	override suspend fun getListPage(
+		page: Int,
+		query: String?,
+		tags: Set<MangaTag>?,
+		sortOrder: SortOrder,
+	): List<Manga> {
+
+		val url = buildString {
+			append("https://")
+			append(domain)
+			append("/mangas")
+			append("?pagina=")
+			append(page.toString())
+
+			if (!query.isNullOrEmpty()) {
+				append("&search=")
+				append(query.urlEncoded())
+			}
+
+			if (!tags.isNullOrEmpty()) {
+				append("&genero=")
+				for (tag in tags) {
+					append(tag.key)
+					append(",")
+				}
+			}
+		}
+		val doc = webClient.httpGet(url).parseHtml()
+		return doc.select("section.row div.mangas")
+			.map { div ->
+				val href = div.selectFirstOrThrow("a").attrAsAbsoluteUrl("href")
+				Manga(
+					id = generateUid(href),
+					title = div.selectFirstOrThrow("a h3").text(),
+					altTitle = null,
+					url = href,
+					publicUrl = href.toAbsoluteUrl(domain),
+					rating = RATING_UNKNOWN,
+					isNsfw = div.selectFirst("div.MangaAdulto") != null,
+					coverUrl = div.selectFirstOrThrow("img").attrAsAbsoluteUrl("src"),
+					tags = setOf(),
+					state = null,
+					author = null,
+					source = source,
+				)
+			}
+	}
+
+	override suspend fun getTags(): Set<MangaTag> {
+		val doc = webClient.httpGet("https://$domain/mangas").parseHtml()
+		return doc.select("div.container a.btn.btn-warning ").mapNotNullToSet { a ->
+			MangaTag(
+				key = a.attr("href").substringAfterLast("="),
+				title = a.text(),
+				source = source,
+			)
+		}
+	}
+
+	override suspend fun getDetails(manga: Manga): Manga {
+		val root = webClient.httpGet(manga.url.toAbsoluteUrl(domain)).parseHtml()
+		val dateFormat = SimpleDateFormat("(dd/MM/yyyy)", Locale.ENGLISH)
+		return manga.copy(
+			altTitle = null,
+			state = when (root.select("h5.cg_color")[3].select("a").text()) {
+				"ativo", "Ativo" -> MangaState.ONGOING
+				"Completo" -> MangaState.FINISHED
+				else -> null
+			},
+			tags = root.select("h5.cg_color")[0].select("a").mapNotNullToSet { a ->
+
+				if (a.text().isNullOrEmpty()) {
+					return@mapNotNullToSet null
+				} else {
+					MangaTag(
+						key = a.attr("href").substringAfterLast("="),
+						title = a.text().toTitleCase(),
+						source = source,
+					)
+				}
+			},
+			author = root.select("h5.cg_color a")[1].text(),
+			description = root.getElementById("manga_capitulo_descricao")?.html(),
+			chapters = root.requireElementById("capitulos").select("li")
+
+				.mapChapters(reversed = true) { i, div ->
+					val href = div.selectFirstOrThrow("a").attrAsRelativeUrl("href")
+					val dateText = div.selectFirstOrThrow("div.col-sm-5 span").text()
+					val name = div.selectFirstOrThrow("div.col-sm-5").text().substringBeforeLast("(")
+					MangaChapter(
+						id = generateUid(href),
+						name = name,
+						number = i,
+						url = href,
+						scanlator = null,
+						uploadDate = dateFormat.tryParse(dateText),
+						branch = null,
+						source = source,
+					)
+				},
+		)
+	}
+
+	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
+		val fullUrl = chapter.url.toAbsoluteUrl(domain)
+		val doc = webClient.httpGet(fullUrl).parseHtml()
+		val root = doc.body().requireElementById("capitulos_images")
+		return root.select("img").map { img ->
+			val url = img.src()?.toRelativeUrl(domain) ?: img.parseFailed("Image src not found")
+			MangaPage(
+				id = generateUid(url),
+				url = url,
+				preview = null,
+				source = source,
+			)
+		}
+	}
+}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/wpcomics/WpComicsParser.kt

@@ -40,13 +40,13 @@ internal abstract class WpComicsParser(
 	@JvmField
 	protected val ongoing: Set<String> = setOf(
 		"Đang tiến hành",
-		"Ongoing"
+		"Ongoing",
 	)
 
 	@JvmField
 	protected val finished: Set<String> = setOf(
 		"Hoàn thành",
-		"Completed "
+		"Completed ",
 	)
 
 	override suspend fun getListPage(
@@ -60,17 +60,17 @@ internal abstract class WpComicsParser(
 			append(domain)
 			append(listUrl)
 
-			if(!tags.isNullOrEmpty()){
+			if (!tags.isNullOrEmpty()) {
-			append("/")
+				append("/")
-			for (tag in tags) {
+				for (tag in tags) {
-				append(tag.key)
+					append(tag.key)
-			}
+				}
 			}
 
 			append("?page=")
 			append(page.toString())
 
-			if(!query.isNullOrEmpty()){
+			if (!query.isNullOrEmpty()) {
 				append("&keyword=")
 				append(query.urlEncoded())
 			}
@@ -171,11 +171,9 @@ internal abstract class WpComicsParser(
 			val dateText = li.selectFirst(selectDate)?.text()
 
 			val findHours = dateText?.contains(":")
-			val dateFormat = if(findHours == true)
+			val dateFormat = if (findHours == true) {
-			{
 				SimpleDateFormat("HH:mm dd/MM", sourceLocale)
-			}else
+			} else {
-			{
 				SimpleDateFormat(datePattern, sourceLocale)
 			}
 
@@ -220,7 +218,7 @@ internal abstract class WpComicsParser(
 		return when {
 			d.endsWith(" ago") ||
 					d.endsWith(" trước")  // Handle translated 'ago' in Viêt Nam.
-					 -> parseRelativeDate(date)
+			-> parseRelativeDate(date)
 
 			// Handle 'yesterday' and 'today', using midnight
 			d.startsWith("year") -> Calendar.getInstance().apply {

src/main/kotlin/org/koitharu/kotatsu/parsers/site/wpcomics/en/XoxoComics.kt

@@ -10,7 +10,7 @@ import java.util.EnumSet
 
 @MangaSourceParser("XOXOCOMICS", "Xoxo Comics", "vi", ContentType.COMICS)
 internal class XoxoComics(context: MangaLoaderContext) :
-	WpComicsParser(context, MangaSource.XOXOCOMICS, "xoxocomics.net", 50){
+	WpComicsParser(context, MangaSource.XOXOCOMICS, "xoxocomics.net", 50) {
 
 	override val listUrl = "/genre"
 	override val datePattern = "MM/dd/yyyy"
@@ -19,7 +19,7 @@ internal class XoxoComics(context: MangaLoaderContext) :
 		SortOrder.UPDATED,
 		SortOrder.NEWEST,
 		SortOrder.POPULARITY,
-		SortOrder.ALPHABETICAL
+		SortOrder.ALPHABETICAL,
 	)
 
 	override suspend fun getListPage(
@@ -32,32 +32,31 @@ internal class XoxoComics(context: MangaLoaderContext) :
 			append("https://")
 			append(domain)
 
-			if(!query.isNullOrEmpty()){
+			if (!query.isNullOrEmpty()) {
 				append("/search?keyword=")
 				append(query.urlEncoded())
 				append("&page=")
 				append(page.toString())
-			}else
+			} else {
-			{
+				append(listUrl)
-			append(listUrl)
+				if (!tags.isNullOrEmpty()) {
-			if(!tags.isNullOrEmpty()){
+					append("/")
-				append("/")
+					for (tag in tags) {
-				for (tag in tags) {
+						append(tag.key)
-					append(tag.key)
+					}
 				}
-			}
 
-			append("/")
+				append("/")
-			when (sortOrder) {
+				when (sortOrder) {
-				SortOrder.POPULARITY -> append("popular")
+					SortOrder.POPULARITY -> append("popular")
-				SortOrder.UPDATED -> append("")
+					SortOrder.UPDATED -> append("")
-				SortOrder.NEWEST -> append("newest")
+					SortOrder.NEWEST -> append("newest")
-				SortOrder.ALPHABETICAL -> append("alphabet")
+					SortOrder.ALPHABETICAL -> append("alphabet")
-				else -> append("")
+					else -> append("")
-			}
+				}
 
-			append("?page=")
+				append("?page=")
-			append(page.toString())
+				append(page.toString())
 
 			}
 		}
@@ -98,5 +97,4 @@ internal class XoxoComics(context: MangaLoaderContext) :
 			)
 		}
 	}
-
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/wpcomics/vi/Nettruyenmax.kt

@@ -9,7 +9,7 @@ import org.koitharu.kotatsu.parsers.site.wpcomics.WpComicsParser
 
 @MangaSourceParser("NETTRUYENMAX", "Nettruyenmax", "vi")
 internal class Nettruyenmax(context: MangaLoaderContext) :
-	WpComicsParser(context, MangaSource.NETTRUYENMAX, "www.nettruyenmax.com", 35){
+	WpComicsParser(context, MangaSource.NETTRUYENMAX, "www.nettruyenmax.com", 35) {
 
 	override val listUrl = "/tim-truyen"
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/zmanga/ZMangaParser.kt

@@ -60,7 +60,7 @@ internal abstract class ZMangaParser(
 			append("https://")
 			append(domain)
 			append("/$listUrl")
-			if(page > 1){
+			if (page > 1) {
 				append("page/")
 				append(page.toString())
 				append("/")

src/main/kotlin/org/koitharu/kotatsu/parsers/site/zmanga/id/MaidId.kt

@@ -17,7 +17,7 @@ import java.text.SimpleDateFormat
 // Info: Some scans are password-protected
 @MangaSourceParser("MAID_ID", "Maid Id", "id")
 internal class MaidId(context: MangaLoaderContext) :
-	ZMangaParser(context, MangaSource.MAID_ID, "www.maid.my.id"){
+	ZMangaParser(context, MangaSource.MAID_ID, "www.maid.my.id") {
 
 	override suspend fun getChapters(manga: Manga, doc: Document): List<MangaChapter> {
 		val dateFormat = SimpleDateFormat(datePattern, sourceLocale)
@@ -25,7 +25,8 @@ internal class MaidId(context: MangaLoaderContext) :
 			val a = li.selectFirstOrThrow("a")
 			val href = a.attrAsRelativeUrl("href")
 			val dateText = li.selectFirst(selectDate)?.text()
-			val numChapter = li.selectFirstOrThrow(".flexch-infoz span").html().substringAfterLast("Chapter ").substringBefore("<span")
+			val numChapter = li.selectFirstOrThrow(".flexch-infoz span").html().substringAfterLast("Chapter ")
+				.substringBefore("<span")
 			MangaChapter(
 				id = generateUid(href),
 				name = "Chapter $numChapter",

src/main/kotlin/org/koitharu/kotatsu/parsers/site/zmanga/id/ShiroDoujin.kt

@@ -17,7 +17,7 @@ import java.text.SimpleDateFormat
 
 @MangaSourceParser("SHIRO_DOUJIN", "Shiro Doujin", "id", ContentType.HENTAI)
 internal class ShiroDoujin(context: MangaLoaderContext) :
-	ZMangaParser(context, MangaSource.SHIRO_DOUJIN, "shirodoujin.com"){
+	ZMangaParser(context, MangaSource.SHIRO_DOUJIN, "shirodoujin.com") {
 
 	override suspend fun getChapters(manga: Manga, doc: Document): List<MangaChapter> {
 		val dateFormat = SimpleDateFormat(datePattern, sourceLocale)
@@ -25,7 +25,8 @@ internal class ShiroDoujin(context: MangaLoaderContext) :
 			val a = li.selectFirstOrThrow("a")
 			val href = a.attrAsRelativeUrl("href")
 			val dateText = li.selectFirst(selectDate)?.text()
-			val numChapter = li.selectFirstOrThrow(".flexch-infoz span").html().substringAfterLast("Chapter ").substringBefore("<span")
+			val numChapter = li.selectFirstOrThrow(".flexch-infoz span").html().substringAfterLast("Chapter ")
+				.substringBefore("<span")
 			MangaChapter(
 				id = generateUid(href),
 				name = "Chapter $numChapter",

src/main/kotlin/org/koitharu/kotatsu/parsers/util/Jsoup.kt

@@ -155,7 +155,7 @@ fun Element.attrOrNull(vararg names: String): String? {
 }
 
 @JvmOverloads
-fun Element.src(names: Array<String> = arrayOf("data-src", "data-cfsrc", "data-original", "data-cdn", "data-sizes", "src")): String? {
+fun Element.src(names: Array<String> = arrayOf("data-src", "data-cfsrc", "data-original", "data-cdn", "data-sizes", "data-lazy-src", "src")): String? {
 	for (name in names) {
 		val value = attrAsAbsoluteUrlOrNull(name)
 		if (value != null) {