import kotlin.math.roundToInt

private const val CHAT_ATTACHMENT_MAX_WIDTH = 1600

private const val CHAT_ATTACHMENT_MAX_BASE64_CHARS = 300 * 1024

internal const val CHAT_IMAGE_MAX_BASE64_CHARS = 300 * 1024

private const val CHAT_ATTACHMENT_START_QUALITY = 85

private const val CHAT_DECODE_MAX_DIMENSION = 1600

private const val CHAT_IMAGE_CACHE_BYTES = 16 * 1024 * 1024

if (bitmap == null) {

throw IllegalStateException("unsupported attachment")

}

val maxBytes = (CHAT_ATTACHMENT_MAX_BASE64_CHARS / 4) * 3

val maxBytes = (CHAT_IMAGE_MAX_BASE64_CHARS / 4) * 3

val encoded =

JpegSizeLimiter.compressToLimit(

initialWidth = bitmap.width,

import org.commonmark.node.Text as MarkdownTextNode

private const val LIST_INDENT_DP = 14

private const val DATA_IMAGE_HEADER_MAX_CHARS = 64

private val dataImageRegex = Regex("^data:image/([a-zA-Z0-9+.-]+);base64,([A-Za-z0-9+/=\\n\\r]+)$")

private val markdownParser: Parser by lazy {

return parseDataImageDestination(only.destination)

}

private fun parseDataImageDestination(destination: String?): ParsedDataImage? {

internal fun parseDataImageDestination(destination: String?): ParsedDataImage? {

val raw = destination?.trim().orEmpty()

if (raw.isEmpty()) return null

if (raw.length > CHAT_IMAGE_MAX_BASE64_CHARS + DATA_IMAGE_HEADER_MAX_CHARS) return null

val match = dataImageRegex.matchEntire(raw) ?: return null

val subtype =

match.groupValues

?.trim()

.orEmpty()

if (base64.isEmpty()) return null

if (base64.length > CHAT_IMAGE_MAX_BASE64_CHARS) return null

return ParsedDataImage(mimeType = "image/$subtype", base64 = base64)

}

val cells: List<AnnotatedString>,

)

private data class ParsedDataImage(

internal data class ParsedDataImage(

val mimeType: String,

val base64: String,

)

import androidx.compose.ui.text.LinkAnnotation

import org.junit.Assert.assertEquals

import org.junit.Assert.assertNull

import org.junit.Assert.assertTrue

import org.junit.Test

assertEquals("No link here", annotated.text)

assertTrue(annotated.getLinkAnnotations(0, annotated.length).isEmpty())

}

@Test

fun parseDataImageDestinationAcceptsBoundedPayloads() {

val parsed = parseDataImageDestination("data:image/png;base64,QUJD")

assertEquals(ParsedDataImage(mimeType = "image/png", base64 = "QUJD"), parsed)

}

@Test

fun parseDataImageDestinationRejectsOversizedPayloads() {

val oversized = "A".repeat(CHAT_IMAGE_MAX_BASE64_CHARS + 1)

val parsed = parseDataImageDestination("data:image/png;base64,$oversized")

assertNull(parsed)

}

}