src/pt/animestc/AndroidManifest.xml

@@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-
-    <application>
-        <activity
-            android:name=".pt.animestc.AnimesTCUrlActivity"
-            android:excludeFromRecents="true"
-            android:exported="true"
-            android:theme="@android:style/Theme.NoDisplay">
-            <intent-filter>
-                <action android:name="android.intent.action.VIEW" />
-
-                <category android:name="android.intent.category.DEFAULT" />
-                <category android:name="android.intent.category.BROWSABLE" />
-
-                <data
-                    android:host="www.animestc.net"
-                    android:pathPattern="/animes/..*"
-                    android:scheme="https" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>

src/pt/animestc/build.gradle

@@ -1,11 +0,0 @@
-ext {
-    extName = 'AnimesTC'
-    extClass = '.AnimesTC'
-    extVersionCode = 7
-}
-
-apply from: "$rootDir/common.gradle"
-
-dependencies {
-    implementation(project(":lib:googledrive-extractor"))
-}

src/pt/animestc/src/eu/kanade/tachiyomi/animeextension/pt/animestc/ATCFilters.kt

@@ -1,174 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.pt.animestc
-
-import eu.kanade.tachiyomi.animesource.model.AnimeFilter
-import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
-
-object ATCFilters {
-    open class QueryPartFilter(
-        displayName: String,
-        val vals: Array<Pair<String, String>>,
-    ) : AnimeFilter.Select<String>(
-        displayName,
-        vals.map { it.first }.toTypedArray(),
-    ) {
-        fun toQueryPart() = vals[state].second
-    }
-
-    private inline fun <reified R> AnimeFilterList.asQueryPart(): String {
-        return (first { it is R } as QueryPartFilter).toQueryPart()
-    }
-
-    class TypeFilter : QueryPartFilter("Tipo", ATCFiltersData.TYPES)
-    class YearFilter : QueryPartFilter("Ano", ATCFiltersData.YEARS)
-    class GenreFilter : QueryPartFilter("Gênero", ATCFiltersData.GENRES)
-    class StatusFilter : QueryPartFilter("Status", ATCFiltersData.STATUS)
-
-    val FILTER_LIST get() = AnimeFilterList(
-        TypeFilter(),
-        YearFilter(),
-        GenreFilter(),
-        StatusFilter(),
-    )
-
-    data class FilterSearchParams(
-        val type: String = "series",
-        val year: String = "",
-        val genre: String = "",
-        val status: String = "",
-    )
-
-    internal fun getSearchParameters(filters: AnimeFilterList): FilterSearchParams {
-        if (filters.isEmpty()) return FilterSearchParams()
-
-        return FilterSearchParams(
-            filters.asQueryPart<TypeFilter>(),
-            filters.asQueryPart<YearFilter>(),
-            filters.asQueryPart<GenreFilter>(),
-            filters.asQueryPart<StatusFilter>(),
-        )
-    }
-
-    private object ATCFiltersData {
-        val TYPES = arrayOf(
-            Pair("Anime", "series"),
-            Pair("Filme", "movie"),
-            Pair("OVA", "ova"),
-        )
-
-        val SELECT = Pair("Selecione", "")
-
-        val STATUS = arrayOf(
-            SELECT,
-            Pair("Cancelado", "canceled"),
-            Pair("Completo", "complete"),
-            Pair("Em Lançamento", "airing"),
-            Pair("Pausado", "onhold"),
-        )
-
-        val YEARS = arrayOf(SELECT) + (1997..2024).map {
-            Pair(it.toString(), it.toString())
-        }.toTypedArray()
-
-        val GENRES = arrayOf(
-            SELECT,
-            Pair("Ação", "acao"),
-            Pair("Action", "action"),
-            Pair("Adventure", "adventure"),
-            Pair("Artes Marciais", "artes-marciais"),
-            Pair("Artes Marcial", "artes-marcial"),
-            Pair("Aventura", "aventura"),
-            Pair("Beisebol", "beisebol"),
-            Pair("Boys Love", "boys-love"),
-            Pair("Comédia", "comedia"),
-            Pair("Comédia Romântica", "comedia-romantica"),
-            Pair("Comedy", "comedy"),
-            Pair("Crianças", "criancas"),
-            Pair("Culinária", "culinaria"),
-            Pair("Cyberpunk", "cyberpunk"),
-            Pair("Demônios", "demonios"),
-            Pair("Distopia", "distopia"),
-            Pair("Documentário", "documentario"),
-            Pair("Drama", "drama"),
-            Pair("Ecchi", "ecchi"),
-            Pair("Escola", "escola"),
-            Pair("Escolar", "escolar"),
-            Pair("Espaço", "espaco"),
-            Pair("Esporte", "esporte"),
-            Pair("Esportes", "esportes"),
-            Pair("Fantasia", "fantasia"),
-            Pair("Ficção Científica", "ficcao-cientifica"),
-            Pair("Futebol", "futebol"),
-            Pair("Game", "game"),
-            Pair("Girl battleships", "girl-battleships"),
-            Pair("Gourmet", "gourmet"),
-            Pair("Gundam", "gundam"),
-            Pair("Harém", "harem"),
-            Pair("Hentai", "hentai"),
-            Pair("Historia", "historia"),
-            Pair("Historial", "historial"),
-            Pair("Historical", "historical"),
-            Pair("Histórico", "historico"),
-            Pair("Horror", "horror"),
-            Pair("Humor Negro", "humor-negro"),
-            Pair("Ídolo", "idolo"),
-            Pair("Infantis", "infantis"),
-            Pair("Investigação", "investigacao"),
-            Pair("Isekai", "isekai"),
-            Pair("Jogo", "jogo"),
-            Pair("Jogos", "jogos"),
-            Pair("Josei", "josei"),
-            Pair("Kids", "kids"),
-            Pair("Luta", "luta"),
-            Pair("Maduro", "maduro"),
-            Pair("Máfia", "mafia"),
-            Pair("Magia", "magia"),
-            Pair("Mágica", "magica"),
-            Pair("Mecha", "mecha"),
-            Pair("Militar", "militar"),
-            Pair("Militares", "militares"),
-            Pair("Mistério", "misterio"),
-            Pair("Música", "musica"),
-            Pair("Musical", "musical"),
-            Pair("Não Informado!", "nao-informado"),
-            Pair("Paródia", "parodia"),
-            Pair("Piratas", "piratas"),
-            Pair("Polícia", "policia"),
-            Pair("Policial", "policial"),
-            Pair("Político", "politico"),
-            Pair("Pós-Apocalíptico", "pos-apocaliptico"),
-            Pair("Psico", "psico"),
-            Pair("Psicológico", "psicologico"),
-            Pair("Romance", "romance"),
-            Pair("Samurai", "samurai"),
-            Pair("Samurais", "samurais"),
-            Pair("Sátiro", "satiro"),
-            Pair("School Life", "school-life"),
-            Pair("SciFi", "scifi"),
-            Pair("Sci-Fi", "sci-fi"),
-            Pair("Seinen", "seinen"),
-            Pair("Shotacon", "shotacon"),
-            Pair("Shoujo", "shoujo"),
-            Pair("Shoujo Ai", "shoujo-ai"),
-            Pair("Shounem", "shounem"),
-            Pair("Shounen", "shounen"),
-            Pair("Shounen-ai", "shounen-ai"),
-            Pair("Slice of Life", "slice-of-life"),
-            Pair("Sobrenatural", "sobrenatural"),
-            Pair("Space", "space"),
-            Pair("Supernatural", "supernatural"),
-            Pair("Super Poder", "super-poder"),
-            Pair("Super-Poderes", "super-poderes"),
-            Pair("Suspense", "suspense"),
-            Pair("tear-studio", "tear-studio"),
-            Pair("Terror", "terror"),
-            Pair("Thriller", "thriller"),
-            Pair("Tragédia", "tragedia"),
-            Pair("Vampiro", "vampiro"),
-            Pair("Vampiros", "vampiros"),
-            Pair("Vida Escolar", "vida-escolar"),
-            Pair("Yaoi", "yaoi"),
-            Pair("Yuri", "yuri"),
-            Pair("Zombie", "zombie"),
-        )
-    }
-}

