Fix build

src/main/kotlin/org/koitharu/kotatsu/parsers/site/all/BatoToParser.kt

@@ -69,7 +69,13 @@ internal class BatoToParser(context: MangaLoaderContext) : PagedMangaParser(
 
 	override suspend fun getFilterOptions() = MangaListFilterOptions(
 		availableTags = fetchAvailableTags(),
-		availableStates = EnumSet.allOf(MangaState::class.java),
+		availableStates = EnumSet.of(
+			MangaState.ONGOING,
+			MangaState.FINISHED,
+			MangaState.ABANDONED,
+			MangaState.PAUSED,
+			MangaState.UPCOMING,
+		),
 		availableContentRating = EnumSet.of(ContentRating.SAFE),
 		availableLocales = setOf(
 			Locale.CHINESE, Locale.ENGLISH, Locale.US, Locale.FRENCH, Locale.GERMAN, Locale.ITALIAN, Locale.JAPANESE,
@@ -153,6 +159,7 @@ internal class BatoToParser(context: MangaLoaderContext) : PagedMangaParser(
 								MangaState.ABANDONED -> "cancelled"
 								MangaState.PAUSED -> "hiatus"
 								MangaState.UPCOMING -> "pending"
+								else -> throw IllegalArgumentException("$it not supported")
 							},
 						)
 					}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/all/MangaFireParser.kt

@@ -81,7 +81,13 @@ internal abstract class MangaFireParser(
 
 	override suspend fun getFilterOptions() = MangaListFilterOptions(
 		availableTags = tags.get().values.toSet(),
-		availableStates = EnumSet.allOf(MangaState::class.java),
+		availableStates = EnumSet.of(
+			MangaState.ONGOING,
+			MangaState.FINISHED,
+			MangaState.ABANDONED,
+			MangaState.PAUSED,
+			MangaState.UPCOMING,
+		),
 	)
 
 	override suspend fun getListPage(page: Int, order: SortOrder, filter: MangaListFilter): List<Manga> {
@@ -128,6 +134,7 @@ internal abstract class MangaFireParser(
 								MangaState.ABANDONED -> "discontinued"
 								MangaState.PAUSED -> "on_hiatus"
 								MangaState.UPCOMING -> "info"
+								else -> throw IllegalArgumentException("$state not supported")
 							},
 						)
 					}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/all/MangaPark.kt

@@ -53,7 +53,13 @@ internal class MangaPark(context: MangaLoaderContext) :
 
 	override suspend fun getFilterOptions() = MangaListFilterOptions(
 		availableTags = tagsMap.get().values.toSet(),
-		availableStates = EnumSet.allOf(MangaState::class.java),
+		availableStates = EnumSet.of(
+			MangaState.ONGOING,
+			MangaState.FINISHED,
+			MangaState.ABANDONED,
+			MangaState.PAUSED,
+			MangaState.UPCOMING,
+		),
 		availableContentRating = EnumSet.of(ContentRating.SAFE),
 		availableLocales = setOf(
 			Locale("af"), Locale("sq"), Locale("am"), Locale("ar"), Locale("hy"),
@@ -120,6 +126,7 @@ internal class MangaPark(context: MangaLoaderContext) :
 						MangaState.PAUSED -> "hiatus"
 						MangaState.ABANDONED -> "cancelled"
 						MangaState.UPCOMING -> "pending"
+						else -> throw IllegalArgumentException("$it not supported")
 					},
 				)
 			}

src/main/kotlin/org/koitharu/kotatsu/parsers/site/all/MangaReaderToParser.kt

