atmos/os_lib/css/

color.rs

// 分割: css.rs より機械的に移動（2026-07-16 リファクタ フェーズ3）。
// ロジック不変。可視性のみ pub(crate) へ昇格し、親が pub(crate) use で再エクスポート。
use super::*;

/// `rgb()`/`rgba()` の1成分を 0-255 の整数へ解決する。CSS1 の頃から有効な構文である
/// パーセント表記（`100%`→255、`50%`→128）と、通常の整数表記（`0`〜`255`、範囲外はクランプ）
/// の両方に対応する。
pub(crate) fn parse_rgb_component(s: &str) -> u32 {
    let t = s.trim();
    if let Some(pct) = t.strip_suffix('%') {
        let p = pct.trim().parse::<f32>().unwrap_or(0.0);
        let p = if p.is_finite() { p } else { 0.0 };
        ((p / 100.0) * 255.0).clamp(0.0, 255.0) as u32
    } else {
        let val = t.parse::<f32>().unwrap_or(0.0);
        let val = if val.is_finite() { val } else { 0.0 };
        val.clamp(0.0, 255.0) as u32
    }
}

pub fn parse_color(s: &str) -> Option<u32> {
    let s_trim = s.trim();
    if s_trim.is_empty() {
        return None;
    }

    // #RRGGBB, #RGB, #RRGGBBAA, #RGBA
    if let Some(hex) = s_trim.strip_prefix('#') {
        let bytes = hex.as_bytes();
        let from_hex_digit = |b: u8| -> Option<u32> {
            match b {
                b'0'..=b'9' => Some((b - b'0') as u32),
                b'a'..=b'f' => Some((b - b'a' + 10) as u32),
                b'A'..=b'F' => Some((b - b'A' + 10) as u32),
                _ => None,
            }
        };

        if bytes.len() == 8 {
            let mut val = 0u32;
            for &b in bytes {
                val = (val << 4) | from_hex_digit(b)?;
            }
            let r = (val >> 24) & 0xFF;
            let g = (val >> 16) & 0xFF;
            let b = (val >> 8) & 0xFF;
            let a = val & 0xFF;
            return Some((a << 24) | (r << 16) | (g << 8) | b);
        } else if bytes.len() == 6 {
            let mut val = 0u32;
            for &b in bytes {
                val = (val << 4) | from_hex_digit(b)?;
            }
            return Some(0xFF000000 | val);
        } else if bytes.len() == 3 {
            let r = from_hex_digit(bytes[0])?;
            let g = from_hex_digit(bytes[1])?;
            let b = from_hex_digit(bytes[2])?;
            let r_byte = (r << 4) | r;
            let g_byte = (g << 4) | g;
            let b_byte = (b << 4) | b;
            return Some(0xFF000000 | (r_byte << 16) | (g_byte << 8) | b_byte);
        } else if bytes.len() == 4 {
            let r = from_hex_digit(bytes[0])?;
            let g = from_hex_digit(bytes[1])?;
            let b = from_hex_digit(bytes[2])?;
            let a = from_hex_digit(bytes[3])?;
            let r_byte = (r << 4) | r;
            let g_byte = (g << 4) | g;
            let b_byte = (b << 4) | b;
            let a_byte = (a << 4) | a;
            return Some((a_byte << 24) | (r_byte << 16) | (g_byte << 8) | b_byte);
        }
        return None;
    }

    let s_lower = s_trim.to_lowercase();

    // light-dark(light-color, dark-color) — CSS Color Module Level 5。丸ごと未対応
    // だった。`prefers-color-scheme` メディアクエリと同じ `PREFERS_DARK` を真実源とし、
    // 現在の配色設定に応じてどちらか一方の色式（ネストした `light-dark()` も可）を
    // 選んで再帰的に解決する。
    if let Some(inner) = s_lower.strip_prefix("light-dark(").and_then(|s| s.strip_suffix(')')) {
        let mut depth = 0i32;
        let mut split_at = None;
        for (i, ch) in inner.char_indices() {
            match ch {
                '(' => depth += 1,
                ')' => depth -= 1,
                ',' if depth == 0 => {
                    split_at = Some(i);
                    break;
                }
                _ => {}
            }
        }
        if let Some(i) = split_at {
            let light = inner.get(..i).unwrap_or("").trim();
            let dark = inner.get(i + 1..).unwrap_or("").trim();
            let is_dark = PREFERS_DARK.load(AtomicOrd::Relaxed);
            return parse_color(if is_dark { dark } else { light });
        }
        return None;
    }

    // oklab(L a b [/ alpha]) / oklch(L C H [/ alpha]) — CSS Color Module Level 4。
    // Björn Ottosson の OKLab⇄線形sRGB変換式で近似する（色域外は素直に0-255へ
    // クランプする簡略実装。`color-mix()` の色空間非対応と同じ「厳密な知覚均等
    // 補間は非対応」の割り切り）。`L` は 0-1（`%` 表記可）、`oklch` の `H` は度。
    if let Some(inner) = s_lower
        .strip_prefix("oklab(")
        .or_else(|| s_lower.strip_prefix("oklch("))
        .and_then(|s| s.strip_suffix(')'))
    {
        let is_lch = s_lower.starts_with("oklch(");
        let parts: alloc::vec::Vec<&str> = if inner.contains(',') {
            inner.split(',').collect()
        } else {
            inner.split_whitespace().filter(|s| *s != "/").collect()
        };
        if parts.len() >= 3 {
            let parse_l = |s: &str| -> f32 {
                let s = s.trim();
                if let Some(pct) = s.strip_suffix('%') {
                    pct.parse::<f32>().unwrap_or(0.0) / 100.0
                } else {
                    s.parse::<f32>().unwrap_or(0.0)
                }
            };
            let l = parse_l(parts[0]);
            let (ok_a, ok_b) = if is_lch {
                let c = parse_l(parts[1]).max(0.0);
                let h_deg = parts[2]
                    .trim()
                    .trim_end_matches("deg")
                    .parse::<f32>()
                    .unwrap_or(0.0);
                let h_rad = h_deg * core::f32::consts::PI / 180.0;
                (c * libm::cosf(h_rad), c * libm::sinf(h_rad))
            } else {
                (parse_l(parts[1]), parse_l(parts[2]))
            };
            let a_val = if parts.len() >= 4 {
                let a_str = parts[3].trim();
                if let Some(pct) = a_str.strip_suffix('%') {
                    pct.parse::<f32>().unwrap_or(100.0) / 100.0
                } else {
                    a_str.parse::<f32>().unwrap_or(1.0)
                }
            } else {
                1.0
            };
            let l_ = l + 0.396_337_78 * ok_a + 0.215_803_76 * ok_b;
            let m_ = l - 0.105_561_346 * ok_a - 0.063_854_17 * ok_b;
            let s_ = l - 0.089_484_18 * ok_a - 1.291_485_5 * ok_b;
            let (l3, m3, s3) = (l_ * l_ * l_, m_ * m_ * m_, s_ * s_ * s_);
            let lin_r = 4.076_741_7 * l3 - 3.307_711_6 * m3 + 0.230_969_93 * s3;
            let lin_g = -1.268_438 * l3 + 2.609_757_4 * m3 - 0.341_319_4 * s3;
            let lin_b = -0.004_196_086_3 * l3 - 0.703_418_6 * m3 + 1.707_614_7 * s3;
            // 線形light → sRGBガンマ符号化。
            let to_srgb = |c: f32| -> u32 {
                let c = c.clamp(0.0, 1.0);
                let enc = if c <= 0.003_130_8 {
                    c * 12.92
                } else {
                    1.055 * libm::powf(c, 1.0 / 2.4) - 0.055
                };
                // 行列係数を有限桁で丸めているための誤差蓄積を吸収するため、
                // 単純truncateではなく四捨五入する（truncate だと L=1・彩度0 の
                // 白などが 255 のはずが 254 に化ける丸め落ちが起きていた）。
                libm::roundf((enc * 255.0).clamp(0.0, 255.0)) as u32
            };
            let r = to_srgb(lin_r);
            let g = to_srgb(lin_g);
            let b_out = to_srgb(lin_b);
            let a = (a_val * 255.0).clamp(0.0, 255.0) as u32;
            return Some((a << 24) | (r << 16) | (g << 8) | b_out);
        }
    }

    // hwb(h w% b% [/ a]) — CSS Color Module Level 4。彩度100%・輝度50%相当の純色相RGBを
    // 6分割セクターで求め、white(w)/black(b) の割合でブレンドする（HSLより単純な変換）。
    if let Some(inner) = s_lower.strip_prefix("hwb(").and_then(|s| s.strip_suffix(')')) {
        let parts: alloc::vec::Vec<&str> = if inner.contains(',') {
            inner.split(',').collect()
        } else {
            inner.split_whitespace().filter(|s| *s != "/").collect()
        };
        if parts.len() >= 3 {
            let h_raw = parts[0]
                .trim()
                .trim_end_matches("deg")
                .parse::<f32>()
                .unwrap_or(0.0);
            // hue は360を法とする値のため hsl() と同じく正規化する。
            let h = ((h_raw % 360.0) + 360.0) % 360.0;
            let mut w = parts[1]
                .trim()
                .trim_end_matches('%')
                .parse::<f32>()
                .unwrap_or(0.0)
                / 100.0;
            let mut bl = parts[2]
                .trim()
                .trim_end_matches('%')
                .parse::<f32>()
                .unwrap_or(0.0)
                / 100.0;
            w = w.clamp(0.0, 1.0);
            bl = bl.clamp(0.0, 1.0);
            // w+b が1を超える場合は仕様通り比率を保ったまま正規化する。
            if w + bl > 1.0 {
                let sum = w + bl;
                w /= sum;
                bl /= sum;
            }
            let a_val = if parts.len() >= 4 {
                let a_str = parts[3].trim();
                if a_str.ends_with('%') {
                    a_str.trim_end_matches('%').parse::<f32>().unwrap_or(100.0) / 100.0
                } else {
                    a_str.parse::<f32>().unwrap_or(1.0)
                }
            } else {
                1.0
            };
            let h_prime = h / 60.0;
            let x = 1.0 - libm::fabsf(h_prime % 2.0 - 1.0);
            let (r1, g1, b1) = if h_prime < 1.0 {
                (1.0, x, 0.0)
            } else if h_prime < 2.0 {
                (x, 1.0, 0.0)
            } else if h_prime < 3.0 {
                (0.0, 1.0, x)
            } else if h_prime < 4.0 {
                (0.0, x, 1.0)
            } else if h_prime < 5.0 {
                (x, 0.0, 1.0)
            } else {
                (1.0, 0.0, x)
            };
            let r = ((r1 * (1.0 - w - bl) + w) * 255.0).clamp(0.0, 255.0) as u32;
            let g = ((g1 * (1.0 - w - bl) + w) * 255.0).clamp(0.0, 255.0) as u32;
            let b_out = ((b1 * (1.0 - w - bl) + w) * 255.0).clamp(0.0, 255.0) as u32;
            let a = (a_val * 255.0).clamp(0.0, 255.0) as u32;
            return Some((a << 24) | (r << 16) | (g << 8) | b_out);
        }
    }

    // color(COLORSPACE c1 c2 c3 [/ a]) — CSS Color Module Level 4の述語関数。
    // 丸ごと未対応だった（`spec/TODO.md`では`oklch()`と同格の「知覚均等色空間の
    // 変換数学が無い」大物として記載されていたが、`srgb`/`srgb-linear`だけなら
    // 行列変換不要で対応できるため部分的に実装する）。`srgb`は`rgb()`と同じ
    // ガンマ符号化済み値（0-1範囲）、`srgb-linear`は`oklab()`側で既に書いた
    // `to_srgb`と同じ線形→sRGBガンマ符号化を再利用するだけで対応できる。
    // `display-p3`/`rec2020`/`a98-rgb`/`prophoto-rgb`/`xyz`等の広色域・XYZ空間は
    // 本物のガマット変換行列が必要で、oklch側と同じ「ラスタライズ結果を目視
    // 確認できないため誤変換を自分で検知できない」リスクがあるため対象外の
    // ままとする（未知の色空間名は`None`を返し、呼び出し元は色指定そのものを
    // 無視する既存の安全側フォールバックに委ねる）。
    if let Some(inner) = s_lower.strip_prefix("color(").and_then(|s| s.strip_suffix(')')) {
        let mut parts = inner.split_whitespace().filter(|s| *s != "/");
        let space_name = parts.next().unwrap_or("");
        // 【2026-08-31】以前は `srgb`/`srgb-linear` の 2 つだけを扱い、
        // 広色域（`display-p3` 等）と XYZ は「変換行列が必要」として未対応
        // だった。行列と伝達関数を `css/color_space.rs`（純粋モジュール・
        // 単体試験 33 件）へ切り出したので、全色空間を通す。
        let Some(space) = crate::os_lib::css::color_space::parse_color_space(space_name) else {
            // 未知の色空間名は従来どおり None（色指定そのものを無視する）。
            return None;
        };
        let rest: alloc::vec::Vec<&str> = parts.collect();
        if rest.len() >= 3 {
            let parse_c = |s: &str| -> f32 {
                let s = s.trim();
                if let Some(pct) = s.strip_suffix('%') {
                    pct.parse::<f32>().unwrap_or(0.0) / 100.0
                } else {
                    s.parse::<f32>().unwrap_or(0.0)
                }
            };
            let c0 = parse_c(rest[0]);
            let c1 = parse_c(rest[1]);
            let c2 = parse_c(rest[2]);
            let a_val = if rest.len() >= 4 { parse_c(rest[3]) } else { 1.0 };
            let (lr, lg, lb) = crate::os_lib::css::color_space::components_to_linear_srgb(space, c0, c1, c2);
            let (r, g, b_out) = crate::os_lib::css::color_space::linear_srgb_to_rgb8(lr, lg, lb);
            let a = (a_val.clamp(0.0, 1.0) * 255.0) as u32;
            return Some((a << 24) | (r << 16) | (g << 8) | b_out);
        }
        return None;
    }

    // lab(L a b [/ alpha]) / lch(L C H [/ alpha]) — CSS Color Module Level 4。
    //
    // `oklab()`/`oklch()` とは**白色点が違う**（こちらは CIE Lab の D50）。
    // D50→D65 の Bradford 色順応を挟まないと全体が黄色寄りにずれるので、
    // 変換は `css/color_space.rs` の実装（試験あり）へ委ねる。
    //
    // `L` は 0-100（`%` 表記可）、`a`/`b` はおおむね -125〜125、
    // `lch` の `C` は 0 以上、`H` は度。
    if let Some(inner) = s_lower
        .strip_prefix("lab(")
        .or_else(|| s_lower.strip_prefix("lch("))
        .and_then(|s| s.strip_suffix(')'))
    {
        let is_lch = s_lower.starts_with("lch(");
        let parts: alloc::vec::Vec<&str> = if inner.contains(',') {
            inner.split(',').collect()
        } else {
            inner.split_whitespace().filter(|s| *s != "/").collect()
        };
        if parts.len() >= 3 {
            // `L` は % 表記なら 100 分率、素の数値ならそのまま 0-100。
            let l = {
                let s = parts[0].trim();
                if let Some(pct) = s.strip_suffix('%') {
                    pct.parse::<f32>().unwrap_or(0.0)
                } else {
                    s.parse::<f32>().unwrap_or(0.0)
                }
            };
            let p1 = parts[1].trim().trim_end_matches('%').parse::<f32>().unwrap_or(0.0);
            let p2 = parts[2]
                .trim()
                .trim_end_matches("deg")
                .trim_end_matches('%')
                .parse::<f32>()
                .unwrap_or(0.0);
            let a_val = if parts.len() >= 4 {
                let s = parts[3].trim();
                if let Some(pct) = s.strip_suffix('%') {
                    pct.parse::<f32>().unwrap_or(100.0) / 100.0
                } else {
                    s.parse::<f32>().unwrap_or(1.0)
                }
            } else {
                1.0
            };
            let (l, aa, bb) = if is_lch {
                // 色相は 360 を法とする値なので hsl()/hwb() と同様に正規化する。
                let h = ((p2 % 360.0) + 360.0) % 360.0;
                crate::os_lib::css::color_space::lch_to_lab(l, p1, h)
            } else {
                (l, p1, p2)
            };
            let (lr, lg, lb) = crate::os_lib::css::color_space::lab_to_linear_srgb(l, aa, bb);
            let (r, g, b_out) = crate::os_lib::css::color_space::linear_srgb_to_rgb8(lr, lg, lb);
            let a = (a_val.clamp(0.0, 1.0) * 255.0) as u32;
            return Some((a << 24) | (r << 16) | (g << 8) | b_out);
        }
        return None;
    }

    // hsl(h, s%, l%) / hsla(h, s%, l%, a)
    if s_lower.starts_with("hsl") {
        let has_alpha = s_lower.starts_with("hsla(");
        let inner_start = if has_alpha { 5 } else { 4 };
        if let Some(inner) = s_lower.get(inner_start..) {
            let inner = inner.trim_end_matches(')');
            // カンマ区切りまたはスペース区切り（CSS Color Level 4）
            let parts: alloc::vec::Vec<&str> = if inner.contains(',') {
                inner.split(',').collect()
            } else {
                inner.split_whitespace().filter(|s| *s != "/").collect()
            };
            if parts.len() >= 3 {
                // hue は 360 を法とする値（負値・360以上も有効）のため、以降の6分割
                // セクター判定（h_prime = h/60 が [0,6) にあることを前提とする）の前に
                // [0,360) へ正規化しておく。Rust の `%` は剰余（符号は被除数に従う）なので
                // 負値のときそのままでは正しく巻き戻らず、2回 `%` を取ることで真の mod にする。
                let h_raw = parts[0]
                    .trim()
                    .trim_end_matches("deg")
                    .parse::<f32>()
                    .unwrap_or(0.0);
                let h = ((h_raw % 360.0) + 360.0) % 360.0;
                let s_pct = parts[1]
                    .trim()
                    .trim_end_matches('%')
                    .parse::<f32>()
                    .unwrap_or(0.0)
                    / 100.0;
                let l_pct = parts[2]
                    .trim()
                    .trim_end_matches('%')
                    .parse::<f32>()
                    .unwrap_or(0.0)
                    / 100.0;
                let a_val = if parts.len() >= 4 {
                    let a_str = parts[3].trim();
                    if a_str.ends_with('%') {
                        a_str.trim_end_matches('%').parse::<f32>().unwrap_or(100.0) / 100.0
                    } else {
                        a_str.parse::<f32>().unwrap_or(1.0)
                    }
                } else {
                    1.0
                };

                // HSL to RGB conversion
                let c = (1.0 - libm::fabsf(2.0 * l_pct - 1.0)) * s_pct;
                let h_prime = h / 60.0;
                let x = c * (1.0 - libm::fabsf(h_prime % 2.0 - 1.0));
                let (r1, g1, b1) = if h_prime < 1.0 {
                    (c, x, 0.0)
                } else if h_prime < 2.0 {
                    (x, c, 0.0)
                } else if h_prime < 3.0 {
                    (0.0, c, x)
                } else if h_prime < 4.0 {
                    (0.0, x, c)
                } else if h_prime < 5.0 {
                    (x, 0.0, c)
                } else {
                    (c, 0.0, x)
                };
                let m = l_pct - c / 2.0;
                let r = ((r1 + m) * 255.0).clamp(0.0, 255.0) as u32;
                let g = ((g1 + m) * 255.0).clamp(0.0, 255.0) as u32;
                let b = ((b1 + m) * 255.0).clamp(0.0, 255.0) as u32;
                let a = (a_val * 255.0).clamp(0.0, 255.0) as u32;
                return Some((a << 24) | (r << 16) | (g << 8) | b);
            }
        }
    }

    // color-mix(in <space>, <color> [<pct>]?, <color> [<pct>]?) — CSS Color Module Level 5。
    // 簡略実装: 宣言された色空間（srgb/oklab/oklch 等）に関わらず常に単純な sRGB 0-255
    // 空間で線形補間する（知覚均等空間での補間は非対応。`:is()`/`:where()` と同じ
    // 「複雑な構文は簡略化して割り切る」既存方針に沿う）。
    if let Some(inner) = s_lower
        .strip_prefix("color-mix(")
        .and_then(|s| s.strip_suffix(')'))
    {
        if let Some((_space_clause, rest)) = inner.split_once(',') {
            let segs = split_top_level_commas(rest);
            if segs.len() == 2 {
                fn split_color_and_pct(seg: &str) -> (&str, Option<f32>) {
                    let seg = seg.trim();
                    if let Some(ws) = seg.rfind(char::is_whitespace) {
                        let (color_part, pct_part) = seg.split_at(ws);
                        let pct_part = pct_part.trim();
                        if let Some(num) = pct_part.strip_suffix('%') {
                            if let Ok(p) = num.trim().parse::<f32>() {
                                return (color_part.trim(), Some(p));
                            }
                        }
                    }
                    (seg, None)
                }
                let (c1_str, p1) = split_color_and_pct(segs[0]);
                let (c2_str, p2) = split_color_and_pct(segs[1]);
                let (w1, w2) = match (p1, p2) {
                    (None, None) => (50.0f32, 50.0f32),
                    (Some(a), None) => (a, 100.0 - a),
                    (None, Some(b)) => (100.0 - b, b),
                    (Some(a), Some(b)) => {
                        let sum = a + b;
                        if sum <= 0.0 {
                            (50.0, 50.0)
                        } else {
                            (a / sum * 100.0, b / sum * 100.0)
                        }
                    }
                };
                if let (Some(c1), Some(c2)) = (parse_color(c1_str), parse_color(c2_str)) {
                    let mix_channel = |shift: u32| -> u32 {
                        let v1 = ((c1 >> shift) & 0xFF) as f32;
                        let v2 = ((c2 >> shift) & 0xFF) as f32;
                        ((v1 * w1 + v2 * w2) / 100.0).clamp(0.0, 255.0) as u32
                    };
                    let a = mix_channel(24);
                    let r = mix_channel(16);
                    let g = mix_channel(8);
                    let b = mix_channel(0);
                    return Some((a << 24) | (r << 16) | (g << 8) | b);
                }
            }
        }
    }

    // rgb(r, g, b) / rgba(r, g, b, a) — hsl()/hwb() と同じくカンマ区切り（レガシー）と
    // スペース区切り＋任意の `/ alpha`（CSS Color Level 4）の両方を受理する。
    // 以前は `inner.split(',')` 固定でスペース区切り（`rgb(255 0 0)` 等）が
    // parts.len() の条件に一致せず静かに色なし（None）へ落ちるバグだった。
    let rgb_inner = s_lower
        .strip_prefix("rgba(")
        .or_else(|| s_lower.strip_prefix("rgb("))
        .and_then(|s| s.strip_suffix(')'));
    if let Some(inner) = rgb_inner {
        let parts: Vec<&str> = if inner.contains(',') {
            inner.split(',').collect()
        } else {
            inner.split_whitespace().filter(|s| *s != "/").collect()
        };
        if parts.len() >= 3 {
            let r = parse_rgb_component(parts[0]);
            let g = parse_rgb_component(parts[1]);
            let b = parse_rgb_component(parts[2]);
            let a_val = if parts.len() >= 4 {
                let a_str = parts[3].trim();
                if let Some(pct) = a_str.strip_suffix('%') {
                    pct.parse::<f32>().unwrap_or(100.0) / 100.0
                } else {
                    a_str.parse::<f32>().unwrap_or(1.0)
                }
            } else {
                1.0
            };
            let a = (a_val * 255.0).clamp(0.0, 255.0) as u32;
            return Some((a << 24) | (r << 16) | (g << 8) | b);
        }
    }

    // 名前付き色 (CSS Level 1-4 から実用的なものを網羅)
    match s_lower.as_str() {
        "black" => Some(0xFF000000),
        "white" => Some(0xFFFFFFFF),
        "red" => Some(0xFFFF0000),
        "lime" => Some(0xFF00FF00),
        "blue" => Some(0xFF0000FF),
        "yellow" => Some(0xFFFFFF00),
        "cyan" | "aqua" => Some(0xFF00FFFF),
        "magenta" | "fuchsia" => Some(0xFFFF00FF),
        "silver" => Some(0xFFC0C0C0),
        "gray" | "grey" => Some(0xFF808080),
        "maroon" => Some(0xFF800000),
        "olive" => Some(0xFF808000),
        "green" => Some(0xFF008000),
        "purple" => Some(0xFF800080),
        "teal" => Some(0xFF008080),
        "navy" => Some(0xFF000080),
        "orange" => Some(0xFFFFA500),
        "pink" => Some(0xFFFFC0CB),
        "brown" => Some(0xFFA52A2A),
        "coral" => Some(0xFFFF7F50),
        "tomato" => Some(0xFFFF6347),
        "gold" => Some(0xFFFFD700),
        "indigo" => Some(0xFF4B0082),
        "violet" => Some(0xFFEE82EE),
        "crimson" => Some(0xFFDC143C),
        "darkred" => Some(0xFF8B0000),
        "darkgreen" => Some(0xFF006400),
        "darkblue" => Some(0xFF00008B),
        "darkgray" | "darkgrey" => Some(0xFFA9A9A9),
        "lightgray" | "lightgrey" => Some(0xFFD3D3D3),
        "lightblue" => Some(0xFFADD8E6),
        "lightgreen" => Some(0xFF90EE90),
        "lightyellow" => Some(0xFFFFFFE0),
        "steelblue" => Some(0xFF4682B4),
        "slategray" | "slategrey" => Some(0xFF708090),
        "indianred" => Some(0xFFCD5C5C),
        "royalblue" => Some(0xFF4169E1),
        "dodgerblue" => Some(0xFF1E90FF),
        "skyblue" => Some(0xFF87CEEB),
        "whitesmoke" => Some(0xFFF5F5F5),
        "wheat" => Some(0xFFF5DEB3),
        "tan" => Some(0xFFD2B48C),
        "salmon" => Some(0xFFFA8072),
        "plum" => Some(0xFFDDA0DD),
        "orchid" => Some(0xFFDA70D6),
        "linen" => Some(0xFFFAF0E6),
        "khaki" => Some(0xFFF0E68C),
        "ivory" => Some(0xFFFFFFF0),
        "honeydew" => Some(0xFFF0FFF0),
        "hotpink" => Some(0xFFFF69B4),
        "deeppink" => Some(0xFFFF1493),
        "beige" => Some(0xFFF5F5DC),
        "aliceblue" => Some(0xFFF0F8FF),
        "transparent" => Some(0x00000000),
        // CSS Level 4 extended colors
        "rebeccapurple" => Some(0xFF663399),
        "mintcream" => Some(0xFFF5FFFA),
        "azure" => Some(0xFFF0FFFF),
        "floralwhite" => Some(0xFFFFFAF0),
        "ghostwhite" => Some(0xFFF8F8FF),
        "seashell" => Some(0xFFFFF5EE),
        "oldlace" => Some(0xFFFDF5E6),
        "antiquewhite" => Some(0xFFFAEBD7),
        "bisque" => Some(0xFFFFE4C4),
        "moccasin" => Some(0xFFFFE4B5),
        "navajowhite" => Some(0xFFFFDEAD),
        "papayawhip" => Some(0xFFFFEFD5),
        "peachpuff" => Some(0xFFFFDAB9),
        "mistyrose" => Some(0xFFFFE4E1),
        "lavender" => Some(0xFFE6E6FA),
        "lavenderblush" => Some(0xFFFFF0F5),
        "thistle" => Some(0xFFD8BFD8),
        "powderblue" => Some(0xFFB0E0E6),
        "lightcyan" => Some(0xFFE0FFFF),
        "paleturquoise" => Some(0xFFAFEEEE),
        "turquoise" => Some(0xFF40E0D0),
        "mediumturquoise" => Some(0xFF48D1CC),
        "darkturquoise" => Some(0xFF00CED1),
        "cadetblue" => Some(0xFF5F9EA0),
        "darkcyan" => Some(0xFF008B8B),
        "lightseagreen" => Some(0xFF20B2AA),
        "mediumaquamarine" => Some(0xFF66CDAA),
        "aquamarine" => Some(0xFF7FFFD4),
        "springgreen" => Some(0xFF00FF7F),
        "mediumspringgreen" => Some(0xFF00FA9A),
        "lawngreen" => Some(0xFF7CFC00),
        "chartreuse" => Some(0xFF7FFF00),
        "greenyellow" => Some(0xFFADFF2F),
        "yellowgreen" => Some(0xFF9ACD32),
        "darkolivegreen" => Some(0xFF556B2F),
        "olivedrab" => Some(0xFF6B8E23),
        "palegreen" => Some(0xFF98FB98),
        "mediumseagreen" => Some(0xFF3CB371),
        "seagreen" => Some(0xFF2E8B57),
        "forestgreen" => Some(0xFF228B22),
        "limegreen" => Some(0xFF32CD32),
        "darkkhaki" => Some(0xFFBDB76B),
        "goldenrod" => Some(0xFFDAA520),
        "darkgoldenrod" => Some(0xFFB8860B),
        "saddlebrown" => Some(0xFF8B4513),
        "sienna" => Some(0xFFA0522D),
        "peru" => Some(0xFFCD853F),
        "burlywood" => Some(0xFFDEB887),
        "sandybrown" => Some(0xFFF4A460),
        "chocolate" => Some(0xFFD2691E),
        "rosybrown" => Some(0xFFBC8F8F),
        "darkmagenta" => Some(0xFF8B008B),
        "darkviolet" => Some(0xFF9400D3),
        "blueviolet" => Some(0xFF8A2BE2),
        "mediumvioletred" => Some(0xFFC71585),
        "palevioletred" => Some(0xFFDB7093),
        "mediumorchid" => Some(0xFFBA55D3),
        "mediumpurple" => Some(0xFF9370DB),
        "slateblue" => Some(0xFF6A5ACD),
        "mediumslateblue" => Some(0xFF7B68EE),
        "darkslateblue" => Some(0xFF483D8B),
        "midnightblue" => Some(0xFF191970),
        "cornflowerblue" => Some(0xFF6495ED),
        "deepskyblue" => Some(0xFF00BFFF),
        "lightskyblue" => Some(0xFF87CEFA),
        "lightsteelblue" => Some(0xFFB0C4DE),
        "darkslategray" | "darkslategrey" => Some(0xFF2F4F4F),
        "dimgray" | "dimgrey" => Some(0xFF696969),
        "gainsboro" => Some(0xFFDCDCDC),
        "snow" => Some(0xFFFFFAFA),
        "lightcoral" => Some(0xFFF08080),
        "darksalmon" => Some(0xFFE9967A),
        "lightsalmon" => Some(0xFFFFA07A),
        "orangered" => Some(0xFFFF4500),
        "darkorange" => Some(0xFFFF8C00),
        "firebrick" => Some(0xFFB22222),
        "currentcolor" => None, // コンテキスト依存のため呼び出し側で処理
        _ => None,
    }
}