src/pt/animestc/src/eu/kanade/tachiyomi/animeextension/pt/animestc/AnimesTC.kt

@@ -1,294 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.pt.animestc
-
-import android.app.Application
-import androidx.preference.ListPreference
-import androidx.preference.PreferenceScreen
-import eu.kanade.tachiyomi.animeextension.pt.animestc.dto.AnimeDto
-import eu.kanade.tachiyomi.animeextension.pt.animestc.dto.EpisodeDto
-import eu.kanade.tachiyomi.animeextension.pt.animestc.dto.ResponseDto
-import eu.kanade.tachiyomi.animeextension.pt.animestc.dto.VideoDto
-import eu.kanade.tachiyomi.animeextension.pt.animestc.extractors.LinkBypasser
-import eu.kanade.tachiyomi.animeextension.pt.animestc.extractors.SendcmExtractor
-import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
-import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
-import eu.kanade.tachiyomi.animesource.model.AnimesPage
-import eu.kanade.tachiyomi.animesource.model.SAnime
-import eu.kanade.tachiyomi.animesource.model.SEpisode
-import eu.kanade.tachiyomi.animesource.model.Video
-import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
-import eu.kanade.tachiyomi.lib.googledriveextractor.GoogleDriveExtractor
-import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.network.awaitSuccess
-import eu.kanade.tachiyomi.util.asJsoup
-import eu.kanade.tachiyomi.util.parallelCatchingFlatMapBlocking
-import eu.kanade.tachiyomi.util.parseAs
-import kotlinx.serialization.json.Json
-import okhttp3.HttpUrl.Companion.toHttpUrl
-import okhttp3.Request
-import okhttp3.Response
-import uy.kohesive.injekt.Injekt
-import uy.kohesive.injekt.api.get
-import uy.kohesive.injekt.injectLazy
-import java.text.SimpleDateFormat
-import java.util.Locale
-
-class AnimesTC : ConfigurableAnimeSource, AnimeHttpSource() {
-
-    override val name = "AnimesTC"
-
-    override val baseUrl = "https://api2.animestc.com"
-
-    override val lang = "pt-BR"
-
-    override val supportsLatest = true
-
-    override fun headersBuilder() = super.headersBuilder()
-        .add("Referer", "$HOST_URL/")
-
-    private val preferences by lazy {
-        Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
-    }
-
-    private val json: Json by injectLazy()
-
-    // ============================== Popular ===============================
-    override fun popularAnimeRequest(page: Int) = GET("$baseUrl/series?order=id&direction=asc&page=1&top=true", headers)
-
-    override fun popularAnimeParse(response: Response): AnimesPage {
-        val data = response.parseAs<List<AnimeDto>>()
-        val animes = data.map(::searchAnimeFromObject)
-        return AnimesPage(animes, false)
-    }
-
-    // =============================== Latest ===============================
-    override fun latestUpdatesRequest(page: Int) = GET(HOST_URL, headers)
-
-    override fun latestUpdatesParse(response: Response): AnimesPage {
-        val doc = response.asJsoup()
-        val animes = doc.select("div > article.episode").map {
-            SAnime.create().apply {
-                val ahref = it.selectFirst("h3 > a.episode-info-title-orange")!!
-                title = ahref.text()
-                val slug = ahref.attr("href").substringAfterLast("/")
-                setUrlWithoutDomain("/series?slug=$slug")
-                thumbnail_url = it.selectFirst("img.episode-image")?.attr("abs:data-src")
-            }
-        }
-            .filter { it.thumbnail_url?.contains("/_nuxt/img/") == false }
-            .distinctBy { it.url }
-
-        return AnimesPage(animes, false)
-    }
-
-    // =============================== Search ===============================
-    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
-        val params = ATCFilters.getSearchParameters(filters)
-        val url = "$baseUrl/series?order=title&direction=asc&page=$page".toHttpUrl()
-            .newBuilder()
-            .addQueryParameter("type", params.type)
-            .addQueryParameter("search", query)
-            .addQueryParameter("year", params.year)
-            .addQueryParameter("releaseStatus", params.status)
-            .addQueryParameter("tag", params.genre)
-            .build()
-
-        return GET(url, headers)
-    }
-
-    override fun searchAnimeParse(response: Response): AnimesPage {
-        val data = response.parseAs<ResponseDto<AnimeDto>>()
-        val animes = data.items.map(::searchAnimeFromObject)
-        val hasNextPage = data.lastPage > data.page
-        return AnimesPage(animes, hasNextPage)
-    }
-
-    override suspend fun getSearchAnime(page: Int, query: String, filters: AnimeFilterList): AnimesPage {
-        return if (query.startsWith(PREFIX_SEARCH)) { // URL intent handler
-            val slug = query.removePrefix(PREFIX_SEARCH)
-            client.newCall(GET("$baseUrl/series?slug=$slug"))
-                .awaitSuccess()
-                .use(::searchAnimeBySlugParse)
-        } else {
-            return super.getSearchAnime(page, query, filters)
-        }
-    }
-
-    override fun getFilterList(): AnimeFilterList = ATCFilters.FILTER_LIST
-
-    private fun searchAnimeFromObject(anime: AnimeDto) = SAnime.create().apply {
-        thumbnail_url = anime.cover.url
-        title = anime.title
-        setUrlWithoutDomain("/series/${anime.id}")
-    }
-
-    private fun searchAnimeBySlugParse(response: Response): AnimesPage {
-        val details = animeDetailsParse(response).apply {
-            setUrlWithoutDomain(response.request.url.toString())
-            initialized = true
-        }
-
-        return AnimesPage(listOf(details), false)
-    }
-
-    // =========================== Anime Details ============================
-    override fun animeDetailsParse(response: Response) = SAnime.create().apply {
-        val anime = response.getAnimeDto()
-        setUrlWithoutDomain("/series/${anime.id}")
-        title = anime.title
-        status = anime.status
-        thumbnail_url = anime.cover.url
-        artist = anime.producer
-        genre = anime.genres
-        description = buildString {
-            append(anime.synopsis + "\n")
-
-            anime.classification?.also { append("\nClassificação: ", it, " anos") }
-            anime.year?.also { append("\nAno de lançamento: ", it) }
-        }
-    }
-
-    // ============================== Episodes ==============================
-    override fun episodeListParse(response: Response): List<SEpisode> {
-        val id = response.getAnimeDto().id
-        return getEpisodeList(id)
-    }
-
-    private fun episodeListRequest(animeId: Int, page: Int) =
-        GET("$baseUrl/episodes?order=id&direction=desc&page=$page&seriesId=$animeId&specialOrder=true")
-
-    private fun getEpisodeList(animeId: Int, page: Int = 1): List<SEpisode> {
-        val response = client.newCall(episodeListRequest(animeId, page)).execute()
-        val parsed = response.parseAs<ResponseDto<EpisodeDto>>()
-        val episodes = parsed.items.map(::episodeFromObject)
-
-        if (parsed.page < parsed.lastPage) {
-            return episodes + getEpisodeList(animeId, page + 1)
-        } else {
-            return episodes
-        }
-    }
-
-    private fun episodeFromObject(episode: EpisodeDto) = SEpisode.create().apply {
-        name = episode.title
-        setUrlWithoutDomain("/episodes?slug=${episode.slug}")
-        episode_number = episode.number.toFloat()
-        date_upload = episode.created_at.toDate()
-    }
-
-    // ============================ Video Links =============================
-    private val sendcmExtractor by lazy { SendcmExtractor(client) }
-    private val gdriveExtractor by lazy { GoogleDriveExtractor(client, headers) }
-    private val linkBypasser by lazy { LinkBypasser(client, json) }
-
-    private val supportedPlayers = listOf("send", "drive")
-
-    override fun videoListParse(response: Response): List<Video> {
-        val videoDto = response.parseAs<ResponseDto<VideoDto>>().items.first()
-        val links = videoDto.links
-
-        val allLinks = listOf(links.low, links.medium, links.high).flatten()
-            .filter { it.name in supportedPlayers }
-
-        val online = links.online?.run {
-            filterNot { "mega" in it }.map {
-                Video(it, "Player ATC", it, headers)
-            }
-        }.orEmpty()
-
-        val videoId = videoDto.id
-
-        return online + allLinks.parallelCatchingFlatMapBlocking { extractVideosFromLink(it, videoId) }
-    }
-
-    private fun extractVideosFromLink(video: VideoDto.VideoLink, videoId: Int): List<Video> {
-        val playerUrl = linkBypasser.bypass(video, videoId)
-            ?: return emptyList()
-
-        val quality = when (video.quality) {
-            "low" -> "SD"
-            "medium" -> "HD"
-            "high" -> "FULLHD"
-            else -> "SD"
-        }
-
-        return when (video.name) {
-            "send" -> sendcmExtractor.videosFromUrl(playerUrl, quality)
-            "drive" -> {
-                val id = GDRIVE_REGEX.find(playerUrl)?.groupValues?.get(0) ?: return emptyList()
-                gdriveExtractor.videosFromUrl(id, "GDrive - $quality")
-            }
-            else -> emptyList()
-        }
-    }
-
-    // ============================== Settings ==============================
-    override fun setupPreferenceScreen(screen: PreferenceScreen) {
-        ListPreference(screen.context).apply {
-            key = PREF_QUALITY_KEY
-            title = PREF_QUALITY_TITLE
-            entries = PREF_QUALITY_ENTRIES
-            entryValues = PREF_QUALITY_ENTRIES
-            setDefaultValue(PREF_QUALITY_DEFAULT)
-            summary = "%s"
-        }.also(screen::addPreference)
-
-        ListPreference(screen.context).apply {
-            key = PREF_PLAYER_KEY
-            title = PREF_PLAYER_TITLE
-            entries = PREF_PLAYER_VALUES
-            entryValues = PREF_PLAYER_VALUES
-            setDefaultValue(PREF_PLAYER_DEFAULT)
-            summary = "%s"
-        }.also(screen::addPreference)
-    }
-
-    // ============================= Utilities ==============================
-    private fun Response.getAnimeDto(): AnimeDto {
-        val jsonString = body.string()
-        return try {
-            jsonString.parseAs<AnimeDto>()
-        } catch (e: Exception) {
-            // URL intent handler moment
-            jsonString.parseAs<ResponseDto<AnimeDto>>().items.first()
-        }
-    }
-
-    private fun String.toDate(): Long {
-        return try {
-            DATE_FORMATTER.parse(this)?.time
-        } catch (_: Throwable) { null } ?: 0L
-    }
-
-    override fun List<Video>.sort(): List<Video> {
-        val quality = preferences.getString(PREF_QUALITY_KEY, PREF_QUALITY_DEFAULT)!!
-        val player = preferences.getString(PREF_PLAYER_KEY, PREF_PLAYER_DEFAULT)!!
-        return sortedWith(
-            compareBy(
-                { it.quality.contains(player) },
-                { it.quality.contains("- $quality") },
-            ),
-        ).reversed()
-    }
-
-    companion object {
-        private val DATE_FORMATTER by lazy {
-            SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.ENGLISH)
-        }
-
-        const val PREFIX_SEARCH = "slug:"
-
-        private const val HOST_URL = "https://www.animestc.net"
-
-        private const val PREF_QUALITY_KEY = "pref_quality"
-        private const val PREF_QUALITY_TITLE = "Qualidade preferida"
-        private const val PREF_QUALITY_DEFAULT = "HD"
-        private val PREF_QUALITY_ENTRIES = arrayOf("SD", "HD", "FULLHD")
-
-        private const val PREF_PLAYER_KEY = "pref_player"
-        private const val PREF_PLAYER_TITLE = "Player preferido"
-        private const val PREF_PLAYER_DEFAULT = "Sendcm"
-        private val PREF_PLAYER_VALUES = arrayOf("Sendcm", "GDrive", "Player ATC")
-
-        private val GDRIVE_REGEX = Regex("[\\w-]{28,}")
-    }
-}

