# Supported Colors

## sRGB

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `srgb`

    **White Point:** D65

    **Coordinates:**

    Name       | Range
    ---------- | -----
    red        | [0, 1]
    green      | [0, 1]
    blue       | [0, 1]

The sRGB space is a standard RGB (red, green, blue) color space that HP and Microsoft created cooperatively in 1996 to
use on monitors, printers, and the Web. SRGB stands for "Standard RGB". It is the most widely used color space and is
supported by most operating systems, software programs, monitors, and printers.

---

Parsed input and string output formats support all valid CSS forms:

```css-color
black                  // Color name
#RRGGBBAA              // Hex
rgb(r g b / a)         // RGB function
rgb(r, g, b)           // Legacy RGB Function
rgba(r, g, b, a)       // Legacy RGBA function
color(srgb r g b / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("srgb", [0, 0, 0], 1)
```

The string representation of the color object will always default to the `#!css-color color(srgb r g b / a)` form, but
the default string output will be the `#!css-color rgb(r g b / a)` form.

```playground
Color("srgb", [0, 0, 0], 1)
Color("srgb", [0, 0, 0], 1).to_string()
```

_[Learn about sRGB](https://en.wikipedia.org/wiki/SRGB)_
</div>

## HSV

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `hsv`

    **White Point:** D65

    **Coordinates:**

    Name       | Range
    ---------- | -----
    hue        | [0, 360)
    saturation | [0, 100]
    value      | [0, 100]

HSV is a color space similar to the modern [RGB](#srgb) and CMYK models. The HSV color space has three components: hue,
saturation and value. 'Value' is sometimes substituted with 'brightness' and then it is known as HSB. HSV models how
colors appear under light.

---

HSV is not supported via the CSS spec and the parser input and string output only supports the `#!css-color color()`
function format using the custom name `#!css-color --hsv`:

```css-color
color(--hsv 0 0% 0% / 1)
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("hsv", [0, 0, 0], 1)
```

The string representation of the color object and default string output will always use the
`#!css-color color(hsv h s v / a)` form.

```playground
Color("hsv", [0, 0, 0], 1)
Color("hsv", [0, 0, 0], 1).to_string()
```

_[Learn about HSV](https://en.wikipedia.org/wiki/HSL_and_HSV)_
</div>

## HSL

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `hsl`

    **White Point:**   D65

    **Coordinates:**

    Name       | Range
    ---------- | -----
    hue        | [0, 360)
    saturation | [0, 100]
    lightness  | [0, 100]

HSL is an alternative representations of the [RGB](#srgb) color model, designed in the 1970s by computer graphics
researchers to more closely align with the way human vision perceives color-making attributes. In these models, colors
of each hue are arranged in a radial slice, around a central axis of neutral colors which ranges from black at the
bottom to white at the top.

HSL models the way different paints mix together to create color in the real world, with the lightness dimension
resembling the varying amounts of black or white paint in the mixture.

---

Parsed input and string output formats support all valid CSS forms. In addition, we also allow the `#!css-color color()`
function format using the custom name `#!css-color --hsl`:

```css-color
hsl(h s l / a)          // HSL function
hsl(h, s, l)            // Legacy HSL function
hsla(h, s, l, a)        // Legacy HSLA function
color(--hsl h s l / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("hsl", [0, 0, 0], 1)
```

The string representation of the color object will always default to the `#!css-color color(--hsl h s l / a)` form, but
the default string output will be the `#!css-color hsl(h s l / a)` form.

```playground
Color("hsl", [0, 0, 0], 1)
Color("hsl", [0, 0, 0], 1).to_string()
```

_[Learn about HSL](https://en.wikipedia.org/wiki/HSL_and_HSV)_
</div>

## HWB

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `hwb`

    **White Point:** D65

    **Coordinates:**

    Name       | Range
    ---------- | -----
    hue        | [0, 360)
    whiteness  | [0, 100]
    blackness  | [0, 100]

HWB is a cylindrical-coordinate representation of points in an [RGB](#srgb) color model, similar to HSL and HSV. It was
developed by [HSV](#hsv)'s creator Alvy Ray Smith in 1996 to address some of the issues with HSV. HWB was designed to be
more intuitive for humans to use and slightly faster to compute. The first coordinate, H (Hue), is the same as the Hue
coordinate in [HSL](#hsl) and [HSV](#hsv). W and B stand for Whiteness and Blackness respectively and range from 0-100%
(or 0-1). The mental model is that the user can pick a main hue and then "mix" it with white and/or black to produce the
desired color.

---

Parsed input and string output formats support all valid CSS forms. In addition, we also allow the `#!css-color color()`
function format using the custom name `#!css-color --hwb`:

```css-color
hwb(h w b / a)          // HWB function
color(--hwb h w b / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("hwb", [0, 0, 100], 1)
```

The string representation of the color object will always default to the `#!css-color color(--hwb h w b / a)` form, but
the default string output will be the `#!css-color hsl(h s l / a)` form.

```playground
Color("hwb", [0, 0, 100], 1)
Color("hwb", [0, 0, 100], 1).to_string()
```

_[Learn about HWB](https://en.wikipedia.org/wiki/HWB_color_model)_
</div>

## Display P3

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `display-p3`

    **White Point:** D65

    **Coordinates:**

    Name       | Range
    ---------- | -----
    red        | [0, 1]
    green      | [0, 1]
    blue       | [0, 1]

Display P3 is a combination of the DCI-P3 color gamut with the D65 white point together with the [sRGB](#srgb) gamma
curve. It originated from the DCI-P3 color gamut's implementation in digital cinema projectors, as this standard offers
more vibrant greens and reds than the traditional [sRGB](#srgb) color gamut.

---

Parsed input and string output formats support all valid CSS forms:

```css-color
color(display-p3 r g b / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("display-p3", [0, 0, 0], 1)
```

The string representation of the color object and the default string output will be in the
`#!css-color color(display-p3 r g b / a)` form.

```playground
Color("display-p3", [0, 0, 0], 1)
Color("display-p3", [0, 0, 0], 1).to_string()
```

_[Learn about Display P3](https://en.wikipedia.org/wiki/DCI-P3#Display_P3)_
</div>

## A98 RGB

<div class="info-container" markdown="1">

!!! info inline end "Properties"

    **Name:** `a98-rgb`

    **White Point:** D65

    **Coordinates:**

    Name       | Range
    ---------- | -----
    red        | [0, 1]
    green      | [0, 1]
    blue       | [0, 1]

The Adobe RGB (1998) color space or opRGB is a color space developed by Adobe Systems, Inc. in 1998. It was designed to
encompass most of the colors achievable on CMYK color printers, but by using [RGB](#srgb) primary colors on a device
such as a computer display. The Adobe RGB (1998) color space encompasses roughly 50% of the visible colors specified by
the [CIELAB](#cielab) color space - improving upon the gamut of the [sRGB](#srgb) color space, primarily in cyan-green
hues.

---

Parsed input and string output formats support all valid CSS forms:

```css-color
color(a98-rgb r g b / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("a98-rgb", [0, 0, 0], 1)
```

The string representation of the color object and the default string output will be in the
`#!css-color color(a98-rgb r g b / a)` form.

```playground
Color("a98-rgb", [0, 0, 0], 1)
Color("a98-rgb", [0, 0, 0], 1).to_string()
```

_[Learn about A98 RGB](https://en.wikipedia.org/wiki/Adobe_RGB_color_space)_
</div>

## REC.2020

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `rec2020`

    **White Point:** D65

    **Coordinates:**

    Name       | Range
    ---------- | -----
    red        | [0, 1]
    green      | [0, 1]
    blue       | [0, 1]

The Rec. 2020 color space is a result of this and is a very wide gamut RGB color space which is used in 4k and 8k UHDTV.
ITU-R Recommendation BT.2020, more commonly known by the abbreviations Rec. 2020 or BT.2020, defines various aspects of
ultra-high-definition television (UHDTV) with standard dynamic range (SDR) and wide color gamut (WCG), including picture
resolutions, frame rates with progressive scan, bit depths, color primaries, RGB and luma-chroma color representations,
chroma subsamplings, and an opto-electronic transfer function.

---

Parsed input and string output formats support all valid CSS forms:

```css-color
color(rec2020 r g b / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("rec2020", [0, 0, 0], 1)
```

The string representation of the color object and the default string output will be in the
`#!css-color color(rec2020 r g b / a)` form.

```playground
Color("rec2020", [0, 0, 0], 1)
Color("rec2020", [0, 0, 0], 1).to_string()
```

_[Learn about REC.2020](https://en.wikipedia.org/wiki/Rec._2020)_
</div>

## ProPhoto

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `prophoto-rgb`

    **White Point:** D50

    **Coordinates:**

    Name       | Range
    ---------- | -----
    red        | [0, 1]
    green      | [0, 1]
    blue       | [0, 1]

The ProPhoto RGB color space, also known as ROMM RGB (Reference Output Medium Metric), is an output referred RGB color
space developed by Kodak. It offers an especially large gamut designed for use with photographic output in mind. The
ProPhoto RGB color space encompasses over 90% of possible surface colors in the [CIE L\*a\*b\*](#cielab) color space,
and 100% of likely occurring real-world surface colors documented by Pointer in 1980.

---

Parsed input and string output formats support all valid CSS forms:

```css-color
color(prophoto-rgb r g b / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("prophoto-rgb", [0, 0, 0], 1)
```

The string representation of the color object and the default string output will be in the
`#!css-color color(prophoto-rgb r g b / a)` form.

```playground
Color("prophoto-rgb", [0, 0, 0], 1)
Color("prophoto-rgb", [0, 0, 0], 1).to_string()
```

_[Learn about ProPhoto](https://en.wikipedia.org/wiki/ProPhoto_RGB_color_space)_
</div>

## XYZ

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `xyz`

    **White Point:** D50

    **Coordinates:**

    Name       | Range
    ---------- | -----
    x:         | [0.0, 0.964]^\*^
    y:         | [0.0, 1.0]^\*^
    z:         | [0.0, 0.825]^\*^

    ^\*^ ≈ range in relation to sRGB rounded to 3 decimal places.

The CIE 1931 RGB color space and CIE 1931 XYZ color space were created by the International Commission on Illumination
(CIE) in 1931. They resulted from a series of experiments done in the late 1920s by William David Wright using ten
observers and John Guild using seven observers. The experimental results were combined into the specification of the
CIE RGB color space, from which the CIE XYZ color space was derived. The CIE 1931 color spaces are the first defined
quantitative links between distributions of wavelengths in the electromagnetic visible spectrum, and physiologically
perceived colors in human color vision.

---

Parsed input and string output formats support all valid CSS forms:

```css-color
color(xyz x y z / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("xyz", [0, 0, 0], 1)
```

The string representation of the color object and the default string output will be in the
`#!css-color color(xyz x y z / a)` form.

```playground
Color("xyz", [0, 0, 0], 1)
Color("xyz", [0, 0, 0], 1).to_string()
```

_[Learn about XYZ](https://en.wikipedia.org/wiki/CIE_1931_color_space)_
</div>

## XYZ D65

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `xyz-d65`

    **White Point:** D65

    **Coordinates:**

    Name       | Range
    ---------- | -----
    x          | [0.0, 0.95]^\*^
    y          | [0.0, 1.0]^\*^
    z          | [0.0, 1.089]^\*^

    ^\*^ ≈ range in relation to sRGB rounded to 3 decimal places.

XYZ D65 is the same as [XYZ](#xyz) except it uses a D65 white point.

---

Parsed input and string output formats use the `#!css-color color()` format with the custom name `#!css-color --xyz-d65`
as XYZ D65 is not currently supported in the current CSS spec:

```css-color
color(--xyz-d65 x y z / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("xyz-d65", [0, 0, 0], 1)
```

The string representation of the color object and the default string output will be in the
`#!css-color color(--xyz x y z / a)` form.

```playground
Color("xyz-d65", [0, 0, 0], 1)
Color("xyz-d65", [0, 0, 0], 1).to_string()
```

_[Learn about XYZ](https://en.wikipedia.org/wiki/CIE_1931_color_space)_
</div>

## CIELAB

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `lab`

    **White Point:** D50

    **Coordinates:**

    Name       | Range
    ---------- | -----
    lightness  | [0, 100]^\*^
    a          | [-79.287, 93.55]^\*^
    b          | [-112.029, 93.388]^\*^

    ^\*^ ≈ range in relation to sRGB rounded to 3 decimal places.

The CIELAB color space also referred to as L\*a\*b\* is a color space defined by the International Commission on
Illumination (abbreviated CIE) in 1976. It expresses color as three values: L\* for perceptual lightness, and a\* and
b\* for the four unique colors of human vision: red, green, blue, and yellow. CIELAB was intended as a perceptually
uniform space, where a given numerical change corresponds to similar perceived change in color. While the CIELAB space
is not truly perceptually uniform, it nevertheless is useful in industry for detecting small differences in color.

---

Parsed input and string output formats support all valid CSS forms. In addition, we also allow the `#!css-color color()`
function format using the custom name `#!css-color --lab`:

```css-color
lab(l a b / a)          // Lab function
color(--lab l a b / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("lab", [0, 0, 0], 1)
```

The string representation of the color object will always default to the `#!css-color color(--lab l a b / a)` form, but
the default string output will be the `#!css-color hsl(h s l / a)` form.

```playground
Color("lab", [0, 0, 0], 1)
Color("lab", [0, 0, 0], 1).to_string()
```

_[Learn about CIELAB](https://en.wikipedia.org/wiki/CIELAB_color_space)_
</div>

## CIELCH

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `lch`

    **White Point:** D50

    **Coordinates:**

    Name       | Range
    ---------- | -----
    lightness  | [0, 100]^\*^
    chroma     | [0.0, 131.207]^\*^
    hue        | [0, 360)

    ^\*^ ≈ range in relation to sRGB rounded to 3 decimal places.

The "CIELCH" or "CIEHLC" space is a color space based on [CIELAB](#cielab), which uses the polar coordinates C\*
(chroma, relative saturation) and h&deg; (hue angle, angle of the hue in the CIELAB color wheel) instead of the Cartesian
coordinates a\* and b\*. The CIELAB lightness L\* remains unchanged.

---

Parsed input and string output formats support all valid CSS forms. In addition, we also allow the `#!css-color color()`
function format using the custom name `#!css-color --lch`:

```css-color
lch(l c h / a)          // Lch function
color(--lch l c h / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("lch", [0, 0, 0], 1)
```

The string representation of the color object will always default to the `#!css-color color(--lch l c h / a)` form, but
the default string output will be the `#!css-color hsl(l c h / a)` form.

```playground
Color("lch", [0, 0, 0], 1)
Color("lch", [0, 0, 0], 1).to_string()
```

_[Learn about CIELCH](https://en.wikipedia.org/wiki/CIELAB_color_space#Cylindrical_representation:_CIELCh_or_CIEHLC)_
</div>

## CIELAB D65

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `lab-d65`

    **White Point:** D65

    **Coordinates:**

    Name      | Range
    --------- | -----
    lightness | [0, 100]^\*^
    a         | [-86.183, 98.234]^\*^
    b         | [-107.86, 94.478]^\*^

    ^\*^ ≈ range in relation to sRGB rounded to 3 decimal places.

CIELAB D65 is the same as [CIELAB](#cielab) except it uses a D65 white point.

---

As a D65 variant of CIELAB is not currently supported in the CSS spec, the parsed input and string output formats use
the `#!css-color color()` function format using the custom name `#!css-color --lab-d65`:

```css-color
color(--lab-d65 l a b / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("lab-d65", [0, 0, 0], 1)
```

The string representation of the color object and the default string output use the
`#!css-color color(--lab-d65 l a b / a)` form.

```playground
Color("lab-d65", [0, 0, 0], 1)
Color("lab-d65", [0, 0, 0], 1).to_string()
```

_[Learn about CIELAB](https://en.wikipedia.org/wiki/CIELAB_color_space)_
</div>

## CIELCH D65

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `lch-d65`

    **White Point:** D65

    **Coordinates:**

    Name       | Range
    ---------- | -----
    lightness  | [0, 100]^\*^
    chroma     | [0.0, 133.808]^\*^
    hue        | [0, 360)

    ^\*^ ≈ range in relation to sRGB rounded to 3 decimal places.

CIELCH D65 is the same as [CIELCH](#cielch) except it uses a D65 white point.

---

As a D65 variant of CIELCH is not currently supported in the CSS spec, the parsed input and string output formats use
the `#!css-color color()` function format using the custom name `#!css-color --lch-d65`:

```css-color
color(--lch-d65 l c h / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("lch-d65", [0, 0, 0], 1)
```

The string representation of the color object and the default string output use the
`#!css-color color(--lch-d65 l c h / a)` form.

```playground
Color("lch-d65", [0, 0, 0], 1)
Color("lch-d65", [0, 0, 0], 1).to_string()
```

_[Learn about CIELCH](https://en.wikipedia.org/wiki/CIELAB_color_space#Cylindrical_representation:_CIELCh_or_CIEHLC)_
</div>

## CIELUV

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `luv`

    **White Point:** D50

    **Coordinates:**

    Name       | Range
    ---------- | -----
    lightness  | [0, 100]^\*^
    a          | [-84.937, 175.043]^\*^
    b          | [-125.882, 87.244]^\*^

    ^\*^ ≈ range in relation to sRGB rounded to 3 decimal places.

CIELUV, is a color space adopted by the CIE in 1976, as a simple-to-compute transformation of the 1931 CIE XYZ color
space, but which attempted perceptual uniformity.

---

As CIELUV is not currently supported in the CSS spec, the parsed input and string output formats use the
`#!css-color color()` function format using the custom name `#!css-color --luv`:

```css-color
color(--luv l u v / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("luv", [0, 0, 0], 1)
```

The string representation of the color object and the default string output use the
`#!css-color color(--luv l u v / a)` form.

```playground
Color("luv", [0, 0, 0], 1)
Color("luv", [0, 0, 0], 1).to_string()
```

_[Learn about CIELUV](https://en.wikipedia.org/wiki/CIELUV)_
</div>

## CIELCH~uv~

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `jzczhz`

    **White Point:** D65

    **Coordinates:**

    Name   | Range
    ------ | -----
    jz     | [0, 100]^\*^
    chroma | [0, 176.957]^\*^
    hue    | [0 - 360)

    ^\*^ ≈ range in relation to sRGB rounded to 3 decimal places.

CIELCH~uv~ is the polar form of [CIELUV](#cieluv).

---

As CIELCH~uv~ is not currently supported in the CSS spec, the parsed input and string output formats use the
`#!css-color color()` function format using the custom name `#!css-color --lchuv`:

```css-color
color(--lchuv l c h / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("lchuv", [0, 0, 0], 1)
```

The string representation of the color object and the default string output use the
`#!css-color color(--lchuv jz cz hz / a)` form.

```playground
Color("lchuv", [0, 0, 0], 1)
Color("lchuv", [0, 0, 0], 1).to_string()
```

_[Learn about CIELCH~uv~](https://en.wikipedia.org/wiki/CIELUV)_
</div>

## Oklab

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `oklab`

    **White Point:** D65

    **Coordinates:**

    Name       | Range
    ---------- | -----
    lightness  | [0, 1]
    a          | [-0.5, 0.5]
    b          | [-0.5, 0.5]

A new perceptual color space that claims to be simple to use, while doing a good job at predicting perceived lightness,
chroma and hue. It is called the Oklab color space, because it is an OK Lab color space.

---

As Oklab is not currently supported in the CSS spec, the parsed input and string output formats use the
`#!css-color color()` function format using the custom name `#!css-color --oklab`:

```css-color
color(--oklab l a b / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("oklab", [0, 0, 0], 1)
```

The string representation of the color object and the default string output use the
`#!css-color color(--oklab l a b / a)` form.

```playground
Color("oklab", [0, 0, 0], 1)
Color("oklab", [0, 0, 0], 1).to_string()
```

_[Learn about Oklab](https://bottosson.github.io/posts/oklab/)_
</div>

## Oklch

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `oklch`

    **White Point:** D65

    **Coordinates:**

    Name       | Range
    ---------- | -----
    lightness  | [0, 1]
    chroma     | [0, 1]
    hue        | [0, 360)

Oklch is the cylindrical form of [Oklab](#oklab).

---

As Oklch is not currently supported in the CSS spec, the parsed input and string output formats use the
`#!css-color color()` function format using the custom name `#!css-color --oklch`:

```css-color
color(--oklch l c h / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("oklch", [0, 0, 0], 1)
```

The string representation of the color object and the default string output use the
`#!css-color color(--oklch l c h / a)` form.

```playground
Color("oklch", [0, 0, 0], 1)
Color("oklch", [0, 0, 0], 1).to_string()
```

_[Learn about Oklch](https://bottosson.github.io/posts/oklab/)_
</div>

## Jzazbz

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `jzazbz`

    **White Point:** D65

    **Coordinates:**

    Name | Range
    ---- | -----
    jz   | [0.0, 0.222]^\*^
    az   | [-0.109, 0.13]^\*^
    bz   | [-0.186, 0.135]^\*^

    ^\*^ ≈ range in relation to sRGB rounded to 3 decimal places.

Jzazbz is a a color space designed for perceptual uniformity in high dynamic range (HDR) and wide color gamut (WCG)
applications. Conceptually it is similar to [CIELAB](#cielab), but claims the following improvements:

- Perceptual color difference is predicted by Euclidean distance.
- Perceptually uniform: MacAdam ellipses of just-noticeable-difference (JND) are more circular, and closer to the same
  sizes.
- Hue linearity: changing saturation or lightness has less shift in hue.

---

As Jzazbz is not currently supported in the CSS spec, the parsed input and string output formats use the
`#!css-color color()` function format using the custom name `#!css-color --jzazbz`:

```css-color
color(--jzazbz jz az bz / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("jzazbz", [0, 0, 0], 1)
```

The string representation of the color object and the default string output use the
`#!css-color color(--jzazbz jz az bz / a)` form.

```playground
Color("jzazbz", [0, 0, 0], 1)
Color("jzazbz", [0, 0, 0], 1).to_string()
```

_[Learn about Jzazbz](https://www.osapublishing.org/oe/fulltext.cfm?uri=oe-25-13-15131&id=368272)_
</div>

## JzCzhz

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `jzczhz`

    **White Point:** D65

    **Coordinates:**

    Name   | Range
    ------ | -----
    jz     | [0.0, 0.222]^\*^
    chroma | [0.0, 0.190]^\*^
    hue    | [0.0, 360.0)

    ^\*^ ≈ range in relation to sRGB rounded to 3 decimal places.

JzCzhz is the cylindrical form of [Jzazbz](#jzazbz).

---

As JzCzhz is not currently supported in the CSS spec, the parsed input and string output formats use the
`#!css-color color()` function format using the custom name `#!css-color --jzczhz`:

```css-color
color(--jzczhz jz cz hz / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("jzczhz", [0, 0, 0], 1)
```

The string representation of the color object and the default string output use the
`#!css-color color(--jzczhz jz cz hz / a)` form.

```playground
Color("jzczhz", [0, 0, 0], 1)
Color("jzczhz", [0, 0, 0], 1).to_string()
```

_[Learn about JzCzhz](https://www.osapublishing.org/oe/fulltext.cfm?uri=oe-25-13-15131&id=368272)_
</div>

## ICtCp

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `ictcp`

    **White Point:** D65

    **Coordinates:**

    Name       | Range
    ---------- | -----
    i          | [0.0, 0.581]^\*^
    ct         | [-0.281, 0.277]^\*^
    cp         | [-0.161, 0.279]^\*^

    ^\*^ ≈ range in relation to sRGB rounded to 3 decimal places.

ICtCp is a color space format with better perceptual uniformity than [CIELAB](#cielab) and is used as a part of the
color image pipeline in video and digital photography systems for high dynamic range (HDR) and wide color gamut (WCG)
imagery. It was developed by Dolby Laboratories from the IPT color space by Ebner and Fairchild. It was designed with
the intention to replace YCbCr.

---

As ICtCp is not currently supported in the CSS spec, the parsed input and string output formats use the
`#!css-color color()` function format using the custom name `#!css-color --ictcp`:

```css-color
color(--ictcp i ct cp / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("ictcp", [0, 0, 0], 1)
```

The string representation of the color object and the default string output use the
`#!css-color color(--ictcp i ct cp / a)` form.

```playground
Color("ictcp", [0, 0, 0], 1)
Color("ictcp", [0, 0, 0], 1).to_string()
```

_[Learn about ICtCp](https://en.wikipedia.org/wiki/ICtCp)_
</div>

## DIN99o

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `din99o`

    **White Point:** D65

    **Coordinates:**

    Name       | Range
    ---------- | -----
    lightness  | [0, 100]^\*^
    a          | [-40.09, 45.501]^\*^
    b          | [-40.47, 44.344]^\*^

    ^\*^ ≈ range in relation to sRGB rounded to 3 decimal places.

The DIN99 color space system is a further development of the CIELAB color space system developed by the FNF / FNL 2
Colorimetry Working Committee. It takes the CIELAB space (with a D65 illuminant) and compresses it such that the space
yields better equidistant using Euclidean distance. The whole color space is essentially modified to better fit the
color distancing algorithm opposed to CIELAB which has adapted the color distancing algorithm to better fit the color
space, the latest iteration being ∆E^\*^~00~.

---

As DIN99o is not currently supported in the CSS spec, the parsed input and string output formats use the
`#!css-color color()` function format using the custom name `#!css-color --din99o`:

```css-color
color(--din99o l u v / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("din99o", [0, 0, 0], 1)
```

The string representation of the color object and the default string output use the
`#!css-color color(--din99o l u v / a)` form.

```playground
Color("din99o", [0, 0, 0], 1)
Color("din99o", [0, 0, 0], 1).to_string()
```

_[Learn about DIN99o](https://de.wikipedia.org/wiki/DIN99-Farbraum)_
</div>

## DIN99o Lch

<div class="info-container" markdown="1">
!!! info inline end "Properties"

    **Name:** `din99o-lch`

    **White Point:** D65

    **Coordinates:**

    Name   | Range
    --------- | -----
    lightness | [0, 100]^\*^
    chroma    | [0.0, 51.484]^\*^
    hue       | [0 - 360)

    ^\*^ ≈ range in relation to sRGB rounded to 3 decimal places.

DIN99o Lch is the cylindrical form of [DIN99o](#din99o).

---

As DIN99o Lch is not currently supported in the CSS spec, the parsed input and string output formats use the
`#!css-color color()` function format using the custom name `#!css-color --din99o-lch`:

```css-color
color(--din99o-lch jz cz hz / a)  // Color function
```

When manually creating a color via raw data or specifying a color space as a parameter in a function, the color space
name is always used:

```py
Color("din99o-lch", [0, 0, 0], 1)
```

The string representation of the color object and the default string output use the
`#!css-color color(--din99o-lch jz cz hz / a)` form.

```playground
Color("din99o-lch", [0, 0, 0], 1)
Color("din99o-lch", [0, 0, 0], 1).to_string()
```

_[Learn about DIN99 Lch](https://de.wikipedia.org/wiki/DIN99-Farbraum)_
</div>


<style>
.info-container {display: inline-block;}
</style>
