pythonnative 0.35.0__py3-none-any.whl → 0.37.0__py3-none-any.whl

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/components/ImageLoader.kt

@@ -0,0 +1,141 @@
+package com.pythonnative.runtime.components
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.util.LruCache
+import com.pythonnative.runtime.bridge.MainThread
+import java.io.File
+import java.io.FileOutputStream
+import java.net.HttpURLConnection
+import java.net.URL
+import java.security.MessageDigest
+import java.util.concurrent.Executors
+import kotlin.math.max
+
+/**
+ * Image fetching and decoding for the `Image` manager.
+ *
+ * Remote images are downloaded on a small background pool into a disk
+ * cache under `cacheDir/pn_images` (keyed by the SHA-256 of the URL),
+ * decoded with `inSampleSize` downsampling to the target size, and kept
+ * in a memory `LruCache`. Callbacks run on the main thread.
+ */
+object ImageLoader {
+    private val executor = Executors.newFixedThreadPool(3) { runnable ->
+        Thread(runnable, "pn-image").apply { isDaemon = true }
+    }
+
+    private val memory: LruCache<String, Bitmap> by lazy {
+        val maxKb = (Runtime.getRuntime().maxMemory() / 1024L).toInt()
+        object : LruCache<String, Bitmap>(max(4 * 1024, maxKb / 8)) {
+            override fun sizeOf(key: String, value: Bitmap): Int = max(1, value.byteCount / 1024)
+        }
+    }
+
+    /** Result callback: exactly one of `bitmap` or `error` is non-null. */
+    fun interface Callback {
+        fun onResult(bitmap: Bitmap?, error: String?)
+    }
+
+    /** Load `url` (http/https) into a bitmap sized for `targetW` x `targetH` pixels. */
+    fun loadRemote(context: Context, url: String, targetW: Int, targetH: Int, callback: Callback) {
+        val key = "$url@$targetW"
+        memory.get(key)?.let {
+            callback.onResult(it, null)
+            return
+        }
+        val cacheDir = File(context.cacheDir, "pn_images")
+        executor.execute {
+            try {
+                val file = cachedFile(cacheDir, url)
+                if (!file.exists() || file.length() == 0L) download(url, file)
+                val bitmap = decodeDownsampled(file.absolutePath, targetW, targetH)
+                if (bitmap == null) {
+                    file.delete()
+                    deliver(callback, null, "decode failed")
+                } else {
+                    memory.put(key, bitmap)
+                    deliver(callback, bitmap, null)
+                }
+            } catch (e: Exception) {
+                deliver(callback, null, e.message ?: e.javaClass.simpleName)
+            }
+        }
+    }
+
+    /** Decode a local file on a background thread. */
+    fun loadFile(path: String, targetW: Int, targetH: Int, callback: Callback) {
+        executor.execute {
+            val bitmap = try {
+                decodeDownsampled(path, targetW, targetH)
+            } catch (e: Exception) {
+                null
+            }
+            deliver(callback, bitmap, if (bitmap == null) "decode failed" else null)
+        }
+    }
+
+    /** Decode `path` with `inSampleSize` chosen so the result still covers the target. */
+    fun decodeDownsampled(path: String, targetW: Int, targetH: Int): Bitmap? {
+        val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+        BitmapFactory.decodeFile(path, bounds)
+        val srcW = bounds.outWidth
+        val srcH = bounds.outHeight
+        if (srcW <= 0 || srcH <= 0) return null
+        var tw = if (targetW > 0) targetW else srcW
+        var th = if (targetH > 0) targetH else tw
+        if (tw <= 0) tw = srcW
+        if (th <= 0) th = srcH
+        var sample = 1
+        while (srcW / (sample * 2) >= tw && srcH / (sample * 2) >= th) sample *= 2
+        val opts = BitmapFactory.Options().apply { inSampleSize = sample }
+        return BitmapFactory.decodeFile(path, opts)
+    }
+
+    private fun cachedFile(dir: File, url: String): File {
+        if (!dir.exists()) dir.mkdirs()
+        val digest = MessageDigest.getInstance("SHA-256").digest(url.toByteArray(Charsets.UTF_8))
+        val hex = digest.joinToString("") { String.format("%02x", it) }
+        val path = url.substringBefore('?').substringBefore('#')
+        val ext = path.substringAfterLast('.', "").takeIf { it.length in 1..5 && it.all { c -> c.isLetterOrDigit() } }
+        return File(dir, if (ext != null) "$hex.$ext" else hex)
+    }
+
+    private fun download(url: String, target: File) {
+        var current = url
+        var redirects = 0
+        while (true) {
+            val connection = URL(current).openConnection() as HttpURLConnection
+            connection.connectTimeout = 15_000
+            connection.readTimeout = 30_000
+            connection.instanceFollowRedirects = true
+            connection.setRequestProperty("User-Agent", "PythonNative/Android")
+            try {
+                val code = connection.responseCode
+                if (code in 300..399 && redirects < 5) {
+                    val location = connection.getHeaderField("Location") ?: throw IllegalStateException("redirect without Location")
+                    current = URL(URL(current), location).toString()
+                    redirects++
+                    continue
+                }
+                if (code !in 200..299) throw IllegalStateException("HTTP $code")
+                val tmp = File(target.parentFile, target.name + ".part")
+                connection.inputStream.use { input ->
+                    FileOutputStream(tmp).use { output -> input.copyTo(output) }
+                }
+                if (!tmp.renameTo(target)) {
+                    tmp.copyTo(target, overwrite = true)
+                    tmp.delete()
+                }
+                return
+            } finally {
+                connection.disconnect()
+            }
+        }
+    }
+
+    private fun deliver(callback: Callback, bitmap: Bitmap?, error: String?) {
+        MainThread.post { callback.onResult(bitmap, error) }
+    }
+}

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/components/ImageManager.kt