src/pt/animestc/src/eu/kanade/tachiyomi/animeextension/pt/animestc/AnimesTCUrlActivity.kt

@@ -1,41 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.pt.animestc
-
-import android.app.Activity
-import android.content.ActivityNotFoundException
-import android.content.Intent
-import android.os.Bundle
-import android.util.Log
-import kotlin.system.exitProcess
-
-/**
- * Springboard that accepts https://wwww.animestc.net/animes/<item> intents
- * and redirects them to the main Aniyomi process.
- */
-class AnimesTCUrlActivity : Activity() {
-
-    private val tag = javaClass.simpleName
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        val pathSegments = intent?.data?.pathSegments
-        if (pathSegments != null && pathSegments.size > 1) {
-            val item = pathSegments[1]
-            val mainIntent = Intent().apply {
-                action = "eu.kanade.tachiyomi.ANIMESEARCH"
-                putExtra("query", "${AnimesTC.PREFIX_SEARCH}$item")
-                putExtra("filter", packageName)
-            }
-
-            try {
-                startActivity(mainIntent)
-            } catch (e: ActivityNotFoundException) {
-                Log.e(tag, e.toString())
-            }
-        } else {
-            Log.e(tag, "could not parse uri from intent $intent")
-        }
-
-        finish()
-        exitProcess(0)
-    }
-}