@@ -76,7 +76,13 @@ internal class MangaReaderToParser(context: MangaLoaderContext) :
 
 	override suspend fun getFilterOptions() = MangaListFilterOptions(
 		availableTags = tags.get().values.toSet(),
-		availableStates = EnumSet.allOf(MangaState::class.java),
+		availableStates = EnumSet.of(
+			MangaState.ONGOING,
+			MangaState.FINISHED,
+			MangaState.ABANDONED,
+			MangaState.PAUSED,
+			MangaState.UPCOMING,
+		),
 	)
 
 	override suspend fun getListPage(page: Int, order: SortOrder, filter: MangaListFilter): List<Manga> {
@@ -105,13 +111,14 @@ internal class MangaReaderToParser(context: MangaLoaderContext) :
 					addQueryParameter("genres", filter.tags.joinToString(",") { it.key })
 					addQueryParameter(
 						name = "status",
-						value = when (filter.states.oneOrThrowIfMany()) {
+						value = when (val state = filter.states.oneOrThrowIfMany()) {
 							MangaState.ONGOING -> "2"
 							MangaState.FINISHED -> "1"
 							MangaState.ABANDONED -> "4"
 							MangaState.PAUSED -> "3"
 							MangaState.UPCOMING -> "5"
 							null -> ""
+							else -> throw IllegalArgumentException("$state not supported")
 						},
 					)
 				}

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

@@ -32,7 +32,13 @@ internal class FlixScans(context: MangaLoaderContext) :
 
 	override suspend fun getFilterOptions() = MangaListFilterOptions(
 		availableTags = fetchAvailableTags(),
-		availableStates = EnumSet.allOf(MangaState::class.java),
+		availableStates = EnumSet.of(
+			MangaState.ONGOING,
+			MangaState.FINISHED,
+			MangaState.ABANDONED,
+			MangaState.PAUSED,
+			MangaState.UPCOMING,
+		),
 		availableContentRating = EnumSet.of(ContentRating.ADULT),
 	)
 
@@ -78,6 +84,7 @@ internal class FlixScans(context: MangaLoaderContext) :
 										MangaState.ABANDONED -> "droped"
 										MangaState.PAUSED -> "onhold"
 										MangaState.UPCOMING -> "soon"
+										else -> throw IllegalArgumentException("$it not supported")
 									},
 								)
 							}

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

@@ -44,7 +44,13 @@ internal class AsuraScansParser(context: MangaLoaderContext) :
 
 	override suspend fun getFilterOptions() = MangaListFilterOptions(
 		availableTags = getOrCreateTagMap().values.toSet(),
-		availableStates = EnumSet.allOf(MangaState::class.java),
+		availableStates = EnumSet.of(
+			MangaState.ONGOING,
+			MangaState.FINISHED,
+			MangaState.ABANDONED,
+			MangaState.PAUSED,
+			MangaState.UPCOMING,
+		),
 		availableContentTypes = EnumSet.of(
 			ContentType.MANGA,
 			ContentType.MANHWA,
@@ -78,6 +84,7 @@ internal class AsuraScansParser(context: MangaLoaderContext) :
 						MangaState.ABANDONED -> "4"
 						MangaState.PAUSED -> "2"
 						MangaState.UPCOMING -> "6"
+						else -> throw IllegalArgumentException("$it not supported")
 					},
 				)
 			}

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

@@ -32,7 +32,13 @@ internal class FlixScansOrg(context: MangaLoaderContext) :
 
 	override suspend fun getFilterOptions() = MangaListFilterOptions(
 		availableTags = fetchAvailableTags(),
-		availableStates = EnumSet.allOf(MangaState::class.java),
+		availableStates = EnumSet.of(
+			MangaState.ONGOING,
+			MangaState.FINISHED,
+			MangaState.ABANDONED,
+			MangaState.PAUSED,
+			MangaState.UPCOMING,
+		),
 		availableContentRating = EnumSet.of(ContentRating.ADULT),
 	)
 
@@ -67,6 +73,7 @@ internal class FlixScansOrg(context: MangaLoaderContext) :
 								MangaState.ABANDONED -> "droped"
 								MangaState.PAUSED -> "onhold"
 								MangaState.UPCOMING -> "soon"
+								else -> throw IllegalArgumentException("$it not supported")
 							},
 						)
 					}

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

@@ -34,7 +34,7 @@ internal abstract class MadaraParser(
 
 	// Change these values only if the site does not support manga listings via ajax
 	protected open val withoutAjax = false
-    protected open val authorSearchSupported = false
+	protected open val authorSearchSupported = false
 
 	override val availableSortOrders: Set<SortOrder> = setupAvailableSortOrders()
 
@@ -72,12 +72,18 @@ internal abstract class MadaraParser(
 			isSearchSupported = true,
 			isSearchWithFiltersSupported = true,
 			isYearSupported = true,
-			isAuthorSearchSupported = authorSearchSupported
+			isAuthorSearchSupported = authorSearchSupported,
 		)
 
 	override suspend fun getFilterOptions() = MangaListFilterOptions(
 		availableTags = fetchAvailableTags(),
-		availableStates = EnumSet.allOf(MangaState::class.java),
+		availableStates = EnumSet.of(
+			MangaState.ONGOING,
+			MangaState.FINISHED,
+			MangaState.ABANDONED,
+			MangaState.PAUSED,
+			MangaState.UPCOMING,
+		),
 		availableContentRating = EnumSet.of(ContentRating.SAFE, ContentRating.ADULT),
 	)
 
@@ -256,6 +262,7 @@ internal abstract class MadaraParser(
 						MangaState.ABANDONED -> append("canceled")
 						MangaState.PAUSED -> append("on-hold")
 						MangaState.UPCOMING -> append("upcoming")
+						else -> throw IllegalArgumentException("$it not supported")
 					}
 				}
 