@@ -0,0 +1,156 @@
+package com.pythonnative.runtime.components
+
+import android.content.Context
+import android.content.res.ColorStateList
+import android.graphics.BitmapFactory
+import android.util.Base64
+import android.view.View
+import android.widget.ImageView
+import com.pythonnative.runtime.bridge.PNLog
+import com.pythonnative.runtime.bridge.str
+import com.pythonnative.runtime.bridge.value
+import org.json.JSONObject
+
+/**
+ * `Image` element. Sources: `http(s)` URLs (downloaded and cached by
+ * [ImageLoader]), absolute file paths, drawable resource names, and
+ * base64 `data:` URIs. Fires `on_load` / `on_error`.
+ */
+class ImageManager : ComponentManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View = ImageView(context)
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        val iv = view as ImageView
+        PNColor.parse(props.value("tint_color"))?.let { iv.imageTintList = ColorStateList.valueOf(it) }
+        if (props.has("tint_color") && props.value("tint_color") == null) iv.imageTintList = null
+        PNColor.parse(props.value("placeholder_color"))?.let { iv.setBackgroundColor(it) }
+        if (props.has("source")) {
+            val source = sourceString(props.value("source"))
+            if (source != null) loadSource(iv, source) else iv.setImageDrawable(null)
+        }
+        val mode = props.str("resize_mode") ?: props.str("scale_type")
+        if (mode != null) {
+            iv.scaleType = when (mode) {
+                "cover" -> ImageView.ScaleType.CENTER_CROP
+                "contain" -> ImageView.ScaleType.FIT_CENTER
+                "stretch" -> ImageView.ScaleType.FIT_XY
+                "center", "repeat" -> ImageView.ScaleType.CENTER
+                else -> iv.scaleType
+            }
+        }
+        ViewStyler.apply(iv, props)
+    }
+
+    private fun sourceString(value: Any?): String? {
+        return when (value) {
+            null -> null
+            is JSONObject -> value.str("uri") ?: value.str("url") ?: value.str("path")
+            else -> value.toString().takeIf { it.isNotEmpty() }
+        }
+    }
+
+    private fun loadSource(iv: ImageView, source: String) {
+        val state = stateOf(iv)
+        state["pending_uri"] = source
+        try {
+            when {
+                source.startsWith("data:") -> loadDataUri(iv, source)
+                source.startsWith("http://") || source.startsWith("https://") -> {
+                    val (tw, th) = targetSize(iv)
+                    ImageLoader.loadRemote(iv.context, source, tw, th) { bitmap, error ->
+                        if (stateOf(iv)["pending_uri"] != source) return@loadRemote
+                        if (bitmap != null) {
+                            iv.setImageBitmap(bitmap)
+                            fire(iv, "on_load")
+                        } else {
+                            fire(iv, "on_error", error ?: "load failed")
+                        }
+                    }
+                }
+                source.startsWith("/") || source.startsWith("file://") -> {
+                    val path = source.removePrefix("file://")
+                    val (tw, th) = targetSize(iv)
+                    ImageLoader.loadFile(path, tw, th) { bitmap, error ->
+                        if (stateOf(iv)["pending_uri"] != source) return@loadFile
+                        if (bitmap != null) {
+                            iv.setImageBitmap(bitmap)
+                            fire(iv, "on_load")
+                        } else {
+                            fire(iv, "on_error", error ?: "decode failed")
+                        }
+                    }
+                }
+                else -> {
+                    val ctx = iv.context
+                    val name = source.substringBeforeLast('.', source)
+                    val resId = ctx.resources.getIdentifier(name, "drawable", ctx.packageName)
+                        .takeIf { it != 0 }
+                        ?: ctx.resources.getIdentifier(name, "mipmap", ctx.packageName)
+                    if (resId != 0) {
+                        iv.setImageResource(resId)
+                        fire(iv, "on_load")
+                    } else {
+                        fire(iv, "on_error", "drawable '$name' not found")
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            PNLog.swallowed("ImageManager.loadSource", e)
+            fire(iv, "on_error", e.message ?: "load failed")
+        }
+    }
+
+    private fun loadDataUri(iv: ImageView, source: String) {
+        try {
+            val payload = source.substringAfter(',', "")
+            val raw = Base64.decode(payload, Base64.DEFAULT)
+            val bitmap = BitmapFactory.decodeByteArray(raw, 0, raw.size)
+            if (bitmap != null) {
+                iv.setImageBitmap(bitmap)
+                fire(iv, "on_load")
+            } else {
+                fire(iv, "on_error", "data URI decode failed")
+            }
+        } catch (e: Exception) {
+            fire(iv, "on_error", "data URI decode failed")
+        }
+    }
+
+    private fun targetSize(iv: ImageView): Pair<Int, Int> {
+        var w = iv.width
+        var h = iv.height
+        val frame = recordOf(iv)?.frame
+        if (w <= 0 && frame != null) {
+            w = px(frame[2])
+            h = px(frame[3])
+        }
+        if (w <= 0) {
+            val metrics = iv.context.resources.displayMetrics
+            w = metrics.widthPixels
+            h = metrics.heightPixels
+        }
+        if (h <= 0) h = w
+        return Pair(w, h)
+    }
+
+    override fun measure(view: View, maxWidth: Double, maxHeight: Double): FloatArray {
+        val iv = view as ImageView
+        val drawable = iv.drawable ?: return floatArrayOf(0f, 0f)
+        val density = view.context.resources.displayMetrics.density
+        // Bitmaps decode at device density, so their pixel size is already a dp-ish measure.
+        var w = drawable.intrinsicWidth / density
+        var h = drawable.intrinsicHeight / density
+        if (w <= 0f || h <= 0f) return floatArrayOf(0f, 0f)
+        val maxW = if (maxWidth.isFinite() && maxWidth < 1e6) maxWidth.toFloat() else Float.MAX_VALUE
+        val maxH = if (maxHeight.isFinite() && maxHeight < 1e6) maxHeight.toFloat() else Float.MAX_VALUE
+        if (w > maxW) {
+            h *= maxW / w
+            w = maxW
+        }
+        if (h > maxH) {
+            w *= maxH / h
+            h = maxH
+        }
+        return floatArrayOf(w, h)
+    }
+}

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/components/ModalManager.kt

@@ -0,0 +1,134 @@
+package com.pythonnative.runtime.components
+
+import android.app.Dialog
+import android.content.Context
+import android.graphics.drawable.ColorDrawable
+import android.view.View
+import android.view.ViewGroup
+import android.view.WindowManager
+import android.widget.FrameLayout
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.str
+import com.pythonnative.runtime.bridge.value
+import org.json.JSONObject
+
+/**
+ * `Modal` element: real modal presentation backed by a `Dialog`.
+ *
+ * The on-tree placeholder is a hidden `View`. When `visible` flips to
+ * `true`, a `Dialog` hosting a `FrameLayout` is shown and the
+ * reconciler's child inserts are forwarded into that content view.
+ */
+class ModalManager : ComponentManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val placeholder = View(context)
+        placeholder.visibility = View.GONE
+        return placeholder
+    }
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        val state = stateOf(view)
+        // Only react when `visible` itself changed; a re-render while the
+        // dialog is open must not tear it down.
+        if (props.has("visible")) {
+            val visible = JsonUtil.truthy(props.value("visible"))
+            if (visible && state["dialog"] == null) present(view)
+            else if (!visible && state["dialog"] != null) dismiss(view, fromUser = false)
+        }
+        val dialog = state["dialog"] as? Dialog
+        if (dialog != null && props.has("dismiss_on_backdrop")) {
+            dialog.setCanceledOnTouchOutside(props.value("dismiss_on_backdrop") != false)
+        }
+    }
+
+    override fun insertChild(parent: View, child: View, index: Int) {
+        val state = stateOf(parent)
+        val content = state["content_view"] as? FrameLayout
+        if (content != null) {
+            ViewChildren.insert(content, child, index)
+        } else {
+            @Suppress("UNCHECKED_CAST")
+            val pending = state.getOrPut("pending") { ArrayList<View>() } as ArrayList<View>
+            pending.remove(child)
+            pending.add(index.coerceIn(0, pending.size), child)
+        }
+    }
+
+    override fun removeChild(parent: View, child: View) {
+        val state = stateOf(parent)
+        val content = state["content_view"] as? FrameLayout
+        if (content != null) {
+            content.removeView(child)
+        } else {
+            @Suppress("UNCHECKED_CAST")
+            (state["pending"] as? ArrayList<View>)?.remove(child)
+        }
+    }
+
+    override fun setFrame(view: View, x: Double, y: Double, width: Double, height: Double) {
+        // The dialog owns its own window; the layout engine frames only the children.
+    }
+
+    override fun teardown(view: View) {
+        if (stateOf(view)["dialog"] != null) dismiss(view, fromUser = false)
+    }
+
+    private fun present(placeholder: View) {
+        val state = stateOf(placeholder)
+        val props = propsOf(placeholder)
+        val ctx = placeholder.context
+        val dialog = Dialog(ctx)
+        val content = FrameLayout(ctx)
+        val presentation = props.str("presentation_style") ?: "page_sheet"
+        val isOverlay = presentation == "overlay" || JsonUtil.truthy(props.value("transparent"))
+        content.setBackgroundColor(if (isOverlay) 0x00FFFFFF else 0xFFFFFFFF.toInt())
+        dialog.setContentView(content, ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
+        dialog.window?.let { window ->
+            if (isOverlay) {
+                window.setBackgroundDrawable(ColorDrawable(0x00000000))
+                window.setDimAmount(0.5f)
+                window.setLayout(WindowManager.LayoutParams.MATCH_PARENT, WindowManager.LayoutParams.MATCH_PARENT)
+            } else {
+                window.setLayout(WindowManager.LayoutParams.MATCH_PARENT, WindowManager.LayoutParams.MATCH_PARENT)
+            }
+            val animation = props.str("animation_type") ?: props.str("animation")
+            when (animation) {
+                "none" -> window.setWindowAnimations(0)
+                "fade" -> window.setWindowAnimations(android.R.style.Animation_Toast)
+                "slide" -> window.setWindowAnimations(android.R.style.Animation_InputMethod)
+            }
+            PNColor.parse(props.value("status_bar_color"))?.let { window.statusBarColor = it }
+        }
+        dialog.setCanceledOnTouchOutside(props.value("dismiss_on_backdrop") != false)
+        dialog.setCancelable(props.value("dismissable") != false)
+        state["dialog"] = dialog
+        state["content_view"] = content
+        @Suppress("UNCHECKED_CAST")
+        val pending = state.remove("pending") as? ArrayList<View>
+        pending?.forEach { child ->
+            (child.parent as? ViewGroup)?.removeView(child)
+            content.addView(child)
+        }
+        dialog.setOnShowListener { fire(placeholder, "on_show") }
+        dialog.setOnDismissListener {
+            // Programmatic dismiss (visible=false) also lands here; the
+            // Python side expects on_dismiss only for user-driven closes,
+            // but android.py fired it unconditionally, so keep that.
+            if (stateOf(placeholder)["dialog"] === dialog) {
+                stateOf(placeholder).remove("dialog")
+                stateOf(placeholder).remove("content_view")
+            }
+            fire(placeholder, "on_dismiss")
+            if (hasEvent(placeholder, "on_request_close")) fire(placeholder, "on_request_close")
+        }
+        dialog.show()
+    }
+
+    private fun dismiss(placeholder: View, fromUser: Boolean) {
+        val state = stateOf(placeholder)
+        val dialog = state.remove("dialog") as? Dialog
+        state.remove("content_view")
+        if (!fromUser) dialog?.setOnDismissListener(null)
+        dialog?.dismiss()
+    }
+}

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/components/PNColor.kt