src/pt/animestc/src/eu/kanade/tachiyomi/animeextension/pt/animestc/dto/AnimesTCDto.kt

@@ -1,78 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.pt.animestc.dto
-
-import eu.kanade.tachiyomi.animesource.model.SAnime
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-
-@Serializable
-data class ResponseDto<T>(
-    @SerialName("data")
-    val items: List<T>,
-    val lastPage: Int,
-    val page: Int,
-)
-
-@Serializable
-data class AnimeDto(
-    val classification: String?,
-    val cover: CoverDto,
-    val id: Int,
-    val producer: String?,
-    val releaseStatus: String,
-    val synopsis: String,
-    val tags: List<TagDto>,
-    val title: String,
-    val year: Int?,
-) {
-    val status by lazy {
-        when (releaseStatus) {
-            "complete" -> SAnime.COMPLETED
-            "airing" -> SAnime.ONGOING
-            else -> SAnime.UNKNOWN
-        }
-    }
-
-    val genres by lazy { tags.joinToString(", ") { it.name } }
-
-    @Serializable
-    data class TagDto(val name: String)
-}
-
-@Serializable
-data class EpisodeDto(
-    @SerialName("seriesId")
-    val animeId: Int,
-    val cover: CoverDto?,
-    val created_at: String,
-    val number: String,
-    val slug: String,
-    val title: String,
-)
-
-@Serializable
-data class VideoDto(
-    val id: Int,
-    val links: VideoLinksDto,
-) {
-    @Serializable
-    data class VideoLinksDto(
-        val low: List<VideoLink> = emptyList(),
-        val medium: List<VideoLink> = emptyList(),
-        val high: List<VideoLink> = emptyList(),
-        val online: List<String>? = null,
-    )
-
-    @Serializable
-    data class VideoLink(
-        val index: Int,
-        val name: String,
-        val quality: String,
-    )
-}
-
-@Serializable
-data class CoverDto(
-    val originalName: String,
-) {
-    val url by lazy { "https://stc.animestc.com/$originalName" }
-}

src/pt/animestc/src/eu/kanade/tachiyomi/animeextension/pt/animestc/extractors/LinkBypasser.kt