@@ -275,13 +282,13 @@ internal abstract class MadaraParser(
 					append(filter.year.toString())
 				}
 
-                if (!filter.author.isNullOrEmpty()) {
+				if (!filter.author.isNullOrEmpty()) {
-                    filter.author.let {
+					filter.author.let {
-                        append("&author=")
+						append("&author=")
-                        // should be like "minamida-usuke"
+						// should be like "minamida-usuke"
-                        append(it.lowercase().replace(" ", "-"))
+						append(it.lowercase().replace(" ", "-"))
-                    }
+					}
-                }
+				}
 
 				// Support artist
 				//filter.artist?.let {
@@ -435,6 +442,7 @@ internal abstract class MadaraParser(
 						MangaState.ABANDONED -> "canceled"
 						MangaState.PAUSED -> "on-hold"
 						MangaState.UPCOMING -> "upcoming"
+						else -> throw IllegalArgumentException("$it not supported")
 					}
 			}
 
@@ -462,12 +470,12 @@ internal abstract class MadaraParser(
 			doc.select("div.page-item-detail")
 		}
 
-        // Avoid "Content not found or removed" errors
+		// Avoid "Content not found or removed" errors
 		if (elements.isEmpty()) {
 			return emptyList()
 		}
 
-        return elements.map { div ->
+		return elements.map { div ->
 			val href = div.selectFirstOrThrow("a").attrAsRelativeUrl("href")
 			val summary = div.selectFirst(".tab-summary") ?: div.selectFirst(".item-summary")
 			val author = summary?.selectFirst(".mg_author")?.selectFirst("a")?.ownText()

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

@@ -74,6 +74,7 @@ internal class Hentai4Free(context: MangaLoaderContext) :
 								MangaState.ABANDONED -> append("canceled")
 								MangaState.PAUSED -> append("on-hold")
 								MangaState.UPCOMING -> append("upcoming")
+								else -> throw IllegalArgumentException("$it not supported")
 							}
 						}
 

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

@@ -62,6 +62,7 @@ internal class IsekaiScanEuParser(context: MangaLoaderContext) :
 								MangaState.ABANDONED -> append("canceled")
 								MangaState.PAUSED -> append("on-hold")
 								MangaState.UPCOMING -> append("upcoming")
+								else -> throw IllegalArgumentException("$it not supported")
 							}
 						}
 

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

@@ -4,23 +4,11 @@ import org.jsoup.nodes.Element
 import org.koitharu.kotatsu.parsers.MangaLoaderContext
 import org.koitharu.kotatsu.parsers.MangaSourceParser
 import org.koitharu.kotatsu.parsers.exception.ParseException
-import org.koitharu.kotatsu.parsers.model.ContentType
+import org.koitharu.kotatsu.parsers.model.*
-import org.koitharu.kotatsu.parsers.model.MangaChapter
-import org.koitharu.kotatsu.parsers.model.MangaPage
-import org.koitharu.kotatsu.parsers.model.MangaTag
-import org.koitharu.kotatsu.parsers.model.MangaListFilter
-import org.koitharu.kotatsu.parsers.model.MangaListFilterOptions
-import org.koitharu.kotatsu.parsers.model.MangaParserSource
-import org.koitharu.kotatsu.parsers.model.Manga
-import org.koitharu.kotatsu.parsers.model.MangaState
-import org.koitharu.kotatsu.parsers.model.ContentRating
-import org.koitharu.kotatsu.parsers.model.SortOrder
 import org.koitharu.kotatsu.parsers.site.madara.MadaraParser
-import org.koitharu.kotatsu.parsers.config.ConfigKey
 import org.koitharu.kotatsu.parsers.util.*
 import org.koitharu.kotatsu.parsers.util.suspendlazy.getOrNull
 import org.koitharu.kotatsu.parsers.util.suspendlazy.suspendLazy