@@ -0,0 +1,201 @@
+package com.pythonnative.runtime.components
+
+import org.json.JSONArray
+import org.json.JSONObject
+
+/**
+ * Color parsing shared by every manager.
+ *
+ * Accepts `#RGB`, `#RGBA`, `#RRGGBB`, `#AARRGGBB` (the Android/Python
+ * convention used by `parse_color_int`), `rgb(r, g, b)`,
+ * `rgba(r, g, b, a)` with `a` in `0..1`, CSS named colors, packed
+ * integers (`0xRRGGBB` gains full alpha), and `[r, g, b(, a)]` arrays.
+ * Results are signed 32-bit ARGB ints suitable for Android APIs.
+ */
+object PNColor {
+    private val named: Map<String, Int> = mapOf(
+        "transparent" to 0x00000000,
+        "clear" to 0x00000000,
+        "black" to 0xFF000000.toInt(),
+        "white" to 0xFFFFFFFF.toInt(),
+        "red" to 0xFFFF0000.toInt(),
+        "green" to 0xFF008000.toInt(),
+        "lime" to 0xFF00FF00.toInt(),
+        "blue" to 0xFF0000FF.toInt(),
+        "yellow" to 0xFFFFFF00.toInt(),
+        "cyan" to 0xFF00FFFF.toInt(),
+        "aqua" to 0xFF00FFFF.toInt(),
+        "magenta" to 0xFFFF00FF.toInt(),
+        "fuchsia" to 0xFFFF00FF.toInt(),
+        "gray" to 0xFF808080.toInt(),
+        "grey" to 0xFF808080.toInt(),
+        "darkgray" to 0xFFA9A9A9.toInt(),
+        "darkgrey" to 0xFFA9A9A9.toInt(),
+        "lightgray" to 0xFFD3D3D3.toInt(),
+        "lightgrey" to 0xFFD3D3D3.toInt(),
+        "dimgray" to 0xFF696969.toInt(),
+        "dimgrey" to 0xFF696969.toInt(),
+        "silver" to 0xFFC0C0C0.toInt(),
+        "maroon" to 0xFF800000.toInt(),
+        "olive" to 0xFF808000.toInt(),
+        "navy" to 0xFF000080.toInt(),
+        "teal" to 0xFF008080.toInt(),
+        "purple" to 0xFF800080.toInt(),
+        "orange" to 0xFFFFA500.toInt(),
+        "pink" to 0xFFFFC0CB.toInt(),
+        "brown" to 0xFFA52A2A.toInt(),
+        "gold" to 0xFFFFD700.toInt(),
+        "indigo" to 0xFF4B0082.toInt(),
+        "violet" to 0xFFEE82EE.toInt(),
+        "coral" to 0xFFFF7F50.toInt(),
+        "salmon" to 0xFFFA8072.toInt(),
+        "tomato" to 0xFFFF6347.toInt(),
+        "crimson" to 0xFFDC143C.toInt(),
+        "khaki" to 0xFFF0E68C.toInt(),
+        "beige" to 0xFFF5F5DC.toInt(),
+        "ivory" to 0xFFFFFFF0.toInt(),
+        "tan" to 0xFFD2B48C.toInt(),
+        "turquoise" to 0xFF40E0D0.toInt(),
+        "skyblue" to 0xFF87CEEB.toInt(),
+        "steelblue" to 0xFF4682B4.toInt(),
+        "royalblue" to 0xFF4169E1.toInt(),
+        "dodgerblue" to 0xFF1E90FF.toInt(),
+        "slategray" to 0xFF708090.toInt(),
+        "slategrey" to 0xFF708090.toInt(),
+        "whitesmoke" to 0xFFF5F5F5.toInt(),
+        "snow" to 0xFFFFFAFA.toInt(),
+        "seagreen" to 0xFF2E8B57.toInt(),
+        "forestgreen" to 0xFF228B22.toInt(),
+        "darkgreen" to 0xFF006400.toInt(),
+        "lightblue" to 0xFFADD8E6.toInt(),
+        "lightgreen" to 0xFF90EE90.toInt(),
+        "darkblue" to 0xFF00008B.toInt(),
+        "darkred" to 0xFF8B0000.toInt(),
+        "orangered" to 0xFFFF4500.toInt(),
+        "hotpink" to 0xFFFF69B4.toInt(),
+        "deeppink" to 0xFFFF1493.toInt(),
+        "chocolate" to 0xFFD2691E.toInt(),
+        "plum" to 0xFFDDA0DD.toInt(),
+        "lavender" to 0xFFE6E6FA.toInt(),
+        "mintcream" to 0xFFF5FFFA.toInt(),
+        "gainsboro" to 0xFFDCDCDC.toInt(),
+    )
+
+    /** Parse `value` into a signed ARGB int, or `null` when unparseable. */
+    fun parse(value: Any?): Int? {
+        return when (value) {
+            null, JSONObject.NULL -> null
+            is Boolean -> null
+            is Int -> if (value ushr 24 == 0) value or 0xFF000000.toInt() else value
+            is Long -> parseLong(value)
+            is Number -> {
+                val d = value.toDouble()
+                if (d.isNaN() || d.isInfinite()) null else parseLong(d.toLong())
+            }
+            is String -> parseString(value)
+            is JSONArray -> parseArray((0 until value.length()).map { value.opt(it) })
+            is List<*> -> parseArray(value)
+            else -> null
+        }
+    }
+
+    /** Parse `value`, falling back to `default` when unparseable. */
+    fun parseOr(value: Any?, default: Int): Int = parse(value) ?: default
+
+    /** Replace the alpha channel of `color` with `alpha` in `0..1`. */
+    fun withAlpha(color: Int, alpha: Double): Int {
+        val a = (alpha.coerceIn(0.0, 1.0) * 255.0).toInt()
+        return (color and 0x00FFFFFF) or (a shl 24)
+    }
+
+    private fun parseLong(raw: Long): Int {
+        val masked = raw and 0xFFFFFFFFL
+        val withAlpha = if (masked ushr 24 == 0L) masked or 0xFF000000L else masked
+        return withAlpha.toInt()
+    }
+
+    private fun parseArray(items: List<Any?>): Int? {
+        if (items.size < 3) return null
+        val r = channel(items[0]) ?: return null
+        val g = channel(items[1]) ?: return null
+        val b = channel(items[2]) ?: return null
+        val a = if (items.size >= 4) alphaChannel(items[3]) ?: return null else 255
+        return argb(a, r, g, b)
+    }
+
+    private fun parseString(raw: String): Int? {
+        val s = raw.trim()
+        if (s.isEmpty()) return null
+        if (s.startsWith("#")) return parseHex(s.substring(1))
+        val lower = s.lowercase()
+        named[lower]?.let { return it }
+        if (lower.startsWith("rgb")) return parseFunctional(lower)
+        if (lower.startsWith("0x")) return s.substring(2).toLongOrNull(16)?.let { parseLong(it) }
+        return s.toLongOrNull(16)?.takeIf { s.length == 6 || s.length == 8 }?.let {
+            parseHexDigits(s)
+        }
+    }
+
+    private fun parseHex(digits: String): Int? {
+        if (digits.isEmpty() || !digits.all { it.isLetterOrDigit() }) return null
+        val expanded = when (digits.length) {
+            3 -> "FF" + digits.map { "$it$it" }.joinToString("")
+            4 -> {
+                // CSS #RGBA: alpha is the last digit.
+                val rgb = digits.substring(0, 3).map { "$it$it" }.joinToString("")
+                val a = "${digits[3]}${digits[3]}"
+                a + rgb
+            }
+            6 -> "FF$digits"
+            8 -> digits
+            else -> return null
+        }
+        return expanded.toLongOrNull(16)?.toInt()
+    }
+
+    private fun parseHexDigits(digits: String): Int? = parseHex(digits)
+
+    private fun parseFunctional(lower: String): Int? {
+        val open = lower.indexOf('(')
+        val close = lower.lastIndexOf(')')
+        if (open < 0 || close < open) return null
+        val parts = lower.substring(open + 1, close).split(',', '/', ' ').map { it.trim() }.filter { it.isNotEmpty() }
+        if (parts.size < 3) return null
+        val r = channel(parts[0]) ?: return null
+        val g = channel(parts[1]) ?: return null
+        val b = channel(parts[2]) ?: return null
+        val a = if (parts.size >= 4) alphaChannel(parts[3]) ?: return null else 255
+        return argb(a, r, g, b)
+    }
+
+    private fun channel(value: Any?): Int? {
+        val d = when (value) {
+            is Number -> value.toDouble()
+            is String -> {
+                val t = value.trim()
+                if (t.endsWith("%")) (t.dropLast(1).toDoubleOrNull() ?: return null) * 2.55
+                else t.toDoubleOrNull() ?: return null
+            }
+            else -> return null
+        }
+        return d.toInt().coerceIn(0, 255)
+    }
+
+    private fun alphaChannel(value: Any?): Int? {
+        val d = when (value) {
+            is Number -> value.toDouble()
+            is String -> {
+                val t = value.trim()
+                if (t.endsWith("%")) (t.dropLast(1).toDoubleOrNull() ?: return null) / 100.0
+                else t.toDoubleOrNull() ?: return null
+            }
+            else -> return null
+        }
+        // Values above 1 are taken as 0..255 bytes.
+        val a = if (d > 1.0) d / 255.0 else d
+        return (a.coerceIn(0.0, 1.0) * 255.0 + 0.5).toInt()
+    }
+
+    private fun argb(a: Int, r: Int, g: Int, b: Int): Int =
+        (a shl 24) or (r shl 16) or (g shl 8) or b
+}