.gitignore

@@ -18,4 +18,3 @@ captures
 **/xcshareddata/WorkspaceSettings.xcsettings
 node_modules/
 /composeApp/release/
-/test_books/

composeApp/build.gradle.kts

@@ -3,7 +3,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 val appVersionName = "1.0"
-val appVersionCode = 4
+val appVersionCode = 3
 val appVersionDisplay = "$appVersionName.$appVersionCode"
 
 plugins {

composeApp/src/commonMain/kotlin/net/sergeych/toread/App.kt

@@ -46,11 +46,6 @@ private data class PendingLibraryDelete(
     val restore: () -> Unit,
 )
 
-internal data class LibraryItemRefreshRequest(
-    val id: Long,
-    val fileId: String,
-)
-
 @Composable
 @Preview
 fun App() {
@@ -170,23 +165,15 @@ private fun BookReaderApp(
     ) -> Unit,
 ) {
     var state by remember { mutableStateOf<AppState>(AppState.LoadingStartup) }
-    var libraryBackState by remember { mutableStateOf<AppState.Library?>(null) }
     var activeScan by remember { mutableStateOf<LibraryScanProgress?>(null) }
     var scanJob by remember { mutableStateOf<Job?>(null) }
     var pendingDelete by remember { mutableStateOf<PendingLibraryDelete?>(null) }
     var pendingDeleteJob by remember { mutableStateOf<Job?>(null) }
     var hiddenDeletedFileIds by remember { mutableStateOf<Set<String>>(emptySet()) }
     var nextDeleteId by remember { mutableStateOf(0L) }
-    var nextLibraryItemRefreshId by remember { mutableStateOf(0L) }
-    var libraryItemRefreshRequest by remember { mutableStateOf<LibraryItemRefreshRequest?>(null) }
     var imageViewer by remember { mutableStateOf<ViewedBookImage?>(null) }
     val scope = rememberCoroutineScope()
 
-    fun refreshLibraryItem(fileId: String) {
-        nextLibraryItemRefreshId += 1
-        libraryItemRefreshRequest = LibraryItemRefreshRequest(nextLibraryItemRefreshId, fileId)
-    }
-
     LaunchedEffect(Unit) {
         state = loadStartupState()
     }
@@ -292,11 +279,7 @@ private fun BookReaderApp(
             )
             is AppState.Reader -> {
                 scope.launch { saveActiveReadingFileId(null) }
-                refreshLibraryItem(current.fileId)
-                val backState = libraryBackState?.copy(message = current.message)
-                    ?: AppState.Library(current.libraryItems, current.scanPath, current.message)
-                libraryBackState = null
-                backState
+                AppState.Library(current.libraryItems, current.scanPath, current.message)
             }
             is AppState.Scan -> AppState.Library(current.items, current.scanPath, current.message)
             is AppState.Error -> AppState.LoadingStartup
@@ -357,37 +340,17 @@ private fun BookReaderApp(
         }
     }
 
-    Box(Modifier.fillMaxSize()) {
-        val currentLibraryState = when (val current = state) {
-            is AppState.Library -> current
-            is AppState.Reader, is AppState.BookInfo -> libraryBackState
-            else -> null
-        }
-        currentLibraryState?.let { libraryState ->
-            LibraryScreen(
-                state = libraryState,
+    when (val current = state) {
+        AppState.LoadingStartup -> LoadingScreen(strings.loadingOpeningBook)
+        is AppState.Library -> LibraryScreen(
+            state = current,
             activeScan = activeScan,
-                itemRefreshRequest = libraryItemRefreshRequest,
             hiddenFileIds = hiddenDeletedFileIds + pendingDelete?.request?.fileId?.let(::setOf).orEmpty(),
-                onStateChange = { next ->
-                    val currentState = state
-                    if (next is AppState.Reader && currentState is AppState.Library) {
-                        libraryBackState = currentState
-                    }
-                    state = next
-                },
-                onNavigateToScan = {
-                    libraryBackState = null
-                    state = AppState.Scan(libraryState.items, libraryState.scanPath, libraryState.message)
-                },
+            onStateChange = { state = it },
+            onNavigateToScan = { state = AppState.Scan(current.items, current.scanPath, current.message) },
             onStartScan = ::startScan,
             onDeleteRequested = ::requestDelete,
         )
-        }
-
-        when (val current = state) {
-            AppState.LoadingStartup -> LoadingScreen(strings.loadingOpeningBook)
-            is AppState.Library -> Unit
         is AppState.Scan -> ScanScreen(
             state = current,
             activeScan = activeScan,
@@ -402,7 +365,6 @@ private fun BookReaderApp(
             book = current.book,
             onImageOpen = { imageViewer = it },
             onThemeToggle = onThemeToggle,
-                onBookChanged = ::refreshLibraryItem,
             onBookInfo = {
                 state = AppState.BookInfo(
                     fileId = current.fileId,
@@ -413,9 +375,7 @@ private fun BookReaderApp(
                 )
             },
             onDeleted = { message ->
-                    state = libraryBackState?.copy(message = message)
-                        ?: AppState.Library(emptyList(), current.scanPath, message)
-                    libraryBackState = null
+                state = AppState.Library(emptyList(), current.scanPath, message)
             },
             onDeleteRequested = ::requestDelete,
             onBack = ::navigateBack,
@@ -428,7 +388,6 @@ private fun BookReaderApp(
         )
         is AppState.Error -> ErrorScreen(current.message, onBack = ::navigateBack)
     }
-    }
 
     imageViewer?.let { image ->
         ImageViewer(

composeApp/src/commonMain/kotlin/net/sergeych/toread/LibraryScreen.kt

@@ -82,7 +82,6 @@ import kotlinx.coroutines.launch
 internal fun LibraryScreen(
     state: AppState.Library,
     activeScan: LibraryScanProgress?,
-    itemRefreshRequest: LibraryItemRefreshRequest?,
     hiddenFileIds: Set<String>,
     onStateChange: (AppState) -> Unit,
     onNavigateToScan: () -> Unit,
@@ -148,13 +147,6 @@ internal fun LibraryScreen(
         recentlyAddedItems = loadRecentlyAddedLibraryItems(since, RecentlyAddedLimit)
     }
 
-    suspend fun refreshLibraryItem(fileId: String) {
-        val updatedItem = loadLibraryItem(fileId) ?: return
-        items = items.replaceLibraryItem(updatedItem)
-        searchResults = searchResults.replaceLibraryItem(updatedItem)
-        recentlyAddedItems = recentlyAddedItems.replaceLibraryItem(updatedItem)
-    }
-
     fun refresh(nextMessage: String? = message) {
         message = nextMessage
         scope.launch {
@@ -255,10 +247,6 @@ internal fun LibraryScreen(
         }
     }
 
-    LaunchedEffect(itemRefreshRequest) {
-        itemRefreshRequest?.let { refreshLibraryItem(it.fileId) }
-    }
-
     LaunchedEffect(searchText) {
         val query = searchText
         if (query.isBlank()) {

composeApp/src/commonMain/kotlin/net/sergeych/toread/ReaderContent.kt

@@ -46,7 +46,6 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.drawWithContent
 import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.geometry.Rect
 import androidx.compose.ui.geometry.Size
 import androidx.compose.ui.graphics.BlendMode
 import androidx.compose.ui.graphics.Brush
@@ -80,7 +79,6 @@ import androidx.compose.ui.text.style.LineBreak
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.text.style.TextDecoration
 import androidx.compose.ui.text.withStyle
-import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.isSpecified
 import androidx.compose.ui.unit.sp
@@ -98,6 +96,7 @@ import net.sergeych.toread.fb2.Fb2TextSpan
 import net.sergeych.toread.fb2.Fb2TextStyle
 import net.sergeych.toread.text.HyphenationRegistry
 import net.sergeych.toread.text.SoftHyphen
+import kotlin.math.min
 import kotlinx.coroutines.launch
 import kotlin.math.max
 import kotlin.math.min
@@ -118,7 +117,7 @@ internal fun ContinuousBookReader(
     val hyphenation = remember { HyphenationRegistry() }
     val scope = rememberCoroutineScope()
     val textLineMetricsByItem = remember(contentPlan) { mutableStateMapOf<Int, TextLineMetrics>() }
-    val contentPadding = PaddingValues(top=6.dp, bottom = 6.dp, start = 4.dp, end = 6.dp)
+    val contentPadding = PaddingValues(6.dp)
     val userScrollConnection = remember(onUserScroll) {
         object : NestedScrollConnection {
             override fun onPreScroll(available: Offset, source: NestedScrollSource): Offset {
@@ -946,13 +945,6 @@ private val isDesktopPlatform: Boolean by lazy {
     getPlatform().name.startsWith("Java")
 }
 
-private val MinimumBookImageMaxDimension = 800.dp
-
-private fun minimumBookImageMaxDimension(availableWidth: Dp): Dp {
-    val relativeMinimum = availableWidth * 0.55f
-    return if (MinimumBookImageMaxDimension < relativeMinimum) MinimumBookImageMaxDimension else relativeMinimum
-}
-
 private fun TextLayoutResult.endsAtSoftHyphen(text: String, line: Int): Boolean {
     val end = getLineEnd(line, visibleEnd = false)
     return text.getOrNull(end - 1) == SoftHyphen || text.getOrNull(end) == SoftHyphen
@@ -1004,17 +996,8 @@ private fun BookImage(
             val imageAspectRatio = bitmap.width.toFloat() / bitmap.height.coerceAtLeast(1).toFloat()
             val imageModifier = if (fitBackgroundToBitmapBounds) {
                 val bitmapWidth = with(density) { bitmap.width.toDp() }
-                val bitmapHeight = with(density) { bitmap.height.toDp() }
-                val bitmapMaxDimension = if (bitmapWidth > bitmapHeight) bitmapWidth else bitmapHeight
-                val minimumMaxDimension = minimumBookImageMaxDimension(maxWidth)
-                val displayWidth = when {
-                    bitmapMaxDimension < minimumMaxDimension ->
-                        bitmapWidth * (minimumMaxDimension.value / bitmapMaxDimension.value)
-                    bitmapWidth < maxWidth -> bitmapWidth
-                    else -> maxWidth
-                }
                 Modifier
-                    .width(displayWidth)
+                    .width(if (bitmapWidth < maxWidth) bitmapWidth else maxWidth)
                     .aspectRatio(imageAspectRatio)
             } else {
                 Modifier.fillMaxSize()
@@ -1098,14 +1081,7 @@ private fun Modifier.readerLinkTapHandler(
 ): Modifier = pointerInput(annotatedText, textLayout, onLinkOpen) {
     awaitEachGesture {
         val down = awaitFirstDown(requireUnconsumed = false, pass = PointerEventPass.Main)
-        val link = textLayout?.readerLinkAt(
-            text = annotatedText,
-            position = down.position,
-            minimumTouchWidthPx = ReaderLinkMinimumTouchWidth.toPx(),
-            minimumTouchHeightPx = ReaderLinkMinimumTouchHeight.toPx(),
-            horizontalPaddingPx = ReaderLinkHorizontalTouchPadding.toPx(),
-            verticalPaddingPx = ReaderLinkVerticalTouchPadding.toPx(),
-        )
+        val link = textLayout?.readerLinkAt(annotatedText, down.position)
         if (link == null) {
             waitForUpOrCancellation(pass = PointerEventPass.Main)
             return@awaitEachGesture
@@ -1120,78 +1096,11 @@ private fun Modifier.readerLinkTapHandler(
     }
 }
 
-private fun TextLayoutResult.readerLinkAt(
-    text: AnnotatedString,
-    position: Offset,
-    minimumTouchWidthPx: Float,
-    minimumTouchHeightPx: Float,
-    horizontalPaddingPx: Float,
-    verticalPaddingPx: Float,
-): String? =
-    text.getStringAnnotations(ReaderLinkAnnotationTag, 0, text.length)
-        .firstOrNull { annotation ->
-            readerLinkTouchBounds(
-                start = annotation.start,
-                end = annotation.end,
-                minimumTouchWidthPx = minimumTouchWidthPx,
-                minimumTouchHeightPx = minimumTouchHeightPx,
-                horizontalPaddingPx = horizontalPaddingPx,
-                verticalPaddingPx = verticalPaddingPx,
-            ).any { it.contains(position) }
-        }
+private fun TextLayoutResult.readerLinkAt(text: AnnotatedString, position: Offset): String? {
+    val offset = getOffsetForPosition(position)
+    return text.getStringAnnotations(ReaderLinkAnnotationTag, offset, offset)
+        .firstOrNull()
         ?.item
-
-private fun TextLayoutResult.readerLinkTouchBounds(
-    start: Int,
-    end: Int,
-    minimumTouchWidthPx: Float,
-    minimumTouchHeightPx: Float,
-    horizontalPaddingPx: Float,
-    verticalPaddingPx: Float,
-): List<Rect> {
-    if (start >= end) return emptyList()
-
-    val boundsByLine = linkedMapOf<Int, Rect>()
-    val safeEnd = min(end, layoutInput.text.length)
-    for (offset in start until safeEnd) {
-        val line = getLineForOffset(offset)
-        val bounds = getBoundingBox(offset)
-        boundsByLine[line] = boundsByLine[line]?.union(bounds) ?: bounds
-    }
-
-    return boundsByLine.values.map { bounds ->
-        bounds.withCenteredTouchPadding(
-            minimumWidth = minimumTouchWidthPx,
-            minimumHeight = minimumTouchHeightPx,
-            horizontalPadding = horizontalPaddingPx,
-            verticalPadding = verticalPaddingPx,
-        )
-    }
-}
-
-private fun Rect.union(other: Rect): Rect =
-    Rect(
-        left = min(left, other.left),
-        top = min(top, other.top),
-        right = max(right, other.right),
-        bottom = max(bottom, other.bottom),
-    )
-
-private fun Rect.withCenteredTouchPadding(
-    minimumWidth: Float,
-    minimumHeight: Float,
-    horizontalPadding: Float,
-    verticalPadding: Float,
-): Rect {
-    val touchWidth = max(width + horizontalPadding * 2f, minimumWidth)
-    val touchHeight = max(height + verticalPadding * 2f, minimumHeight)
-    val center = center
-    return Rect(
-        left = center.x - touchWidth / 2f,
-        top = center.y - touchHeight / 2f,
-        right = center.x + touchWidth / 2f,
-        bottom = center.y + touchHeight / 2f,
-    )
 }
 
 private fun AnnotatedString.hasReaderLinks(): Boolean =
@@ -1346,12 +1255,12 @@ internal fun buildReaderContentPlan(book: Fb2Book): ReaderContentPlan {
         epigraph.textAuthors.forEach { addTextSentences(itemIndex, it) }
     }
 
-    fun addSection(section: Fb2Section, readerDepth: Int) {
+    fun addSection(section: Fb2Section, depth: Int) {
         if (section.title.isNullOrBlank()) {
             elements += ReaderElement.SectionSeparator
         } else {
             val itemIndex = elements.size
-            elements += ReaderElement.SectionTitle(section.title!!, readerDepth)
+            elements += ReaderElement.SectionTitle(section.title!!, depth)
             sentences += ReadAloudSentence(
                 index = sentences.size,
                 itemIndex = itemIndex,
@@ -1363,19 +1272,18 @@ internal fun buildReaderContentPlan(book: Fb2Book): ReaderContentPlan {
             )
             pendingPauseBeforeMillis = 0L
         }
-        val blocks = section.readableBlocks()
-        blocks.forEach { block ->
+        section.readableBlocks().forEach { block ->
             val itemIndex = elements.size
             when (block) {
                 Fb2Block.EmptyLine -> elements += ReaderElement.FixedSpacer(16)
                 is Fb2Block.Image -> elements += ReaderElement.BookImage(block.image)
                 is Fb2Block.Paragraph -> {
                     addTextSentences(itemIndex, block.content)
-                    elements += ReaderElement.Paragraph(block.content, readerDepth)
+                    elements += ReaderElement.Paragraph(block.content, depth)
                 }
                 is Fb2Block.Poem -> {
                     addPoemSentences(itemIndex, block.poem)
-                    elements += ReaderElement.Poem(block.poem, readerDepth)
+                    elements += ReaderElement.Poem(block.poem, depth)
                 }
                 is Fb2Block.Subtitle -> {
                     addTextSentences(
@@ -1388,16 +1296,15 @@ internal fun buildReaderContentPlan(book: Fb2Book): ReaderContentPlan {
                 }
                 is Fb2Block.Epigraph -> {
                     addEpigraphSentences(itemIndex, block.epigraph)
-                    elements += ReaderElement.Epigraph(block.epigraph, readerDepth)
+                    elements += ReaderElement.Epigraph(block.epigraph, depth)
                 }
                 is Fb2Block.Cite -> {
                     addCiteSentences(itemIndex, block.cite)
-                    elements += ReaderElement.Cite(block.cite, readerDepth)
+                    elements += ReaderElement.Cite(block.cite, depth)
                 }
             }
         }
-        val childDepth = if (blocks.isEmpty()) readerDepth else readerDepth + 1
-        section.sections.forEach { addSection(it, childDepth) }
+        section.sections.forEach { addSection(it, depth + 1) }
     }
 
     elements += ReaderElement.Cover
@@ -1614,10 +1521,6 @@ private const val CombiningAcuteAccent = '\u0301'
 private const val ReadAloudStressableLetters = "аеёиоуыэюяАЕЁИОУЫЭЮЯaeiouyAEIOUY"
 private const val ReaderLinkAnnotationTag = "fb2-link"
 private val LinkTextColor = Color(0xFF0B57D0)
-private val ReaderLinkMinimumTouchWidth = 44.dp
-private val ReaderLinkMinimumTouchHeight = 40.dp
-private val ReaderLinkHorizontalTouchPadding = 10.dp
-private val ReaderLinkVerticalTouchPadding = 6.dp
 
 private val ReadAloudHardcodedTextReplacements = listOf(
     ReadAloudTextReplacement(from = "Господа,", to = "Господ/а,", caseSensitive = true),

composeApp/src/commonMain/kotlin/net/sergeych/toread/ReaderScreen.kt

@@ -66,7 +66,6 @@ internal fun BookView(
     book: Fb2Book,
     onImageOpen: (ViewedBookImage) -> Unit,
     onThemeToggle: () -> Unit,
-    onBookChanged: (String) -> Unit,
     onBookInfo: () -> Unit,
     onDeleted: (String?) -> Unit,
     onDeleteRequested: (
@@ -111,7 +110,6 @@ internal fun BookView(
         scope.launch {
             if (markLibraryReadingStatus(fileId, status)) {
                 libraryItem = loadLibraryItem(fileId) ?: libraryItem?.copy(readingStatus = status)
-                onBookChanged(fileId)
                 if (status == BookReadingStatus.READ) markedRead = true
                 if (status == BookReadingStatus.NEW) markedRead = false
                 if (status == BookReadingStatus.NOT_INTERESTED) {
@@ -136,7 +134,6 @@ internal fun BookView(
         markedRead = item?.readingStatus == BookReadingStatus.READ
         if (item?.readingStatus?.shouldBecomeReadingOnOpen() == true && markLibraryReadingStatus(fileId, BookReadingStatus.READING)) {
             libraryItem = loadLibraryItem(fileId) ?: item.copy(readingStatus = BookReadingStatus.READING)
-            onBookChanged(fileId)
         }
     }
 
@@ -185,7 +182,6 @@ internal fun BookView(
                 markedRead = true
                 if (markLibraryReadingStatus(fileId, BookReadingStatus.READ)) {
                     libraryItem = loadLibraryItem(fileId) ?: libraryItem?.copy(readingStatus = BookReadingStatus.READ)
-                    onBookChanged(fileId)
                 }
             }
     }
@@ -234,7 +230,6 @@ internal fun BookView(
                     scope.launch {
                         if (markLibraryFavorite(fileId, favorite)) {
                             libraryItem = loadLibraryItem(fileId) ?: libraryItem?.copy(favorite = favorite)
-                            onBookChanged(fileId)
                             showMessage(if (favorite) strings.addedToFavorites() else strings.removedFromFavorites())
                         } else {
                             showMessage(strings.couldNotUpdateBook)

composeApp/src/commonTest/kotlin/net/sergeych/toread/ReadAloudContentPlanTest.kt

@@ -216,95 +216,6 @@ class ReadAloudContentPlanTest {
         )
     }
 
-    @Test
-    fun wrapperOnlyTopSectionDoesNotIndentChildParagraphs() {
-        val plan = buildReaderContentPlan(
-            Fb2Book(
-                title = "Book",
-                sections = listOf(
-                    Fb2Section(
-                        title = "Wrapper title",
-                        sections = listOf(
-                            Fb2Section(
-                                title = "Chapter",
-                                blocks = listOf(paragraph("Chapter text.")),
-                            ),
-                        ),
-                    ),
-                ),
-            ),
-        )
-
-        assertEquals(0, plan.elements.filterIsInstance<ReaderElement.Paragraph>().single().depth)
-        assertEquals(
-            listOf(0, 0),
-            plan.elements.filterIsInstance<ReaderElement.SectionTitle>().map { it.depth },
-        )
-    }
-
-    @Test
-    fun titleOnlyPartSectionDoesNotIndentChaptersAfterFrontMatter() {
-        val plan = buildReaderContentPlan(
-            Fb2Book(
-                title = "Book",
-                sections = listOf(
-                    Fb2Section(
-                        title = "Copyright",
-                        blocks = listOf(paragraph("Copyright text.")),
-                    ),
-                    Fb2Section(
-                        title = "Part one",
-                        sections = listOf(
-                            Fb2Section(
-                                title = "Chapter one",
-                                blocks = listOf(paragraph("Chapter text.")),
-                            ),
-                        ),
-                    ),
-                ),
-            ),
-        )
-
-        assertEquals(
-            listOf(0, 0),
-            plan.elements.filterIsInstance<ReaderElement.Paragraph>().map { it.depth },
-        )
-        assertEquals(
-            listOf(0, 0, 0),
-            plan.elements.filterIsInstance<ReaderElement.SectionTitle>().map { it.depth },
-        )
-    }
-
-    @Test
-    fun realNestedSectionsKeepRelativeIndent() {
-        val plan = buildReaderContentPlan(
-            Fb2Book(
-                title = "Book",
-                sections = listOf(
-                    Fb2Section(
-                        title = "Part",
-                        blocks = listOf(paragraph("Part text.")),
-                        sections = listOf(
-                            Fb2Section(
-                                title = "Nested chapter",
-                                blocks = listOf(paragraph("Nested text.")),
-                            ),
-                        ),
-                    ),
-                ),
-            ),
-        )
-
-        assertEquals(
-            listOf(0, 1),
-            plan.elements.filterIsInstance<ReaderElement.Paragraph>().map { it.depth },
-        )
-        assertEquals(
-            listOf(0, 1),
-            plan.elements.filterIsInstance<ReaderElement.SectionTitle>().map { it.depth },
-        )
-    }
-
     private fun paragraph(text: String): Fb2Block.Paragraph =
         Fb2Block.Paragraph(text(text))
 

docs/fb2-import-export.md

@@ -20,7 +20,7 @@ The common API is `Fb2Format.parse(input: ByteArray, fileName: String? = null)`.
 Import detection:
 
 - A file is treated as ZIP when its bytes start with the ZIP local-file signature `PK\003\004` or the provided filename ends with `.zip`.
-- Otherwise bytes are decoded according to the XML declaration when supported. UTF-8 is the default, and unsupported or missing encodings fall back to UTF-8. `windows-1251` and `windows-1252` are supported for legacy FB2 files.
+- Otherwise bytes are decoded according to the XML declaration when supported. UTF-8 is the default, and unsupported or missing encodings fall back to UTF-8. `windows-1251` is supported for legacy FB2 files.
 - In ZIP archives, the first entry ending with `.fb2` is used. If no such entry exists, the first non-directory entry is used.
 
 ZIP support:

shared/src/commonMain/kotlin/net/sergeych/toread/fb2/Fb2XmlEncoding.kt

@@ -6,7 +6,6 @@ internal object Fb2XmlEncoding {
     fun decodeXml(bytes: ByteArray): String =
         when (declaredEncoding(bytes)?.lowercase()) {
             "windows-1251" -> decodeWindows1251(bytes)
-            "windows-1252" -> decodeWindows1252(bytes)
             else -> bytes.decodeToString()
         }
 
@@ -31,12 +30,6 @@ internal object Fb2XmlEncoding {
         }
     }
 
-    private fun decodeWindows1252(bytes: ByteArray): String = buildString(bytes.size) {
-        bytes.forEach { byte ->
-            append(windows1252Char(byte.toInt() and 0xff))
-        }
-    }
-
     private fun windows1251Char(value: Int): Char =
         when (value) {
             in 0x00..0x7f -> value.toChar()
@@ -107,43 +100,4 @@ internal object Fb2XmlEncoding {
             in 0xc0..0xff -> (0x0410 + value - 0xc0).toChar()
             else -> '\uFFFD'
         }
-
-    private fun windows1252Char(value: Int): Char =
-        when (value) {
-            in 0x00..0x7f -> value.toChar()
-            0x80 -> '\u20ac'
-            0x81 -> '\uFFFD'
-            0x82 -> '\u201a'
-            0x83 -> '\u0192'
-            0x84 -> '\u201e'
-            0x85 -> '\u2026'
-            0x86 -> '\u2020'
-            0x87 -> '\u2021'
-            0x88 -> '\u02c6'
-            0x89 -> '\u2030'
-            0x8a -> '\u0160'
-            0x8b -> '\u2039'
-            0x8c -> '\u0152'
-            0x8d -> '\uFFFD'
-            0x8e -> '\u017d'
-            0x8f -> '\uFFFD'
-            0x90 -> '\uFFFD'
-            0x91 -> '\u2018'
-            0x92 -> '\u2019'
-            0x93 -> '\u201c'
-            0x94 -> '\u201d'
-            0x95 -> '\u2022'
-            0x96 -> '\u2013'
-            0x97 -> '\u2014'
-            0x98 -> '\u02dc'
-            0x99 -> '\u2122'
-            0x9a -> '\u0161'
-            0x9b -> '\u203a'
-            0x9c -> '\u0153'
-            0x9d -> '\uFFFD'
-            0x9e -> '\u017e'
-            0x9f -> '\u0178'
-            in 0xa0..0xff -> value.toChar()
-            else -> '\uFFFD'
-        }
 }

shared/src/commonTest/kotlin/net/sergeych/toread/fb2/Fb2FormatTest.kt

@@ -60,23 +60,6 @@ class Fb2FormatTest {
         assertEquals("Привет, мир.", book.sections.single().paragraphs.single())
     }
 
-    @Test
-    fun parsesWindows1252PlainXml() {
-        val book = Fb2Format.parse(windows1252Xml.encodeWindows1252(), "legacy.fb2")
-
-        assertEquals("The “Test” Book", book.title)
-        assertEquals("It’s 25€ for café — OK.", book.sections.single().paragraphs.single())
-    }
-
-    @Test
-    fun parsesWindows1252StoredZip() {
-        val zip = Fb2Zip.createStoredZip("legacy.fb2", windows1252Xml.encodeWindows1252())
-        val book = Fb2Format.parse(zip, "legacy.fb2.zip")
-
-        assertEquals("The “Test” Book", book.title)
-        assertEquals("It’s 25€ for café — OK.", book.sections.single().paragraphs.single())
-    }
-
     @Test
     fun fallsBackToUtf8ForUnknownEncoding() {
         val xml = sampleXml.replace("encoding=\"UTF-8\"", "encoding=\"KOI8-R\"")
@@ -290,26 +273,6 @@ class Fb2FormatTest {
         </FictionBook>
     """.trimIndent()
 
-    private val windows1252Xml = """
-        <?xml version="1.0" encoding="windows-1252"?>
-        <FictionBook xmlns="http://www.gribuser.ru/xml/fictionbook/2.0" xmlns:xlink="http://www.w3.org/1999/xlink">
-          <description>
-            <title-info>
-              <author><nickname>Author</nickname></author>
-              <book-title>The “Test” Book</book-title>
-              <lang>en</lang>
-            </title-info>
-            <document-info>
-              <author><nickname>Toread</nickname></author>
-              <date>2026-05-12</date>
-              <id>legacy-1252</id>
-              <version>1.0</version>
-            </document-info>
-          </description>
-          <body><section><p>It’s 25€ for café — OK.</p></section></body>
-        </FictionBook>
-    """.trimIndent()
-
     private val notesXml = """
         <?xml version="1.0" encoding="UTF-8"?>
         <FictionBook xmlns="http://www.gribuser.ru/xml/fictionbook/2.0" xmlns:l="http://www.w3.org/1999/xlink">
@@ -351,23 +314,4 @@ class Fb2FormatTest {
             }
             value.toByte()
         }
-
-    private fun String.encodeWindows1252(): ByteArray =
-        ByteArray(length) { index ->
-            val char = this[index]
-            val value = when {
-                char.code <= 0x7f -> char.code
-                char.code in 0xa0..0xff -> char.code
-                char == '€' -> 0x80
-                char == '‘' -> 0x91
-                char == '’' -> 0x92
-                char == '“' -> 0x93
-                char == '”' -> 0x94
-                char == '–' -> 0x96
-                char == '—' -> 0x97
-                char == '™' -> 0x99
-                else -> error("Test character $char is not mapped to windows-1252")
-            }
-            value.toByte()
-        }
 }