@@ -1,42 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.pt.animestc.extractors
-
-import android.util.Base64
-import eu.kanade.tachiyomi.animeextension.pt.animestc.dto.VideoDto.VideoLink
-import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.util.asJsoup
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.json.Json
-import okhttp3.OkHttpClient
-
-class LinkBypasser(
-    private val client: OkHttpClient,
-    private val json: Json,
-) {
-    fun bypass(video: VideoLink, episodeId: Int): String? {
-        val joined = "$episodeId/${video.quality}/${video.index}"
-        val encoded = Base64.encodeToString(joined.toByteArray(), Base64.NO_WRAP)
-        val url = "$PROTECTOR_URL/link/$encoded"
-        val res = client.newCall(GET(url)).execute()
-        if (res.code != 200) {
-            return null
-        }
-
-        // Sadly we MUST wait 6s or we are going to get a HTTP 500
-        Thread.sleep(6000L)
-        val id = res.asJsoup().selectFirst("meta#link-id")!!.attr("value")
-        val apiCall = client.newCall(GET("$PROTECTOR_URL/api/link/$id")).execute()
-        if (apiCall.code != 200) {
-            return null
-        }
-
-        val apiBody = apiCall.body.string()
-        return json.decodeFromString<LinkDto>(apiBody).link
-    }
-
-    @Serializable
-    data class LinkDto(val link: String)
-
-    companion object {
-        private const val PROTECTOR_URL = "https://protetor.animestc.xyz"
-    }
-}

src/pt/animestc/src/eu/kanade/tachiyomi/animeextension/pt/animestc/extractors/SendcmExtractor.kt

@@ -1,20 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.pt.animestc.extractors
-
-import eu.kanade.tachiyomi.animesource.model.Video
-import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.util.asJsoup
-import okhttp3.Headers
-import okhttp3.OkHttpClient
-
-class SendcmExtractor(private val client: OkHttpClient) {
-    private val playerName = "Sendcm"
-
-    fun videosFromUrl(url: String, quality: String): List<Video> {
-        val doc = client.newCall(GET(url)).execute().asJsoup()
-        val videoUrl = doc.selectFirst("video#vjsplayer > source")?.attr("src")
-        return videoUrl?.let {
-            val headers = Headers.headersOf("Referer", url)
-            listOf(Video(it, "$playerName - $quality", it, headers = headers))
-        }.orEmpty()
-    }
-}

src/pt/goanimes/build.gradle

@@ -1,16 +0,0 @@
-ext {
-    extName = 'GoAnimes'
-    extClass = '.GoAnimes'
-    themePkg = 'dooplay'
-    baseUrl = 'https://goanimes.net'
-    overrideVersionCode = 13
-    isNsfw = true
-}
-
-apply from: "$rootDir/common.gradle"
-
-dependencies {
-    implementation(project(":lib:playlist-utils"))
-    implementation(project(":lib:blogger-extractor"))
-    implementation("dev.datlag.jsunpacker:jsunpacker:1.0.1")
-}

src/pt/goanimes/src/eu/kanade/tachiyomi/animeextension/pt/goanimes/GoAnimes.kt