-import java.util.*
 
 // Do not use "hentaicb.sbs" domain, may cause duplicate tags!
 @MangaSourceParser("HENTAICUBE", "CBHentai", "vi", ContentType.HENTAI)
@@ -29,116 +17,117 @@ internal class HentaiCube(context: MangaLoaderContext) :
 
 	override val datePattern = "dd/MM/yyyy"
 	override val postReq = true
-    override val authorSearchSupported = true
+	override val authorSearchSupported = true
 	override val postDataReq = "action=manga_views&manga="
 
-    private val availableTags = suspendLazy(initializer = ::fetchTags)
+	private val availableTags = suspendLazy(initializer = ::fetchTags)
 
 	override suspend fun getFilterOptions() = MangaListFilterOptions(
 		availableTags = availableTags.get(),
 	)
 
-    override suspend fun getListPage(page: Int, order: SortOrder, filter: MangaListFilter): List<Manga> {
+	override suspend fun getListPage(page: Int, order: SortOrder, filter: MangaListFilter): List<Manga> {
 		val pages = page + 1
 
-        val url = buildString {
+		val url = buildString {
-            if (!filter.author.isNullOrEmpty()) {
+			if (!filter.author.isNullOrEmpty()) {
-                clear()
+				clear()
-                append("https://")
+				append("https://")
-                append(domain)
+				append(domain)
-                append("/tacgia/")
+				append("/tacgia/")
-                append(filter.author.lowercase().replace(" ", "-"))
+				append(filter.author.lowercase().replace(" ", "-"))
-                
+
-                if (pages > 1) {
+				if (pages > 1) {
-                    append("/page/")
+					append("/page/")
-                    append(pages.toString())
+					append(pages.toString())
-                }
+				}
-                
+
-                append("/?m_orderby=")
+				append("/?m_orderby=")
-                when (order) {
+				when (order) {
-                    SortOrder.POPULARITY -> append("views")
+					SortOrder.POPULARITY -> append("views")
-                    SortOrder.UPDATED -> append("latest")
+					SortOrder.UPDATED -> append("latest")
-                    SortOrder.NEWEST -> append("new-manga")
+					SortOrder.NEWEST -> append("new-manga")
-                    SortOrder.ALPHABETICAL -> {}
+					SortOrder.ALPHABETICAL -> {}
-                    SortOrder.RATING -> append("trending")
+					SortOrder.RATING -> append("trending")
-                    SortOrder.RELEVANCE -> {}
+					SortOrder.RELEVANCE -> {}
-                    else -> append("latest") // default
+					else -> append("latest") // default
-                }
+				}
-                return@buildString
+				return@buildString
-            }
+			}
-
+
-            append("https://")
+			append("https://")
-            append(domain)
+			append(domain)
-
+
-            if (pages > 1) {
+			if (pages > 1) {
-                append("/page/")
+				append("/page/")
-                append(pages.toString())
+				append(pages.toString())
-            }
+			}
-            
+
-            append("/?s=")
+			append("/?s=")
-
+
-            filter.query?.let {
+			filter.query?.let {
-                append(filter.query.urlEncoded())
+				append(filter.query.urlEncoded())
-            }
+			}
-
+
-            append("&post_type=wp-manga")
+			append("&post_type=wp-manga")
-
+
-            if (filter.tags.isNotEmpty()) {
+			if (filter.tags.isNotEmpty()) {
-                filter.tags.forEach {
+				filter.tags.forEach {
-                    append("&genre[]=")
+					append("&genre[]=")
-                    append(it.key)
+					append(it.key)
-                }
+				}
-            }
+			}
-
+
-            filter.states.forEach {
+			filter.states.forEach {
-                append("&status[]=")
+				append("&status[]=")
-                when (it) {
+				when (it) {
-                    MangaState.ONGOING -> append("on-going")
+					MangaState.ONGOING -> append("on-going")
-                    MangaState.FINISHED -> append("end")
+					MangaState.FINISHED -> append("end")
-                    MangaState.ABANDONED -> append("canceled")
+					MangaState.ABANDONED -> append("canceled")
-                    MangaState.PAUSED -> append("on-hold")
+					MangaState.PAUSED -> append("on-hold")
-                    MangaState.UPCOMING -> append("upcoming")
+					MangaState.UPCOMING -> append("upcoming")
-                }
+					else -> throw IllegalArgumentException("$it not supported")
-            }
+				}
-
+			}
-            filter.contentRating.oneOrThrowIfMany()?.let {
+
-                append("&adult=")
+			filter.contentRating.oneOrThrowIfMany()?.let {
-                append(
+				append("&adult=")
-                    when (it) {
+				append(
-                        ContentRating.SAFE -> "0"
+					when (it) {
-                        ContentRating.ADULT -> "1"
+						ContentRating.SAFE -> "0"
-                        else -> ""
+						ContentRating.ADULT -> "1"
-                    },
+						else -> ""
-                )
+					},
-            }
+				)
-
+			}
-            if (filter.year != 0) {
+
-                append("&release=")
+			if (filter.year != 0) {
-                append(filter.year.toString())
+				append("&release=")
-            }
+				append(filter.year.toString())
-
+			}
-            append("&m_orderby=")
+
-            when (order) {
+			append("&m_orderby=")
-                SortOrder.POPULARITY -> append("views")
+			when (order) {
-                SortOrder.UPDATED -> append("latest")
+				SortOrder.POPULARITY -> append("views")
-                SortOrder.NEWEST -> append("new-manga")
+				SortOrder.UPDATED -> append("latest")
-                SortOrder.ALPHABETICAL -> append("alphabet")
+				SortOrder.NEWEST -> append("new-manga")
-                SortOrder.RATING -> append("rating")
+				SortOrder.ALPHABETICAL -> append("alphabet")
-                SortOrder.RELEVANCE -> {}
+				SortOrder.RATING -> append("rating")
-                else -> {}
+				SortOrder.RELEVANCE -> {}
-            }
+				else -> {}
-        }
+			}
-        return parseMangaList(webClient.httpGet(url).parseHtml())
+		}
-    }
+		return parseMangaList(webClient.httpGet(url).parseHtml())
+	}
 
 	override suspend fun createMangaTag(a: Element): MangaTag? {
-        val allTags = availableTags.getOrNull().orEmpty()
+		val allTags = availableTags.getOrNull().orEmpty()
-        val title = a.text().replace(Regex("\\(\\d+\\)"), "").trim() // force trim to remove space
+		val title = a.text().replace(Regex("\\(\\d+\\)"), "").trim() // force trim to remove space
-        // compare to avoid duplicate tags with the same title
+		// compare to avoid duplicate tags with the same title
-        return allTags.find { 
+		return allTags.find {
-            it.title.trim().equals(title, ignoreCase = true) // try to search with trim
+			it.title.trim().equals(title, ignoreCase = true) // try to search with trim
-        }
+		}
-    }
+	}
 
 	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
 		val fullUrl = chapter.url.toAbsoluteUrl(domain)
