Skip to main content

parsec_css/values/
convert.rs

1// SPDX-License-Identifier: Apache-2.0
2// Copyright 2026 James Conway
3
4//! Colours worked out: conversion between every colour space of CSS
5//! Color 4 (its sample code's matrices and transfer functions, §18), and
6//! CSS Color 5's relative colours and `color-mix()`, as a computed value
7//! has them.
8
9// The matrices are CSS Color 4's sample code's, digit for digit.
10#![allow(clippy::excessive_precision)]
11
12use super::color::{Channel, Channels, Color, Model, Predefined, Relative, RelativeChannel};
13use super::math::Leaf;
14use super::units::write_number;
15use crate::parser::ComponentValue;
16use crate::tokenizer::Token;
17
18/// A colour space a colour can be worked out in.
19#[derive(Clone, Copy, Debug, PartialEq, Eq)]
20pub enum Space {
21    Srgb,
22    SrgbLinear,
23    DisplayP3,
24    DisplayP3Linear,
25    A98Rgb,
26    ProphotoRgb,
27    Rec2020,
28    XyzD50,
29    XyzD65,
30    Lab,
31    Lch,
32    Oklab,
33    Oklch,
34    Hsl,
35    Hwb,
36}
37
38impl Space {
39    fn parse(name: &str) -> Option<Space> {
40        Some(match name.to_ascii_lowercase().as_str() {
41            "srgb" => Space::Srgb,
42            "srgb-linear" => Space::SrgbLinear,
43            "display-p3" => Space::DisplayP3,
44            "display-p3-linear" => Space::DisplayP3Linear,
45            "a98-rgb" => Space::A98Rgb,
46            "prophoto-rgb" => Space::ProphotoRgb,
47            "rec2020" => Space::Rec2020,
48            "xyz-d50" => Space::XyzD50,
49            "xyz" | "xyz-d65" => Space::XyzD65,
50            "lab" => Space::Lab,
51            "lch" => Space::Lch,
52            "oklab" => Space::Oklab,
53            "oklch" => Space::Oklch,
54            "hsl" => Space::Hsl,
55            "hwb" => Space::Hwb,
56            _ => return None,
57        })
58    }
59
60    fn from_predefined(p: Predefined) -> Space {
61        match p {
62            Predefined::Srgb => Space::Srgb,
63            Predefined::SrgbLinear => Space::SrgbLinear,
64            Predefined::DisplayP3 => Space::DisplayP3,
65            Predefined::DisplayP3Linear => Space::DisplayP3Linear,
66            Predefined::A98Rgb => Space::A98Rgb,
67            Predefined::ProphotoRgb => Space::ProphotoRgb,
68            Predefined::Rec2020 => Space::Rec2020,
69            Predefined::XyzD50 => Space::XyzD50,
70            Predefined::XyzD65 => Space::XyzD65,
71        }
72    }
73
74    fn predefined_name(self) -> Option<&'static str> {
75        Some(match self {
76            Space::Srgb => "srgb",
77            Space::SrgbLinear => "srgb-linear",
78            Space::DisplayP3 => "display-p3",
79            Space::DisplayP3Linear => "display-p3-linear",
80            Space::A98Rgb => "a98-rgb",
81            Space::ProphotoRgb => "prophoto-rgb",
82            Space::Rec2020 => "rec2020",
83            Space::XyzD50 => "xyz-d50",
84            Space::XyzD65 => "xyz-d65",
85            _ => return None,
86        })
87    }
88
89    /// Which channel is the hue, for the polar spaces.
90    fn hue(self) -> Option<usize> {
91        match self {
92            Space::Hsl | Space::Hwb => Some(0),
93            Space::Lch | Space::Oklch => Some(2),
94            _ => None,
95        }
96    }
97
98    /// What kind of thing each channel is, for carrying a missing one
99    /// across a conversion (CSS Color 4 §12.2).
100    fn kinds(self) -> [Category; 3] {
101        use Category::*;
102        match self {
103            Space::Lab | Space::Oklab => [Lightness, Other, Other],
104            Space::Lch | Space::Oklch => [Lightness, Colorfulness, Hue],
105            Space::Hsl => [Hue, Colorfulness, Lightness],
106            Space::Hwb => [Hue, Other, Other],
107            Space::XyzD50 | Space::XyzD65 => [Red, Green, Blue],
108            _ => [Red, Green, Blue],
109        }
110    }
111}
112
113#[derive(Clone, Copy, PartialEq, Eq)]
114enum Category {
115    Red,
116    Green,
117    Blue,
118    Lightness,
119    Colorfulness,
120    Hue,
121    Other,
122}
123
124/// A colour with numbers for channels, `None` where one is missing.
125#[derive(Clone, Copy, Debug, PartialEq)]
126pub struct Absolute {
127    pub space: Space,
128    pub channels: [Option<f64>; 3],
129    pub alpha: Option<f64>,
130}
131
132type M = [[f64; 3]; 3];
133
134fn mul(m: &M, v: [f64; 3]) -> [f64; 3] {
135    [
136        m[0][0] * v[0] + m[0][1] * v[1] + m[0][2] * v[2],
137        m[1][0] * v[0] + m[1][1] * v[1] + m[1][2] * v[2],
138        m[2][0] * v[0] + m[2][1] * v[1] + m[2][2] * v[2],
139    ]
140}
141
142const SRGB_TO_XYZ: M = [
143    [0.41239079926595934, 0.357584339383878, 0.1804807884018343],
144    [0.21263900587151027, 0.715168678767756, 0.07219231536073371],
145    [0.01933081871559182, 0.11919477979462598, 0.9505321522496607],
146];
147const XYZ_TO_SRGB: M = [
148    [3.2409699419045226, -1.537383177570094, -0.4986107602930034],
149    [-0.9692436362808796, 1.8759675015077202, 0.04155505740717559],
150    [
151        0.05563007969699366,
152        -0.20397695888897652,
153        1.0569715142428786,
154    ],
155];
156const P3_TO_XYZ: M = [
157    [0.4865709486482162, 0.26566769316909306, 0.1982172852343625],
158    [0.2289745640697488, 0.6917385218365064, 0.079286914093745],
159    [0.0, 0.04511338185890264, 1.043944368900976],
160];
161const XYZ_TO_P3: M = [
162    [2.493496911941425, -0.9313836179191239, -0.40271078445071684],
163    [
164        -0.8294889695615747,
165        1.7626640603183463,
166        0.023624685841943577,
167    ],
168    [
169        0.03584583024378447,
170        -0.07617238926804182,
171        0.9568845240076872,
172    ],
173];
174const A98_TO_XYZ: M = [
175    [0.5766690429101305, 0.1855582379065463, 0.1882286462349947],
176    [0.29734497525053605, 0.6273635662554661, 0.07529145849399788],
177    [0.02703136138641234, 0.07068885253582723, 0.9913375368376388],
178];
179const XYZ_TO_A98: M = [
180    [
181        2.0415879038107465,
182        -0.5650069742788596,
183        -0.34473135077832956,
184    ],
185    [-0.9692436362808795, 1.8759675015077202, 0.04155505740717557],
186    [
187        0.013444280632031142,
188        -0.11836239223101838,
189        1.0151749943912054,
190    ],
191];
192const PROPHOTO_TO_XYZ50: M = [
193    [0.7977666449006423, 0.13518129740053308, 0.0313477341283922],
194    [0.2880748288194013, 0.711835234241873, 0.00008993693872564],
195    [0.0, 0.0, 0.8251046025104602],
196];
197const XYZ50_TO_PROPHOTO: M = [
198    [
199        1.3457868816471583,
200        -0.25557208737979464,
201        -0.05110186497554526,
202    ],
203    [-0.5446307051249019, 1.5082477428451468, 0.02052744743642139],
204    [0.0, 0.0, 1.2119675456389452],
205];
206const REC2020_TO_XYZ: M = [
207    [0.6369580483012914, 0.14461690358620832, 0.1688809751641721],
208    [0.2627002120112671, 0.6779980715188708, 0.05930171646986196],
209    [0.0, 0.028072693049087428, 1.060985057710791],
210];
211const XYZ_TO_REC2020: M = [
212    [1.716651187971268, -0.355670783776392, -0.25336628137366],
213    [-0.666684351832489, 1.616481236634939, 0.0157685458139111],
214    [0.017639857445311, -0.042770613257809, 0.942103121235474],
215];
216const D65_TO_D50: M = [
217    [
218        1.0479298208405488,
219        0.022946793341019088,
220        -0.05019222954313557,
221    ],
222    [
223        0.029627815688159344,
224        0.990434484573249,
225        -0.01707382502938514,
226    ],
227    [
228        -0.009243058152591178,
229        0.015055144896577895,
230        0.7518742899580008,
231    ],
232];
233const D50_TO_D65: M = [
234    [
235        0.9554734527042182,
236        -0.023098536874261423,
237        0.0632593086610217,
238    ],
239    [
240        -0.028369706963208136,
241        1.0099954580058226,
242        0.021041398966943008,
243    ],
244    [
245        0.012314001688319899,
246        -0.020507696433477912,
247        1.3303659366080753,
248    ],
249];
250const XYZ_TO_LMS: M = [
251    [0.8190224379967030, 0.3619062600528904, -0.1288737815209879],
252    [0.0329836539323885, 0.9292868615863434, 0.0361446663506424],
253    [0.0481771893596242, 0.2642395317527308, 0.6335478284694309],
254];
255const LMS_TO_OKLAB: M = [
256    [0.2104542683093140, 0.7936177747023054, -0.0040720430116193],
257    [1.9779985324311684, -2.4285922420485799, 0.4505937096174110],
258    [0.0259040424655478, 0.7827717124575296, -0.8086757548750674],
259];
260const OKLAB_TO_LMS: M = [
261    [1.0, 0.3963377773761749, 0.2158037573099136],
262    [1.0, -0.1055613458156586, -0.0638541728258133],
263    [1.0, -0.0894841775298119, -1.2914855480194092],
264];
265const LMS_TO_XYZ: M = [
266    [1.2268798758459243, -0.5578149944602171, 0.2813910456659647],
267    [-0.0405757452148008, 1.1122868032803170, -0.0717110580655164],
268    [-0.0763729366746601, -0.4214933324022432, 1.5869240198367816],
269];
270const D50_WHITE: [f64; 3] = [0.3457 / 0.3585, 1.0, (1.0 - 0.3457 - 0.3585) / 0.3585];
271
272fn srgb_to_linear(c: f64) -> f64 {
273    let a = c.abs();
274    if a <= 0.04045 {
275        c / 12.92
276    } else {
277        c.signum() * ((a + 0.055) / 1.055).powf(2.4)
278    }
279}
280
281fn linear_to_srgb(c: f64) -> f64 {
282    let a = c.abs();
283    if a > 0.0031308 {
284        c.signum() * (1.055 * a.powf(1.0 / 2.4) - 0.055)
285    } else {
286        12.92 * c
287    }
288}
289
290fn rec2020_to_linear(c: f64) -> f64 {
291    const A: f64 = 1.09929682680944;
292    const B: f64 = 0.018053968510807;
293    let a = c.abs();
294    if a < B * 4.5 {
295        c / 4.5
296    } else {
297        c.signum() * ((a + A - 1.0) / A).powf(1.0 / 0.45)
298    }
299}
300
301fn linear_to_rec2020(c: f64) -> f64 {
302    const A: f64 = 1.09929682680944;
303    const B: f64 = 0.018053968510807;
304    let a = c.abs();
305    if a > B {
306        c.signum() * (A * a.powf(0.45) - (A - 1.0))
307    } else {
308        4.5 * c
309    }
310}
311
312fn hsl_to_srgb(h: f64, s: f64, l: f64) -> [f64; 3] {
313    let (s, l) = (s / 100.0, l / 100.0);
314    let f = |n: f64| {
315        let k = (n + h / 30.0).rem_euclid(12.0);
316        let a = s * l.min(1.0 - l);
317        l - a * (k - 3.0).min(9.0 - k).clamp(-1.0, 1.0)
318    };
319    [f(0.0), f(8.0), f(4.0)]
320}
321
322fn srgb_to_hsl(rgb: [f64; 3]) -> [Option<f64>; 3] {
323    let [r, g, b] = rgb;
324    let max = r.max(g).max(b);
325    let min = r.min(g).min(b);
326    let l = (min + max) / 2.0;
327    let d = max - min;
328    let mut h = f64::NAN;
329    let mut s = 0.0;
330    // Near-equal channels, out of gamut by rounding: achromatic.
331    if d.abs() > 1e-6 {
332        s = if l == 0.0 || l == 1.0 {
333            0.0
334        } else {
335            (max - l) / l.min(1.0 - l)
336        };
337        h = if max == r {
338            (g - b) / d + if g < b { 6.0 } else { 0.0 }
339        } else if max == g {
340            (b - r) / d + 2.0
341        } else {
342            (r - g) / d + 4.0
343        } * 60.0;
344    }
345    if s < 0.0 {
346        h += 180.0;
347        s = s.abs();
348    }
349    if h >= 360.0 {
350        h -= 360.0;
351    }
352    // An achromatic colour's hue is powerless: missing.
353    let hue = if s.abs() < 1e-9 || h.is_nan() {
354        None
355    } else {
356        Some(h)
357    };
358    [hue, Some(s * 100.0), Some(l * 100.0)]
359}
360
361fn hwb_to_srgb(h: f64, w: f64, b: f64) -> [f64; 3] {
362    let (w, b) = (w / 100.0, b / 100.0);
363    if w + b >= 1.0 {
364        let gray = w / (w + b);
365        return [gray; 3];
366    }
367    hsl_to_srgb(h, 100.0, 50.0).map(|c| c * (1.0 - w - b) + w)
368}
369
370fn srgb_to_hwb(rgb: [f64; 3]) -> [Option<f64>; 3] {
371    let hsl = srgb_to_hsl(rgb);
372    let w = rgb[0].min(rgb[1]).min(rgb[2]);
373    let b = 1.0 - rgb[0].max(rgb[1]).max(rgb[2]);
374    let hue = if w + b >= 1.0 - 1e-4 { None } else { hsl[0] };
375    [hue, Some(w * 100.0), Some(b * 100.0)]
376}
377
378fn xyz50_to_lab(v: [f64; 3]) -> [f64; 3] {
379    const E: f64 = 216.0 / 24389.0;
380    const K: f64 = 24389.0 / 27.0;
381    let f = |x: f64| {
382        if x > E {
383            x.cbrt()
384        } else {
385            (K * x + 16.0) / 116.0
386        }
387    };
388    let [x, y, z] = [
389        v[0] / D50_WHITE[0],
390        v[1] / D50_WHITE[1],
391        v[2] / D50_WHITE[2],
392    ]
393    .map(f);
394    [116.0 * y - 16.0, 500.0 * (x - y), 200.0 * (y - z)]
395}
396
397fn lab_to_xyz50(lab: [f64; 3]) -> [f64; 3] {
398    const E: f64 = 216.0 / 24389.0;
399    const K: f64 = 24389.0 / 27.0;
400    let f1 = (lab[0] + 16.0) / 116.0;
401    let f0 = lab[1] / 500.0 + f1;
402    let f2 = f1 - lab[2] / 200.0;
403    let x = if f0.powi(3) > E {
404        f0.powi(3)
405    } else {
406        (116.0 * f0 - 16.0) / K
407    };
408    let y = if lab[0] > K * E {
409        f1.powi(3)
410    } else {
411        lab[0] / K
412    };
413    let z = if f2.powi(3) > E {
414        f2.powi(3)
415    } else {
416        (116.0 * f2 - 16.0) / K
417    };
418    [x * D50_WHITE[0], y * D50_WHITE[1], z * D50_WHITE[2]]
419}
420
421fn xyz_to_oklab(v: [f64; 3]) -> [f64; 3] {
422    let lms = mul(&XYZ_TO_LMS, v).map(f64::cbrt);
423    mul(&LMS_TO_OKLAB, lms)
424}
425
426fn oklab_to_xyz(v: [f64; 3]) -> [f64; 3] {
427    let lms = mul(&OKLAB_TO_LMS, v).map(|x| x * x * x);
428    mul(&LMS_TO_XYZ, lms)
429}
430
431fn to_polar(lab: [f64; 3], powerless: f64) -> [Option<f64>; 3] {
432    let c = (lab[1] * lab[1] + lab[2] * lab[2]).sqrt();
433    let h = lab[2].atan2(lab[1]).to_degrees().rem_euclid(360.0);
434    [
435        Some(lab[0]),
436        Some(c),
437        if c <= powerless { None } else { Some(h) },
438    ]
439}
440
441fn from_polar(lch: [f64; 3]) -> [f64; 3] {
442    let h = lch[2].to_radians();
443    [lch[0], lch[1] * h.cos(), lch[1] * h.sin()]
444}
445
446/// A colour's channels in XYZ D65, missing ones as 0.
447fn to_xyz(c: &Absolute) -> [f64; 3] {
448    let v = c.channels.map(|x| x.unwrap_or(0.0));
449    match c.space {
450        Space::Srgb => mul(&SRGB_TO_XYZ, v.map(srgb_to_linear)),
451        Space::SrgbLinear => mul(&SRGB_TO_XYZ, v),
452        Space::DisplayP3 => mul(&P3_TO_XYZ, v.map(srgb_to_linear)),
453        Space::DisplayP3Linear => mul(&P3_TO_XYZ, v),
454        Space::A98Rgb => mul(
455            &A98_TO_XYZ,
456            v.map(|x| x.signum() * x.abs().powf(563.0 / 256.0)),
457        ),
458        Space::ProphotoRgb => {
459            let lin = v.map(|x| {
460                if x.abs() <= 16.0 / 512.0 {
461                    x / 16.0
462                } else {
463                    x.signum() * x.abs().powf(1.8)
464                }
465            });
466            mul(&D50_TO_D65, mul(&PROPHOTO_TO_XYZ50, lin))
467        }
468        Space::Rec2020 => mul(&REC2020_TO_XYZ, v.map(rec2020_to_linear)),
469        Space::XyzD50 => mul(&D50_TO_D65, v),
470        Space::XyzD65 => v,
471        Space::Lab => mul(&D50_TO_D65, lab_to_xyz50(v)),
472        Space::Lch => mul(&D50_TO_D65, lab_to_xyz50(from_polar(v))),
473        Space::Oklab => oklab_to_xyz(v),
474        Space::Oklch => oklab_to_xyz(from_polar(v)),
475        Space::Hsl => mul(
476            &SRGB_TO_XYZ,
477            hsl_to_srgb(v[0], v[1], v[2]).map(srgb_to_linear),
478        ),
479        Space::Hwb => mul(
480            &SRGB_TO_XYZ,
481            hwb_to_srgb(v[0], v[1], v[2]).map(srgb_to_linear),
482        ),
483    }
484}
485
486fn from_xyz(v: [f64; 3], space: Space) -> [Option<f64>; 3] {
487    let some = |a: [f64; 3]| a.map(Some);
488    let srgb = || mul(&XYZ_TO_SRGB, v).map(linear_to_srgb);
489    match space {
490        Space::Srgb => some(srgb()),
491        Space::SrgbLinear => some(mul(&XYZ_TO_SRGB, v)),
492        Space::DisplayP3 => some(mul(&XYZ_TO_P3, v).map(linear_to_srgb)),
493        Space::DisplayP3Linear => some(mul(&XYZ_TO_P3, v)),
494        Space::A98Rgb => {
495            some(mul(&XYZ_TO_A98, v).map(|x| x.signum() * x.abs().powf(256.0 / 563.0)))
496        }
497        Space::ProphotoRgb => some(mul(&XYZ50_TO_PROPHOTO, mul(&D65_TO_D50, v)).map(|x| {
498            if x.abs() >= 1.0 / 512.0 {
499                x.signum() * x.abs().powf(1.0 / 1.8)
500            } else {
501                16.0 * x
502            }
503        })),
504        Space::Rec2020 => some(mul(&XYZ_TO_REC2020, v).map(linear_to_rec2020)),
505        Space::XyzD50 => some(mul(&D65_TO_D50, v)),
506        Space::XyzD65 => some(v),
507        Space::Lab => some(xyz50_to_lab(mul(&D65_TO_D50, v))),
508        Space::Lch => to_polar(xyz50_to_lab(mul(&D65_TO_D50, v)), 0.0015),
509        Space::Oklab => some(xyz_to_oklab(v)),
510        Space::Oklch => to_polar(xyz_to_oklab(v), 0.000004),
511        Space::Hsl => srgb_to_hsl(srgb()),
512        Space::Hwb => srgb_to_hwb(srgb()),
513    }
514}
515
516impl Absolute {
517    /// The colour in `space`, missing channels carried over where the two
518    /// spaces have a channel of the same kind.
519    pub fn convert(&self, space: Space) -> Absolute {
520        if space == self.space {
521            return *self;
522        }
523        // Nothing known converts to nothing known.
524        if self.channels.iter().all(Option::is_none) {
525            return Absolute {
526                space,
527                channels: [None; 3],
528                alpha: self.alpha,
529            };
530        }
531        let mut channels = from_xyz(to_xyz(self), space);
532        let (from, to) = (self.space.kinds(), space.kinds());
533        // Lab-like to LCh-like with both opponents missing: chroma and
534        // hue are missing too.
535        if matches!(self.space, Space::Lab | Space::Oklab)
536            && matches!(space, Space::Lch | Space::Oklch)
537            && self.channels[1].is_none()
538            && self.channels[2].is_none()
539        {
540            channels[1] = None;
541            channels[2] = None;
542        }
543        for (i, k) in to.iter().enumerate() {
544            if *k == Category::Other {
545                continue;
546            }
547            if let Some(j) = from.iter().position(|f| f == k)
548                && self.channels[j].is_none()
549            {
550                channels[i] = None;
551            }
552        }
553        Absolute {
554            space,
555            channels,
556            alpha: self.alpha,
557        }
558    }
559
560    /// Written as a computed colour: in its own function, the sRGB-based
561    /// ones as `color(srgb …)` unless a channel is missing.
562    pub fn write(&self) -> String {
563        let mut s = String::new();
564        let n = |s: &mut String, v: Option<f64>, pct: bool| match v {
565            None => s.push_str("none"),
566            Some(v) => {
567                let v = if v.abs() < 5e-7 || v.is_nan() { 0.0 } else { v };
568                write_number(s, v).unwrap();
569                if pct {
570                    s.push('%');
571                }
572            }
573        };
574        let (name, pcts, chans) = match self.space {
575            Space::Hsl | Space::Hwb if self.channels.iter().any(Option::is_none) => (
576                if self.space == Space::Hsl {
577                    "hsl("
578                } else {
579                    "hwb("
580                },
581                [false, true, true],
582                self.channels,
583            ),
584            Space::Hsl | Space::Hwb => (
585                "color(srgb ",
586                [false; 3],
587                self.convert(Space::Srgb).channels,
588            ),
589            Space::Lab => ("lab(", [false; 3], self.channels),
590            Space::Lch => ("lch(", [false; 3], self.channels),
591            Space::Oklab => ("oklab(", [false; 3], self.channels),
592            Space::Oklch => ("oklch(", [false; 3], self.channels),
593            sp => {
594                s.push_str("color(");
595                s.push_str(sp.predefined_name().unwrap());
596                s.push(' ');
597                ("", [false; 3], self.channels)
598            }
599        };
600        s.push_str(name);
601        for (i, (c, p)) in chans.iter().zip(pcts).enumerate() {
602            if i > 0 {
603                s.push(' ');
604            }
605            n(&mut s, *c, p);
606        }
607        match self.alpha {
608            Some(a) if (a - 1.0).abs() < 1e-9 => {}
609            a => {
610                s.push_str(" / ");
611                n(&mut s, a.map(|a| a.clamp(0.0, 1.0)), false);
612            }
613        }
614        s.push(')');
615        s
616    }
617}
618
619/// The channels a colour has, in its space; `None` for one that isn't
620/// known without an element (`currentcolor`) or unresolved math.
621pub fn absolute(c: &Color) -> Option<Absolute> {
622    match c {
623        Color::Named(_) => absolute(&c.computed()),
624        Color::Channels(ch) => from_channels(ch),
625        Color::Relative(r) => relative(r),
626        Color::Text(t) => absolute(&Color::parse(crate::parse_component_values(t).first()?)?),
627        Color::Mix(m) => {
628            let (space, hue, items) = m.parts.as_ref()?;
629            let items: Vec<(Absolute, Option<f64>)> = items
630                .iter()
631                .map(|(c, p)| Some((absolute(c)?, *p)))
632                .collect::<Option<_>>()?;
633            mix(*space, hue, &items)
634        }
635        _ => None,
636    }
637}
638
639/// A channel's number; math giving a percentage is `percent` a percent.
640fn channel(c: &Channel, percent: f64) -> Option<Option<f64>> {
641    match c {
642        Channel::None => Some(None),
643        Channel::Number(v) => Some(Some(*v)),
644        Channel::Math(m) => match m.leaf()? {
645            Leaf::Number(v) => Some(Some(v)),
646            Leaf::Percentage(p) => Some(Some(p * percent)),
647            Leaf::Dimension(v, u) => Some(Some(v * u.to_canonical()?)),
648        },
649    }
650}
651
652fn from_channels(ch: &Channels) -> Option<Absolute> {
653    let percent: [f64; 3] = match ch.model {
654        Model::Rgb => [2.55; 3],
655        Model::Hsl | Model::Hwb => [1.0; 3],
656        Model::Lab => [1.0, 1.25, 1.25],
657        Model::Lch => [1.0, 1.5, 1.0],
658        Model::Oklab => [0.01, 0.004, 0.004],
659        Model::Oklch => [0.01, 0.004, 1.0],
660        _ => [0.01; 3],
661    };
662    let v: Vec<Option<f64>> = ch
663        .channels
664        .iter()
665        .zip(percent)
666        .map(|(c, p)| channel(c, p))
667        .collect::<Option<_>>()?;
668    let alpha = channel(&ch.alpha, 0.01)?;
669    let space = match ch.model {
670        Model::Rgb => {
671            return Some(Absolute {
672                space: Space::Srgb,
673                channels: [
674                    v[0].map(|x| x / 255.0),
675                    v[1].map(|x| x / 255.0),
676                    v[2].map(|x| x / 255.0),
677                ],
678                alpha,
679            });
680        }
681        Model::Hsl => Space::Hsl,
682        Model::Hwb => Space::Hwb,
683        Model::Lab => Space::Lab,
684        Model::Lch => Space::Lch,
685        Model::Oklab => Space::Oklab,
686        Model::Oklch => Space::Oklch,
687        Model::Color(p) => Space::from_predefined(p),
688        Model::DeviceCmyk => return None,
689    };
690    // Computed values clamp what parsing couldn't, in math: lightness,
691    // chroma, alpha; and hues go round.
692    let mut channels = [v[0], v[1], v[2]];
693    let clamp = |c: &mut Option<f64>, lo: f64, hi: f64| {
694        if let Some(x) = c {
695            *x = if x.is_nan() { 0.0 } else { x.clamp(lo, hi) };
696        }
697    };
698    match space {
699        Space::Lab => clamp(&mut channels[0], 0.0, 100.0),
700        Space::Lch => {
701            clamp(&mut channels[0], 0.0, 100.0);
702            clamp(&mut channels[1], 0.0, f64::INFINITY);
703        }
704        Space::Oklab => clamp(&mut channels[0], 0.0, 1.0),
705        Space::Oklch => {
706            clamp(&mut channels[0], 0.0, 1.0);
707            clamp(&mut channels[1], 0.0, f64::INFINITY);
708        }
709        _ => {}
710    }
711    if let Some(h) = space.hue()
712        && let Some(x) = &mut channels[h]
713    {
714        *x = if x.is_finite() {
715            x.rem_euclid(360.0)
716        } else {
717            0.0
718        };
719    }
720    for c in &mut channels {
721        if let Some(x) = c
722            && x.is_nan()
723        {
724            *x = 0.0;
725        }
726    }
727    let mut alpha = alpha;
728    clamp(&mut alpha, 0.0, 1.0);
729    Some(Absolute {
730        space,
731        channels,
732        alpha,
733    })
734}
735
736/// What 100% of each channel is in a relative colour's function, and
737/// the scale its channel names have there.
738fn scales(function: &str, space: Space) -> [f64; 3] {
739    match (function, space) {
740        ("rgb", _) => [255.0; 3],
741        ("hsl" | "hwb", _) => [1.0, 100.0, 100.0],
742        (_, Space::Lab) => [100.0, 125.0, 125.0],
743        (_, Space::Lch) => [100.0, 150.0, 1.0],
744        (_, Space::Oklab) => [1.0, 0.4, 0.4],
745        (_, Space::Oklch) => [1.0, 0.4, 1.0],
746        _ => [1.0; 3],
747    }
748}
749
750fn relative(r: &Relative) -> Option<Absolute> {
751    let space = match (r.function, r.space) {
752        ("rgb", _) => Space::Srgb,
753        ("color", Some(p)) => Space::from_predefined(p),
754        ("alpha", _) => absolute(&r.origin)?.space,
755        (f, _) => Space::parse(f)?,
756    };
757    let origin = absolute(&r.origin)?.convert(space);
758    let scale = scales(r.function, space);
759    // The channel names, in the units the function writes its channels in.
760    let names: &[&str] = match r.function {
761        "rgb" => &["r", "g", "b"],
762        "hsl" => &["h", "s", "l"],
763        "hwb" => &["h", "w", "b"],
764        "lab" | "oklab" => &["l", "a", "b"],
765        "lch" | "oklch" => &["l", "c", "h"],
766        "alpha" => &[],
767        _ if matches!(space, Space::XyzD50 | Space::XyzD65) => &["x", "y", "z"],
768        _ => &["r", "g", "b"],
769    };
770    let rgb = r.function == "rgb";
771    // A name for a missing channel is missing too; in math it's 0.
772    let named_missing = |k: &str| -> Option<Option<f64>> {
773        if k == "alpha" {
774            return Some(origin.alpha);
775        }
776        let i = names.iter().position(|n| *n == k)?;
777        Some(origin.channels[i].map(|v| if rgb { v * 255.0 } else { v }))
778    };
779    let named = |k: &str| named_missing(k).map(|v| v.unwrap_or(0.0));
780    let value = |c: &RelativeChannel, i: Option<usize>| -> Option<Option<f64>> {
781        let pct = i.map_or(1.0, |i| scale[i]);
782        Some(match c {
783            RelativeChannel::None => None,
784            RelativeChannel::Number(v) => Some(*v),
785            RelativeChannel::Percentage(p) => Some(p / 100.0 * pct),
786            RelativeChannel::Angle(v, u) => Some(v * u.to_canonical()?),
787            RelativeChannel::Keyword(k) => named_missing(k)?,
788            RelativeChannel::Math(m) => {
789                let m = m.substitute_keywords(&named);
790                Some(match m.leaf()? {
791                    Leaf::Number(v) => v,
792                    Leaf::Percentage(p) => p / 100.0 * pct,
793                    Leaf::Dimension(v, u) => v * u.to_canonical()?,
794                })
795            }
796        })
797    };
798    let mut channels = origin.channels;
799    for (i, c) in r.channels.iter().enumerate() {
800        let mut v = value(c, Some(i))?;
801        if rgb {
802            v = v.map(|x| x / 255.0);
803        }
804        channels[i] = v;
805    }
806    let alpha = match &r.alpha {
807        Some(a) => value(a, None)?.map(|a| a.clamp(0.0, 1.0)),
808        None => origin.alpha,
809    };
810    Some(Absolute {
811        space,
812        channels,
813        alpha,
814    })
815}
816
817/// What `color-mix()` mixes, and how: its space, its hue method, and
818/// each colour with its percentage.
819pub(crate) fn mix_parts(f: &crate::parser::Function<'_>) -> Option<super::color::MixParts> {
820    if !f.name.eq_ignore_ascii_case("color-mix") {
821        return None;
822    }
823    let parts: Vec<Vec<&ComponentValue<'_>>> = f
824        .arguments
825        .split(|v| matches!(v, ComponentValue::Token(Token::Comma, _)))
826        .map(|p| p.iter().filter(|v| !v.is_whitespace()).collect())
827        .collect();
828    let (mut space, mut hue, mut start) = (Space::Oklab, "shorter", 0);
829    if let Some(ComponentValue::Token(Token::Ident(w), _)) = parts[0].first().copied()
830        && w.eq_ignore_ascii_case("in")
831    {
832        let ComponentValue::Token(Token::Ident(s), _) = parts[0].get(1)? else {
833            return None;
834        };
835        space = Space::parse(s)?;
836        if let Some(ComponentValue::Token(Token::Ident(h), _)) = parts[0].get(2) {
837            hue = match h.to_ascii_lowercase().as_str() {
838                "shorter" => "shorter",
839                "longer" => "longer",
840                "increasing" => "increasing",
841                "decreasing" => "decreasing",
842                _ => return None,
843            };
844        }
845        start = 1;
846    }
847    let mut items = Vec::new();
848    for p in &parts[start..] {
849        let (color, pct) = match p[..] {
850            [c] => (c, None),
851            [c, ComponentValue::Token(Token::Percentage(n), _)]
852            | [ComponentValue::Token(Token::Percentage(n), _), c] => (c, Some(n.value)),
853            [c, ComponentValue::Function(m)] | [ComponentValue::Function(m), c]
854                if super::math::Math::is_math_function(&m.name) =>
855            {
856                match super::math::Math::parse(m)?.leaf()? {
857                    Leaf::Percentage(p) => (c, Some(p)),
858                    _ => return None,
859                }
860            }
861            _ => return None,
862        };
863        items.push((Color::parse(color)?, pct));
864    }
865    Some((space, hue, items))
866}
867
868/// CSS Color 5 §3: mix colours in `space`, premultiplied, the hue taken
869/// the way `hue` says. Percentages left out share what the others leave
870/// of 100%; more than two colours mix in turn, each by its share of the
871/// weight so far.
872fn mix(space: Space, hue: &str, items: &[(Absolute, Option<f64>)]) -> Option<Absolute> {
873    if items.is_empty() {
874        return None;
875    }
876    if items.len() == 1 {
877        return Some(items[0].0.convert(space));
878    }
879    let given: f64 = items.iter().filter_map(|(_, p)| *p).sum();
880    let missing = items.iter().filter(|(_, p)| p.is_none()).count();
881    let share = if missing > 0 {
882        ((100.0 - given) / missing as f64).max(0.0)
883    } else {
884        0.0
885    };
886    let weights: Vec<f64> = items.iter().map(|(_, p)| p.unwrap_or(share)).collect();
887    let sum: f64 = weights.iter().sum();
888    // Nothing of any: an even mix, transparent.
889    let (multiplier, weights) = if sum == 0.0 {
890        (0.0, vec![1.0; items.len()])
891    } else {
892        (if sum < 100.0 { sum / 100.0 } else { 1.0 }, weights)
893    };
894    let mut acc = items[0].0.convert(space);
895    let mut acc_w = weights[0];
896    for ((c, _), w) in items[1..].iter().zip(&weights[1..]) {
897        let t = if acc_w + w == 0.0 {
898            0.5
899        } else {
900            w / (acc_w + w)
901        };
902        acc = mix2(space, hue, &acc, c, t);
903        acc_w += w;
904    }
905    acc.alpha = acc.alpha.map(|a| a * multiplier);
906    Some(acc)
907}
908
909fn mix2(space: Space, hue: &str, a: &Absolute, b: &Absolute, t: f64) -> Absolute {
910    let (a, b) = (a.convert(space), b.convert(space));
911    let hue_at = space.hue();
912    let (aa, ba) = (a.alpha, b.alpha);
913    let alpha = match (aa, ba) {
914        (None, None) => None,
915        (x, y) => {
916            let (x, y) = (x.or(y).unwrap(), y.or(x).unwrap());
917            Some(x + (y - x) * t)
918        }
919    };
920    let (wa, wb) = (aa.or(ba).unwrap_or(1.0), ba.or(aa).unwrap_or(1.0));
921    let mut out = [None; 3];
922    for (i, slot) in out.iter_mut().enumerate() {
923        let (x, y) = match (a.channels[i], b.channels[i]) {
924            (None, None) => continue,
925            (Some(x), None) => (x, x),
926            (None, Some(y)) => (y, y),
927            (Some(x), Some(y)) => (x, y),
928        };
929        *slot = Some(if Some(i) == hue_at {
930            let (mut x, mut y) = (x.rem_euclid(360.0), y.rem_euclid(360.0));
931            let d = y - x;
932            match hue {
933                "shorter" if d > 180.0 => x += 360.0,
934                "shorter" if d < -180.0 => y += 360.0,
935                "longer" if d > 0.0 && d < 180.0 => x += 360.0,
936                "longer" if d > -180.0 && d <= 0.0 => y += 360.0,
937                "increasing" if y < x => y += 360.0,
938                "decreasing" if x < y => x += 360.0,
939                _ => {}
940            }
941            (x + (y - x) * t).rem_euclid(360.0)
942        } else {
943            // Premultiplied by alpha.
944            let v = x * wa + (y * wb - x * wa) * t;
945            match alpha {
946                Some(al) if al != 0.0 => v / al,
947                _ => v,
948            }
949        });
950    }
951    Absolute {
952        space,
953        channels: out,
954        alpha,
955    }
956}