@@ -1,185 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.pt.goanimes
-
-import eu.kanade.tachiyomi.animeextension.pt.goanimes.extractors.BloggerJWPlayerExtractor
-import eu.kanade.tachiyomi.animeextension.pt.goanimes.extractors.GoAnimesExtractor
-import eu.kanade.tachiyomi.animeextension.pt.goanimes.extractors.JsDecoder
-import eu.kanade.tachiyomi.animeextension.pt.goanimes.extractors.LinkfunBypasser
-import eu.kanade.tachiyomi.animeextension.pt.goanimes.extractors.PlaylistExtractor
-import eu.kanade.tachiyomi.animesource.model.SEpisode
-import eu.kanade.tachiyomi.animesource.model.Video
-import eu.kanade.tachiyomi.lib.bloggerextractor.BloggerExtractor
-import eu.kanade.tachiyomi.lib.playlistutils.PlaylistUtils
-import eu.kanade.tachiyomi.multisrc.dooplay.DooPlay
-import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.network.await
-import eu.kanade.tachiyomi.util.asJsoup
-import eu.kanade.tachiyomi.util.parallelCatchingFlatMapBlocking
-import okhttp3.Response
-import org.jsoup.nodes.Element
-
-class GoAnimes : DooPlay(
-    "pt-BR",
-    "GoAnimes",
-    "https://goanimes.net",
-) {
-    // ============================== Popular ===============================
-    override fun popularAnimeSelector() = "div#featured-titles article.item.tvshows > div.poster"
-
-    // =============================== Latest ===============================
-    override val latestUpdatesPath = "lancamentos"
-
-    // ============================== Episodes ==============================
-    override val seasonListSelector = "div#seasons > *"
-
-    override fun getSeasonEpisodes(season: Element): List<SEpisode> {
-        // All episodes are listed under a single page
-        season.selectFirst(episodeListSelector())?.let {
-            return getSeasonEpisodesRecursive(season)
-        }
-
-        // Episodes are listed at another page
-        val url = season.attr("href")
-        return client.newCall(GET(url, headers))
-            .execute()
-            .asJsoup()
-            .let(::getSeasonEpisodes)
-    }
-
-    private val episodeListNextPageSelector = "div.pagination span.current + a:not(.arrow_pag)"
-
-    private fun getSeasonEpisodesRecursive(season: Element): List<SEpisode> {
-        var doc = season.root()
-        return buildList {
-            do {
-                if (isNotEmpty()) {
-                    doc.selectFirst(episodeListNextPageSelector)?.let {
-                        val url = it.attr("abs:href")
-                        doc = client.newCall(GET(url, headers)).execute()
-                            .asJsoup()
-                    }
-                }
-                addAll(super.getSeasonEpisodes(doc))
-            } while (doc.selectFirst(episodeListNextPageSelector) != null)
-            reversed()
-        }
-    }
-
-    // ============================ Video Links =============================
-    override val prefQualityValues = arrayOf("240p", "360p", "480p", "720p", "1080p")
-    override val prefQualityEntries = prefQualityValues
-
-    private val goanimesExtractor by lazy { GoAnimesExtractor(client, headers) }
-    private val bloggerExtractor by lazy { BloggerExtractor(client) }
-    private val linkfunBypasser by lazy { LinkfunBypasser(client) }
-    private val playlistUtils by lazy { PlaylistUtils(client, headers) }
-
-    override fun videoListParse(response: Response): List<Video> {
-        val document = response.asJsoup()
-        val players = document.select("ul#playeroptionsul li")
-        return players.parallelCatchingFlatMapBlocking(::getPlayerVideos)
-    }
-
-    private suspend fun getPlayerVideos(player: Element): List<Video> {
-        val name = player.selectFirst("span.title")!!.text()
-            .replace("FULLHD", "1080p")
-            .replace("HD", "720p")
-            .replace("SD", "480p")
-        val url = getPlayerUrl(player)
-        return when {
-            "https://gojopoolt" in url -> {
-                val headers = headers.newBuilder()
-                    .set("referer", url)
-                    .build()
-
-                val script = client.newCall(GET(url, headers)).await()
-                    .body.string()
-                    .let { JsDecoder.decodeScript(it, false).ifBlank { it } }
-
-                script.substringAfter("sources: [")
-                    .substringBefore(']')
-                    .split('{')
-                    .drop(1)
-                    .mapNotNull {
-                        val videoUrl = it.substringAfter("file: ")
-                            .substringBefore(", ")
-                            .trim('"', '\'', ' ')
-                            .ifBlank { return@mapNotNull null }
-
-                        val resolution = it.substringAfter("label: ", "")
-                            .substringAfter('"')
-                            .substringBefore('"')
-                            .ifBlank { name.split('-').last().trim() }
-
-                        val partialName = name.split('-').first().trim()
-                        return when {
-                            videoUrl.contains(".m3u8") -> {
-                                playlistUtils.extractFromHls(
-                                    videoUrl,
-                                    url,
-                                    videoNameGen = {
-                                        "$partialName - ${it.replace("Video", resolution)}"
-                                    },
-                                )
-                            }
-                            else -> listOf(Video(videoUrl, "$partialName - $resolution", videoUrl, headers))
-                        }
-                    }
-            }
-            listOf("/bloggerjwplayer", "/m3u8", "/multivideo").any { it in url } -> {
-                val script = client.newCall(GET(url)).await()
-                    .body.string()
-                    .let { JsDecoder.decodeScript(it, true).ifBlank { JsDecoder.decodeScript(it, false).ifBlank { it } } }
-                when {
-                    "/bloggerjwplayer" in url ->
-                        BloggerJWPlayerExtractor.videosFromScript(script)
-                    "/m3u8" in url ->
-                        PlaylistExtractor.videosFromScript(script)
-                    "/multivideo" in url ->
-                        script.substringAfter("attr")
-                            .substringAfter(" \"")
-                            .substringBefore('"')
-                            .let { goanimesExtractor.videosFromUrl(it, name) }
-
-                    else -> emptyList<Video>()
-                }
-            }
-            "www.blogger.com" in url -> bloggerExtractor.videosFromUrl(url, headers)
-            else -> goanimesExtractor.videosFromUrl(url, name)
-        }
-    }
-
-    private suspend fun getPlayerUrl(player: Element): String {
-        val type = player.attr("data-type")
-        val id = player.attr("data-post")
-        val num = player.attr("data-nume")
-        val url = client.newCall(GET("$baseUrl/wp-json/dooplayer/v2/$id/$type/$num"))
-            .await()
-            .body.string()
-            .substringAfter("\"embed_url\":\"")
-            .substringBefore("\",")
-            .replace("\\", "")
-
-        return when {
-            "/protetorlinks/" in url -> {
-                val link = client.newCall(GET(url)).await()
-                    .asJsoup()
-                    .selectFirst("a[href]")!!.attr("href")
-
-                client.newCall(GET(link)).await()
-                    .use(linkfunBypasser::getIframeUrl)
-            }
-            else -> url
-        }
-    }
-    // ============================= Utilities ==============================
-
-    override fun List<Video>.sort(): List<Video> {
-        val quality = preferences.getString(videoSortPrefKey, videoSortPrefDefault)!!
-        return sortedWith(
-            compareBy(
-                { it.quality.contains(quality) },
-                { Regex("""(\d+)p""").find(it.quality)?.groupValues?.get(1)?.toIntOrNull() ?: 0 },
-            ),
-        ).reversed()
-    }
-}

src/pt/goanimes/src/eu/kanade/tachiyomi/animeextension/pt/goanimes/extractors/BloggerJWPlayerExtractor.kt

@@ -1,18 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.pt.goanimes.extractors
-
-import eu.kanade.tachiyomi.animesource.model.Video
-
-object BloggerJWPlayerExtractor {
-    fun videosFromScript(script: String): List<Video> {
-        val sources = script.substringAfter("sources: [").substringBefore("],")
-
-        return sources.split("{").drop(1).map {
-            val label = it.substringAfter("label").substringAfter(":\"").substringBefore('"')
-            val videoUrl = it.substringAfter("file")
-                .substringAfter(":\"")
-                .substringBefore('"')
-                .replace("\\", "")
-            Video(videoUrl, "BloggerJWPlayer - $label", videoUrl)
-        }
-    }
-}

src/pt/goanimes/src/eu/kanade/tachiyomi/animeextension/pt/goanimes/extractors/GoAnimesExtractor.kt