@@ -157,17 +146,17 @@ internal class HentaiCube(context: MangaLoaderContext) :
 	}
 
 	private suspend fun fetchTags(): Set<MangaTag> {
-        val doc = webClient.httpGet("https://$domain/the-loai-genres").parseHtml()
+		val doc = webClient.httpGet("https://$domain/the-loai-genres").parseHtml()
-        val elements = doc.select("ul.list-unstyled li a")
+		val elements = doc.select("ul.list-unstyled li a")
-        return elements.mapToSet { element ->
+		return elements.mapToSet { element ->
-            val href = element.attr("href")
+			val href = element.attr("href")
-            val key = href.substringAfter("/theloai/").removeSuffix("/")
+			val key = href.substringAfter("/theloai/").removeSuffix("/")
-            val title = element.text().replace(Regex("\\(\\d+\\)"), "").trim() // force trim
+			val title = element.text().replace(Regex("\\(\\d+\\)"), "").trim() // force trim
-            MangaTag(
+			MangaTag(
-                key = key,
+				key = key,
-                title = title,
+				title = title,
-                source = source,
+				source = source,
-            )
+			)
-        }.toSet()
+		}.toSet()
-    }
+	}
 }

src/main/kotlin/org/koitharu/kotatsu/parsers/site/nepnep/NepnepParser.kt

@@ -47,7 +47,13 @@ internal abstract class NepnepParser(
 
 	override suspend fun getFilterOptions() = MangaListFilterOptions(
 		availableTags = fetchAvailableTags(),
-		availableStates = EnumSet.allOf(MangaState::class.java),
+		availableStates = EnumSet.of(
+			MangaState.ONGOING,
+			MangaState.FINISHED,
+			MangaState.ABANDONED,
+			MangaState.PAUSED,
+			MangaState.UPCOMING,
+		),
 	)
 
 	data class MangaWithLastUpdate(

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

@@ -90,6 +90,7 @@ internal class MangaWtfParser(
 								MangaState.ABANDONED -> ""
 								MangaState.PAUSED -> "FROZEN"
 								MangaState.UPCOMING -> "ANNOUNCE"
+								else -> throw IllegalArgumentException("$it not supported")
 							}
 						},
 					)