@@ -1,81 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.pt.goanimes.extractors
-
-import android.util.Base64
-import dev.datlag.jsunpacker.JsUnpacker
-import eu.kanade.tachiyomi.animesource.model.Video
-import eu.kanade.tachiyomi.lib.playlistutils.PlaylistUtils
-import eu.kanade.tachiyomi.network.GET
-import okhttp3.Headers
-import okhttp3.HttpUrl.Companion.toHttpUrl
-import okhttp3.OkHttpClient
-
-class GoAnimesExtractor(private val client: OkHttpClient, private val headers: Headers) {
-    private val playlistUtils by lazy { PlaylistUtils(client, headers) }
-
-    fun videosFromUrl(url: String, name: String): List<Video> {
-        val body = client.newCall(GET(url, headers)).execute()
-            .body.string()
-
-        val decodedBody = JsUnpacker.unpackAndCombine(body)
-            ?: JsDecoder.decodeScript(body, false).takeIf(String::isNotEmpty)
-            ?: JsDecoder.decodeScript(body, true).takeIf(String::isNotEmpty)
-            ?: body
-
-        val partialName = name.split('-').first().trim()
-        val resolution = name.split('-').last().trim()
-
-        return when {
-            "/proxy/v.php" in url -> {
-                val playlistUrl = JsUnpacker.unpackAndCombine(body)
-                    ?.substringAfterLast("player(\\'", "")
-                    ?.substringBefore("\\'", "")
-                    ?.takeIf(String::isNotEmpty)
-                    ?: return emptyList()
-
-                playlistUtils.extractFromHls(
-                    playlistUrl,
-                    url,
-                    videoNameGen = { "$partialName - ${it.replace("Video", resolution)}" },
-                )
-            }
-            "/proxy/api3/" in url -> {
-                val playlistUrl = body.substringAfter("sources:", "")
-                    .substringAfter("file:", "")
-                    .substringAfter("'", "")
-                    .substringBefore("'", "")
-                    .takeIf(String::isNotEmpty)
-                    ?: return emptyList()
-
-                val fixedUrl = if (playlistUrl.contains("/aHR0")) {
-                    val encoded = playlistUrl.substringAfterLast("/").substringBefore(".")
-                    String(Base64.decode(encoded, Base64.DEFAULT))
-                } else {
-                    playlistUrl
-                }
-
-                val referer = url.toHttpUrl().queryParameter("url") ?: url
-                playlistUtils.extractFromHls(
-                    fixedUrl,
-                    referer,
-                    videoNameGen = { "$partialName - ${it.replace("Video", resolution)}" },
-                )
-            }
-            "jwplayer" in decodedBody && "sources:" in decodedBody -> {
-                val videos = PlaylistExtractor.videosFromScript(decodedBody, partialName)
-
-                if ("label:" !in decodedBody && videos.size === 1) {
-                    return playlistUtils.extractFromHls(
-                        videos[0].url,
-                        url,
-                        videoNameGen = { "$partialName - ${it.replace("Video", resolution)}" },
-                    )
-                }
-
-                videos
-            }
-            else -> emptyList()
-        }
-    }
-}
-
-private const val PLAYER_NAME = "GoAnimes"

src/pt/goanimes/src/eu/kanade/tachiyomi/animeextension/pt/goanimes/extractors/JsDecoder.kt

@@ -1,48 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.pt.goanimes.extractors
-
-import android.util.Base64
-import kotlin.math.pow
-
-object JsDecoder {
-    private fun convertToNum(thing: String, limit: Float): Int {
-        return thing.split("")
-            .reversed()
-            .map { it.toIntOrNull() ?: 0 }
-            .reduceIndexed { index: Int, acc, num ->
-                acc + (num * limit.pow(index - 1)).toInt()
-            }
-    }
-
-    fun decodeScript(encodedString: String, magicStr: String, offset: Int, limit: Int): String {
-        val regex = "\\w".toRegex()
-        return encodedString
-            .split(magicStr[limit])
-            .dropLast(1)
-            .map { str ->
-                val replaced = regex.replace(str) { magicStr.indexOf(it.value).toString() }
-                val charInt = convertToNum(replaced, limit.toFloat()) - offset
-                Char(charInt)
-            }.joinToString("")
-    }
-
-    fun decodeScript(html: String, isB64: Boolean = true): String {
-        val script = if (isB64) {
-            html.substringAfter(";base64,")
-                .substringBefore('"')
-                .let { String(Base64.decode(it, Base64.DEFAULT)) }
-        } else {
-            html
-        }
-
-        val regex = """\}\("(\w+)",.*?"(\w+)",(\d+),(\d+),.*?\)""".toRegex()
-        return regex.find(script)
-            ?.run {
-                decodeScript(
-                    groupValues[1], // encoded data
-                    groupValues[2], // magic string
-                    groupValues[3].toIntOrNull() ?: 0, // offset
-                    groupValues[4].toIntOrNull() ?: 0, // limit
-                )
-            } ?: ""
-    }
-}

src/pt/goanimes/src/eu/kanade/tachiyomi/animeextension/pt/goanimes/extractors/LinkfunBypasser.kt

@@ -1,54 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.pt.goanimes.extractors
-
-import android.util.Base64
-import eu.kanade.tachiyomi.network.POST
-import eu.kanade.tachiyomi.util.asJsoup
-import okhttp3.FormBody
-import okhttp3.Headers
-import okhttp3.OkHttpClient
-import okhttp3.Response
-
-class LinkfunBypasser(private val client: OkHttpClient) {
-    fun getIframeUrl(page: Response): String {
-        val docString = page.body.string()
-        val document = if (docString.startsWith("<script")) {
-            page.asJsoup(decodeAtob(docString))
-        } else { page.asJsoup(docString) }
-
-        val newHeaders = Headers.headersOf("Referer", document.location())
-
-        val iframe = document.selectFirst("iframe[src]")
-
-        return if (iframe != null) {
-            iframe.attr("src")
-        } else {
-            val formBody = FormBody.Builder().apply {
-                document.select("input[name]").forEach {
-                    add(it.attr("name"), it.attr("value"))
-                }
-            }.build()
-
-            val formUrl = document.selectFirst("form")!!.attr("action")
-            client.newCall(POST(formUrl, newHeaders, formBody))
-                .execute()
-                .let(::getIframeUrl)
-        }
-    }
-
-    companion object {
-        fun decodeAtob(html: String): String {
-            val atobContent = html.substringAfter("atob(\"").substringBefore("\"));")
-            val hexAtob = atobContent.replace("\\x", "").decodeHex()
-            val decoded = Base64.decode(hexAtob, Base64.DEFAULT)
-            return String(decoded)
-        }
-
-        // Stolen from AnimixPlay(EN) / GogoCdnExtractor
-        private fun String.decodeHex(): ByteArray {
-            check(length % 2 == 0) { "Must have an even length" }
-            return chunked(2)
-                .map { it.toInt(16).toByte() }
-                .toByteArray()
-        }
-    }
-}

src/pt/goanimes/src/eu/kanade/tachiyomi/animeextension/pt/goanimes/extractors/PlaylistExtractor.kt