src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/rulib/LibSocialParser.kt

@@ -67,7 +67,13 @@ internal abstract class LibSocialParser(
 
 	override suspend fun getFilterOptions() = MangaListFilterOptions(
 		availableTags = fetchAvailableTags(),
-		availableStates = EnumSet.allOf(MangaState::class.java),
+		availableStates = EnumSet.of(
+			MangaState.ONGOING,
+			MangaState.FINISHED,
+			MangaState.ABANDONED,
+			MangaState.PAUSED,
+			MangaState.UPCOMING,
+		),
 	)
 
 	override fun intercept(chain: Interceptor.Chain): Response {

src/main/kotlin/org/koitharu/kotatsu/parsers/site/ru/rulib/MangaLibParser.kt

@@ -15,7 +15,7 @@ internal class MangaLibParser(
 	context = context,
 	source = MangaParserSource.MANGALIB,
 	siteId = 1,
-	siteDomains = arrayOf("mangalib.me"),
+	siteDomains = arrayOf("mangalib.org", "mangalib.me"),
 ) {
 
 	override suspend fun getPages(chapter: MangaChapter): List<MangaPage> = try {

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

@@ -11,12 +11,12 @@ import java.text.SimpleDateFormat
 import java.util.*
 
 @MangaSourceParser("ELECEEDTURKIYE", "Eleceed Türkiye", "tr")
-internal class EleceedTurkiye(context: MangaLoaderContext):
+internal class EleceedTurkiye(context: MangaLoaderContext) :
 	SinglePageMangaParser(context, MangaParserSource.ELECEEDTURKIYE) {
 
 	override val configKeyDomain = ConfigKey.Domain(
 		"eleceedturkiye.com",
-		"www.eleceedturkiye.com"
+		"www.eleceedturkiye.com",
 	)
 
 	override val availableSortOrders: Set<SortOrder> = EnumSet.of(SortOrder.UPDATED)
@@ -42,8 +42,8 @@ internal class EleceedTurkiye(context: MangaLoaderContext):
 				authors = setOf("Son Jae Ho", "ZHENA"),
 				state = MangaState.ONGOING,
 				source = source,
-				contentRating = ContentRating.ADULT
+				contentRating = ContentRating.ADULT,
-			)
+			),
 		)
 	}
 
@@ -55,23 +55,23 @@ internal class EleceedTurkiye(context: MangaLoaderContext):
 				MangaTag("Aksiyon", "", source),
 				MangaTag("Drama", "", source),
 				MangaTag("Komedi", "", source),
-				MangaTag("Süper Güçler", "", source)
+				MangaTag("Süper Güçler", "", source),
 			),
-			chapters = doc.select("div.eph-num").map { div ->
+			chapters = doc.select("div.eph-num").mapChapters(reversed = true) { _, div ->
 				val href = div.selectFirstOrThrow("a").attr("href")
-				val title = div.selectFirst("span.chapternum").text()
+				val title = div?.selectFirst("span.chapternum")?.textOrNull()
 				MangaChapter(
 					id = generateUid(href),
 					title = title,
-					number = Regex("\\d+").find(title)?.value?.toFloatOrNull() ?: 0f,
+					number = title?.let { Regex("\\d+").find(it)?.value?.toFloatOrNull() } ?: 0f,
 					url = href,
-					uploadDate = parseChapterDate(div.selectFirst("span.chapterdate")?.text()),
+					uploadDate = dateFormat.tryParse(div.selectFirst("span.chapterdate")?.text()),
 					scanlator = null,
 					branch = null,
 					source = source,
 					volume = 0,
 				)
-			}.reversed()
+			},
 		)
 	}
 
@@ -104,14 +104,4 @@ internal class EleceedTurkiye(context: MangaLoaderContext):
 
 	private val mangaId = "eleceed"
 	private val dateFormat = SimpleDateFormat("MMMM d, yyyy", Locale("tr"))
-
-	private fun parseChapterDate(dateString: String?): Long {
-		return dateString?.let {
-			try {
-				dateFormat.parse(it)?.time ?: 0
-			} catch (e: Exception) {
-				0
-			}
-		} ?: 0
-	}
 }