@@ -1,30 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.pt.goanimes.extractors
-
-import eu.kanade.tachiyomi.animesource.model.Video
-
-object PlaylistExtractor {
-    fun videosFromScript(script: String, prefix: String = "Playlist"): List<Video> {
-        val sources = script.substringAfter("sources: [").substringBefore("],")
-
-        return sources.split("{").drop(1).mapNotNull { source ->
-            val url = source.substringAfter("file:")
-                .substringAfter('"', "")
-                .substringBefore('"', "")
-                .takeIf(String::isNotEmpty)
-                ?: source.substringAfter("file:")
-                    .substringAfter("'", "")
-                    .substringBefore("'", "")
-                    .takeIf(String::isNotEmpty)
-
-            if (url.isNullOrBlank()) {
-                return@mapNotNull null
-            }
-
-            val label = source.substringAfter("label:").substringAfter('"').substringBefore('"')
-                .replace("FHD", "1080p")
-                .replace("HD", "720p")
-                .replace("SD", "480p")
-            Video(url, "$prefix - $label", url)
-        }
-    }
-}

src/pt/listadeanimes/build.gradle

@@ -1,7 +0,0 @@
-ext {
-    extName = 'Lista de Animes'
-    extClass = '.ListaDeAnimes'
-    extVersionCode = 2
-}
-
-apply from: "$rootDir/common.gradle"

src/pt/listadeanimes/src/eu/kanade/tachiyomi/animeextension/pt/listadeanimes/ListaDeAnimes.kt

@@ -1,112 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.pt.listadeanimes
-
-import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
-import eu.kanade.tachiyomi.animesource.model.SAnime
-import eu.kanade.tachiyomi.animesource.model.SEpisode
-import eu.kanade.tachiyomi.animesource.model.Video
-import eu.kanade.tachiyomi.animesource.online.ParsedAnimeHttpSource
-import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.util.asJsoup
-import okhttp3.Request
-import okhttp3.Response
-import org.jsoup.nodes.Document
-import org.jsoup.nodes.Element
-
-class ListaDeAnimes : ParsedAnimeHttpSource() {
-    override val name = "Lista de Animes"
-
-    override val baseUrl = "https://www.listadeanimes.com"
-
-    override val lang = "pt-BR"
-
-    override val supportsLatest = false
-
-    override fun headersBuilder() = super.headersBuilder()
-        .add("Referer", baseUrl)
-
-    // ============================== Popular ===============================
-    override fun popularAnimeRequest(page: Int) = GET("$baseUrl/page/$page")
-
-    override fun popularAnimeSelector() = "article.post.excerpt > div.capa:not(:has(a[href=$baseUrl/anime-lista-online]))"
-
-    override fun popularAnimeFromElement(element: Element) = SAnime.create().apply {
-        setUrlWithoutDomain(element.selectFirst("a")!!.attr("href"))
-        val img = element.selectFirst("img")!!
-        title = titleCase(img.attr("title").substringBefore(" todos os episódios"))
-        thumbnail_url = img.attr("data-src")
-    }
-
-    override fun popularAnimeNextPageSelector() = "a.next.page-numbers"
-
-    // =============================== Latest ===============================
-    override fun latestUpdatesRequest(page: Int): Request = throw UnsupportedOperationException()
-    override fun latestUpdatesSelector(): String = throw UnsupportedOperationException()
-    override fun latestUpdatesFromElement(element: Element): SAnime = throw UnsupportedOperationException()
-    override fun latestUpdatesNextPageSelector() = throw UnsupportedOperationException()
-
-    // =============================== Search ===============================
-    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList) = GET("$baseUrl/page/$page?s=$query")
-    override fun searchAnimeParse(response: Response) = popularAnimeParse(response)
-    override fun searchAnimeSelector() = popularAnimeSelector()
-    override fun searchAnimeFromElement(element: Element) = popularAnimeFromElement(element)
-    override fun searchAnimeNextPageSelector() = popularAnimeNextPageSelector()
-
-    // =========================== Anime Details ============================
-    override fun animeDetailsParse(document: Document) = SAnime.create().apply {
-        setUrlWithoutDomain(document.location())
-        val titleText = document.selectFirst("h1.title.single-title")!!.text()
-        title = titleCase(titleText.substringBefore(" todos os episódios"))
-        thumbnail_url = document.selectFirst("img.aligncenter.size-full")?.attr("src")
-        val infos = document.selectFirst("div#content.post-single-content > center")
-        val infosText = infos?.run {
-            html()
-                .replace("<br>", "\n")
-                .replace("<b>", "")
-                .replace("</b>", "")
-        }?.let { "\n\n$it" }.orEmpty()
-
-        val sinopse = document.selectFirst("div#content > *:contains(Sinopse)")?.nextElementSibling()
-        description = (sinopse?.text() ?: "Sem sinopse.") + infosText
-        genre = document.select("a[rel=tag]").joinToString { it.text() }
-    }
-
-    // ============================== Episodes ==============================
-    override fun episodeListSelector() = "div.videos > ul"
-
-    override fun episodeListParse(response: Response): List<SEpisode> {
-        val doc = response.asJsoup()
-        return doc.select("div.videos > ul > li:gt(0)")
-            .map(::episodeFromElement)
-            .reversed()
-    }
-    override fun episodeFromElement(element: Element): SEpisode {
-        return SEpisode.create().apply {
-            episode_number = runCatching {
-                element.selectFirst("string")!!
-                    .text()
-                    .substringAfter(" ")
-                    .toFloat()
-            }.getOrDefault(0F)
-            name = element.text().substringAfter("► ")
-            url = element.attr("id")
-        }
-    }
-
-    // ============================ Video Links =============================
-    override suspend fun getVideoList(episode: SEpisode): List<Video> {
-        return listOf(Video(episode.url, episode.name, episode.url))
-    }
-
-    override fun videoListSelector() = throw UnsupportedOperationException()
-    override fun videoListRequest(episode: SEpisode) = throw UnsupportedOperationException()
-    override fun videoListParse(response: Response) = throw UnsupportedOperationException()
-    override fun videoFromElement(element: Element) = throw UnsupportedOperationException()
-    override fun videoUrlParse(document: Document) = throw UnsupportedOperationException()
-
-    // ============================= Utilities ==============================
-    private fun titleCase(str: String): String {
-        return str.split(' ')
-            .map { it.replaceFirstChar(Char::uppercase) }
-            .joinToString(" ")
-    }
-}