@design-edito/tools 0.4.4 → 0.4.6

package/agnostic/colors/convert/index.js

@@ -1,46 +1,839 @@
-import {
-  delinearizeToRgb,
-  linearizeToSRgb,
-  toCmyk,
-  toCss,
-  toHex,
-  toHsb,
-  toHsl,
-  toLab,
-  toLch,
-  toRgb,
-  toXyz,
-  viaCmyk,
-  viaHsb,
-  viaHsl,
-  viaLab,
-  viaLch,
-  viaRgb,
-  viaXyz
-} from "../../../chunks/chunk-CVMYA5XK.js";
-import "../../../chunks/chunk-OBSTP7YR.js";
-import "../../../chunks/chunk-HQLRJ7XW.js";
-import "../../../chunks/chunk-DNIOWD7K.js";
-import "../../../chunks/chunk-PUQUSA6S.js";
-import "../../../chunks/chunk-OSAXBA7G.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  delinearizeToRgb,
-  linearizeToSRgb,
-  toCmyk,
-  toCss,
-  toHex,
-  toHsb,
-  toHsl,
-  toLab,
-  toLch,
-  toRgb,
-  toXyz,
-  viaCmyk,
-  viaHsb,
-  viaHsl,
-  viaLab,
-  viaLch,
-  viaRgb,
-  viaXyz
-};
+import { absoluteModulo } from '../../numbers/absolute-modulo/index.js';
+import { tidy } from '../tidy/index.js';
+import { cssColors } from '../cssColorsMap.js';
+import { isHex, isRgb, isHsl, isHsb, isCmyk, isCssColor, isXyz, isLab, isLch } from '../typechecks/index.js';
+import { unknownToString } from '../../errors/unknown-to-string/index.js';
+/* * * * * * * * * * * * * * * * * *
+ * Convertion building blocks
+ * * * * * * * * * * * * * * * * * */
+// RGB ↔ Hex
+// [WIP] maybe use absoluteModulo where needed?
+// needs rewrite, hex char checks, etc
+function _hex2rgb(hex) {
+    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+    if (!isHex(hex))
+        throw new Error(`invalid hex color ${unknownToString(hex)}`);
+    let hexString = hex;
+    const inputHex = hexString;
+    const startsWithHash = hexString.startsWith('#');
+    if (!startsWithHash)
+        throw new Error(`invalid hex color ${inputHex}`);
+    hexString = hexString.slice(1);
+    if (hexString.length === 3) {
+        hexString = hexString.split('').map(c => c + c).join('') + 'ff';
+    }
+    else if (hexString.length === 4) {
+        hexString = hexString.split('').map(c => c + c).join('');
+    }
+    else if (hexString.length === 6) {
+        hexString = hexString + 'ff';
+    }
+    else if (hexString.length !== 8)
+        throw new Error(`invalid hex color ${inputHex}`);
+    const r = parseInt(hexString.slice(0, 2), 16);
+    const g = parseInt(hexString.slice(2, 4), 16);
+    const b = parseInt(hexString.slice(4, 6), 16);
+    const a = parseInt(hexString.slice(6, 8), 16) / 255;
+    return { r, g, b, a };
+}
+function _rgb2hex(rgb) {
+    const { r, g, b, a = 1 } = rgb;
+    const rHex = Math.round(r).toString(16).padStart(2, '0');
+    const gHex = Math.round(g).toString(16).padStart(2, '0');
+    const bHex = Math.round(b).toString(16).padStart(2, '0');
+    const aHex = Math.round(a * 255).toString(16).padStart(2, '0');
+    const returned = `#${rHex}${gHex}${bHex}${aHex}`;
+    if (!isHex(returned)) {
+        // Here typescript says returned is 'never' but this is because
+        // isHex function is more strict than Hex type, so technically
+        // isHex(hex) can return false, for instance if hex === '#zzz'
+        throw new Error(`invalid hex color output ${unknownToString(returned)}`);
+    }
+    return returned;
+}
+function _css2rgb(color) {
+    if (color in cssColors)
+        return cssColors[color];
+    return undefined;
+}
+const cssColorsWithHex = Object.entries(cssColors).map(([cssColor, rgba]) => ({
+    name: cssColor,
+    hex: _rgb2hex(rgba),
+    rgba
+}));
+function _rgb2css(rgb) {
+    const hexTarget = _rgb2hex(rgb);
+    return cssColorsWithHex.find(c => c.hex === hexTarget)?.name;
+}
+// RGB ↔ HSL
+function _hsl2rgb(hsl) {
+    const { h, s, l, a = 1 } = hsl;
+    const H = absoluteModulo(h, 360) / 360;
+    const S = Math.max(0, Math.min(1, s / 100));
+    const L = Math.max(0, Math.min(1, l / 100));
+    const A = Math.max(0, Math.min(1, a));
+    const hue2rgb = (p, q, t) => {
+        if (t < 0)
+            t += 1;
+        if (t > 1)
+            t -= 1;
+        if (t < 1 / 6)
+            return p + (q - p) * 6 * t;
+        if (t < 1 / 2)
+            return q;
+        if (t < 2 / 3)
+            return p + (q - p) * (2 / 3 - t) * 6;
+        return p;
+    };
+    let r;
+    let g;
+    let b;
+    if (S === 0) {
+        r = g = b = L; // achromatic
+    }
+    else {
+        const q = L < 0.5 ? L * (1 + S) : L + S - L * S;
+        const p = 2 * L - q;
+        r = hue2rgb(p, q, H + 1 / 3);
+        g = hue2rgb(p, q, H);
+        b = hue2rgb(p, q, H - 1 / 3);
+    }
+    return {
+        r: Math.round(r * 255),
+        g: Math.round(g * 255),
+        b: Math.round(b * 255),
+        a: A
+    };
+}
+function _rgb2hsl(rgb) {
+    const { r, g, b, a = 1 } = rgb;
+    const R = r / 255;
+    const G = g / 255;
+    const B = b / 255;
+    const max = Math.max(R, G, B);
+    const min = Math.min(R, G, B);
+    const delta = max - min;
+    let h = 0;
+    let s = 0;
+    const l = (max + min) / 2;
+    if (delta !== 0) {
+        s = l > 0.5 ? delta / (2 - max - min) : delta / (max + min);
+        if (max === R) {
+            h = ((G - B) / delta + (G < B ? 6 : 0)) / 6;
+        }
+        else if (max === G) {
+            h = ((B - R) / delta + 2) / 6;
+        }
+        else {
+            h = ((R - G) / delta + 4) / 6;
+        }
+    }
+    return {
+        h: Math.round(h * 360),
+        s: Math.round(s * 100),
+        l: Math.round(l * 100),
+        a
+    };
+}
+// RGB ↔ HSB
+function _hsb2rgb(hsb) {
+    const { h, s, b, a = 1 } = hsb;
+    const H = absoluteModulo(h, 360) / 360;
+    const S = Math.max(0, Math.min(1, s / 100));
+    const B = Math.max(0, Math.min(1, b / 100));
+    const A = Math.max(0, Math.min(1, a));
+    const i = Math.floor(H * 6);
+    const f = H * 6 - i;
+    const p = B * (1 - S);
+    const q = B * (1 - f * S);
+    const t = B * (1 - (1 - f) * S);
+    let r;
+    let g;
+    let blue;
+    switch (absoluteModulo(i, 6)) {
+        case 0:
+            r = B;
+            g = t;
+            blue = p;
+            break;
+        case 1:
+            r = q;
+            g = B;
+            blue = p;
+            break;
+        case 2:
+            r = p;
+            g = B;
+            blue = t;
+            break;
+        case 3:
+            r = p;
+            g = q;
+            blue = B;
+            break;
+        case 4:
+            r = t;
+            g = p;
+            blue = B;
+            break;
+        case 5:
+            r = B;
+            g = p;
+            blue = q;
+            break;
+        default: r = g = blue = 0;
+    }
+    return {
+        r: Math.round(r * 255),
+        g: Math.round(g * 255),
+        b: Math.round(blue * 255),
+        a: A
+    };
+}
+function _rgb2hsb(rgb) {
+    const { r, g, b, a = 1 } = rgb;
+    const R = r / 255;
+    const G = g / 255;
+    const B = b / 255;
+    const max = Math.max(R, G, B);
+    const min = Math.min(R, G, B);
+    const delta = max - min;
+    let h = 0;
+    let s = 0;
+    const brightness = max;
+    if (max !== 0) {
+        s = delta / max;
+    }
+    if (delta !== 0) {
+        if (max === R) {
+            h = ((G - B) / delta + (G < B ? 6 : 0)) / 6;
+        }
+        else if (max === G) {
+            h = ((B - R) / delta + 2) / 6;
+        }
+        else {
+            h = ((R - G) / delta + 4) / 6;
+        }
+    }
+    return {
+        h: Math.round(h * 360),
+        s: Math.round(s * 100),
+        b: Math.round(brightness * 100),
+        a
+    };
+}
+// RGB ↔ CMYK
+function _cmyk2rgb(cmyka) {
+    const { c, m, y, k, a = 1 } = cmyka;
+    // Clamp input to 0–100
+    const C = Math.max(0, Math.min(100, c)) / 100;
+    const M = Math.max(0, Math.min(100, m)) / 100;
+    const Y = Math.max(0, Math.min(100, y)) / 100;
+    const K = Math.max(0, Math.min(100, k)) / 100;
+    const A = Math.max(0, Math.min(1, a));
+    // CMYK → RGB formula
+    const R = 1 - Math.min(1, C * (1 - K) + K);
+    const G = 1 - Math.min(1, M * (1 - K) + K);
+    const B = 1 - Math.min(1, Y * (1 - K) + K);
+    return {
+        r: Math.round(R * 255),
+        g: Math.round(G * 255),
+        b: Math.round(B * 255),
+        a: A
+    };
+}
+function _rgb2cmyk(rgb) {
+    const { r, g, b, a = 1 } = rgb;
+    // Normalize RGB to 0–1
+    const R = Math.max(0, Math.min(1, r / 255));
+    const G = Math.max(0, Math.min(1, g / 255));
+    const B = Math.max(0, Math.min(1, b / 255));
+    const A = Math.max(0, Math.min(1, a));
+    // Compute K (black)
+    const K = 1 - Math.max(R, G, B);
+    // Avoid division by zero
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    const denom = 1 - K || 1;
+    // Compute C, M, Y
+    const C = (1 - R - K) / denom;
+    const M = (1 - G - K) / denom;
+    const Y = (1 - B - K) / denom;
+    return {
+        c: Math.round(C * 100),
+        m: Math.round(M * 100),
+        y: Math.round(Y * 100),
+        k: Math.round(K * 100),
+        a: A
+    };
+}
+// Rgb ↔ XYZ
+function _xyz2rgb(xyza) {
+    const { x, y, z, a = 1 } = xyza;
+    // Normalize XYZ to 0–1
+    const X = x / 100;
+    const Y = y / 100;
+    const Z = z / 100;
+    const A = Math.max(0, Math.min(1, a));
+    // XYZ → linear RGB (D65)
+    let R = X * 3.2404542 + Y * -1.5371385 + Z * -0.4985314;
+    let G = X * -0.9692660 + Y * 1.8760108 + Z * 0.0415560;
+    let B = X * 0.0556434 + Y * -0.2040259 + Z * 1.0572252;
+    // Apply gamma correction
+    const GAMMA_THRESHOLD = 0.0031308;
+    const GAMMA_EXPONENT = 1 / 2.4;
+    const GAMMA_MULT = 1.055;
+    const GAMMA_OFFSET = 0.055;
+    const LINEAR_DIVISOR = 12.92;
+    const gammaCorrect = (c) => c <= GAMMA_THRESHOLD
+        ? c * LINEAR_DIVISOR
+        : GAMMA_MULT * Math.pow(c, GAMMA_EXPONENT) - GAMMA_OFFSET;
+    R = gammaCorrect(R);
+    G = gammaCorrect(G);
+    B = gammaCorrect(B);
+    return {
+        r: Math.round(Math.max(0, Math.min(1, R)) * 255),
+        g: Math.round(Math.max(0, Math.min(1, G)) * 255),
+        b: Math.round(Math.max(0, Math.min(1, B)) * 255),
+        a: A
+    };
+}
+function _rgb2xyz(rgb) {
+    const { r, g, b, a = 1 } = rgb;
+    // Normalize RGB to 0–1
+    let R = Math.max(0, Math.min(1, r / 255));
+    let G = Math.max(0, Math.min(1, g / 255));
+    let B = Math.max(0, Math.min(1, b / 255));
+    const A = Math.max(0, Math.min(1, a));
+    // Apply inverse gamma correction (sRGB → linear)
+    const SRGB_THRESHOLD = 0.04045;
+    const SRGB_OFFSET = 0.055;
+    const SRGB_DIVISOR = 1.055;
+    const SRGB_EXPONENT = 2.4;
+    const SRGB_LINEAR_DIVISOR = 12.92;
+    const linearize = (c) => c > SRGB_THRESHOLD
+        ? Math.pow((c + SRGB_OFFSET) / SRGB_DIVISOR, SRGB_EXPONENT)
+        : c / SRGB_LINEAR_DIVISOR;
+    R = linearize(R);
+    G = linearize(G);
+    B = linearize(B);
+    // Linear RGB → XYZ (D65)
+    const X = R * 0.4124564 + G * 0.3575761 + B * 0.1804375;
+    const Y = R * 0.2126729 + G * 0.7151522 + B * 0.0721750;
+    const Z = R * 0.0193339 + G * 0.1191920 + B * 0.9503041;
+    return {
+        x: X * 100,
+        y: Y * 100,
+        z: Z * 100,
+        a: A
+    };
+}
+// XYZ ↔ LAB
+function _lab2xyz(lab) {
+    const { l, a: A = 0, b: B = 0, al: alpha = 1 } = lab;
+    // D65 reference white
+    const REF_X = 95.047;
+    const REF_Y = 100.0;
+    const REF_Z = 108.883;
+    const fy = (l + 16) / 116;
+    const fx = fy + A / 500;
+    const fz = fy - B / 200;
+    const fx3 = Math.pow(fx, 3);
+    const fz3 = Math.pow(fz, 3);
+    const fy3 = Math.pow(fy, 3);
+    const epsilon = 0.008856; // CIE standard
+    const kappa = 903.3; // CIE standard
+    const X = fx3 > epsilon ? fx3 : (116 * fx - 16) / kappa;
+    const Y = l > (kappa * epsilon) ? fy3 : l / kappa;
+    const Z = fz3 > epsilon ? fz3 : (116 * fz - 16) / kappa;
+    return {
+        x: X * REF_X,
+        y: Y * REF_Y,
+        z: Z * REF_Z,
+        a: Math.max(0, Math.min(1, alpha))
+    };
+}
+function _xyz2lab(xyza) {
+    const { x, y, z, a: alpha = 1 } = xyza;
+    // D65 reference white
+    const REF_X = 95.047;
+    const REF_Y = 100.0;
+    const REF_Z = 108.883;
+    const X = x / REF_X;
+    const Y = y / REF_Y;
+    const Z = z / REF_Z;
+    const epsilon = 0.008856; // CIE standard
+    const kappa = 903.3; // CIE standard
+    const fx = X > epsilon ? Math.cbrt(X) : (kappa * X + 16) / 116;
+    const fy = Y > epsilon ? Math.cbrt(Y) : (kappa * Y + 16) / 116;
+    const fz = Z > epsilon ? Math.cbrt(Z) : (kappa * Z + 16) / 116;
+    const L = 116 * fy - 16;
+    const A = 500 * (fx - fy);
+    const B = 200 * (fy - fz);
+    return {
+        l: L,
+        a: A,
+        b: B,
+        al: Math.max(0, Math.min(1, alpha))
+    };
+}
+// LAB ↔ LCH
+function _lab2lch(lab) {
+    const { l, a, b, al = 1 } = lab;
+    const c = Math.sqrt(a * a + b * b);
+    let h = Math.atan2(b, a) * (180 / Math.PI); // convert to degrees
+    if (h < 0)
+        h += 360;
+    return { l, c, h, a: al };
+}
+function _lch2lab(lch) {
+    const { l, c, h, a = 1 } = lch;
+    const hRad = (h * Math.PI) / 180;
+    const A = c * Math.cos(hRad);
+    const B = c * Math.sin(hRad);
+    return { l, a: A, b: B, al: a };
+}
+/* * * * * * * * * * * * * * * * * *
+ * Converters
+ * * * * * * * * * * * * * * * * * */
+/**
+ * Converts any supported color format to RGBA.
+ *
+ * @param {Color} color - The color to convert.
+ * @returns {Rgba} The color in RGBA format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
+export function toRgb(color) {
+    if (isRgb(color))
+        return color;
+    if (isHsl(color))
+        return _hsl2rgb(color);
+    if (isHsb(color))
+        return _hsb2rgb(color);
+    if (isCmyk(color))
+        return _cmyk2rgb(color);
+    if (isCssColor(color))
+        return _css2rgb(color);
+    if (isHex(color))
+        return _hex2rgb(color);
+    if (isXyz(color))
+        return _xyz2rgb(color);
+    if (isLab(color))
+        return _xyz2rgb(_lab2xyz(color));
+    if (isLch(color))
+        return _xyz2rgb(_lab2xyz(_lch2lab(color)));
+    throw new Error(`Invalid color input: ${unknownToString(color)}`);
+}
+/**
+ * Converts any supported color format to CIE XYZ.
+ *
+ * @param {Color} color - The color to convert.
+ * @returns {Xyza} The color in CIE XYZ format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
+export function toXyz(color) {
+    if (isXyz(color))
+        return color;
+    if (isLab(color))
+        return _lab2xyz(color);
+    if (isLch(color))
+        return _lab2xyz(_lch2lab(color));
+    if (isRgb(color))
+        return _rgb2xyz(color);
+    if (isHsl(color))
+        return _rgb2xyz(_hsl2rgb(color));
+    if (isHsb(color))
+        return _rgb2xyz(_hsb2rgb(color));
+    if (isCmyk(color))
+        return _rgb2xyz(_cmyk2rgb(color));
+    if (isCssColor(color))
+        return _rgb2xyz(_css2rgb(color));
+    if (isHex(color))
+        return _rgb2xyz(_hex2rgb(color));
+    throw new Error(`Invalid color input: ${unknownToString(color)}`);
+}
+/**
+ * Converts any supported color format to CIELAB.
+ *
+ * @param {Color} color - The color to convert.
+ * @returns {Laba} The color in CIELAB format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
+export function toLab(color) {
+    if (isLab(color))
+        return color;
+    if (isLch(color))
+        return _lch2lab(color);
+    const xyzColor = toXyz(color);
+    return _xyz2lab(xyzColor);
+}
+/**
+ * Converts any supported color format to CIELCh.
+ *
+ * @param {Color} color - The color to convert.
+ * @returns {Lcha} The color in CIELCh format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
+export function toLch(color) {
+    if (isLch(color))
+        return color;
+    const labColor = toLab(color);
+    return _lab2lch(labColor);
+}
+/**
+ * Converts any supported color format to HSLA.
+ *
+ * @param {Color} color - The color to convert.
+ * @returns {Hsla} The color in HSLA format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
+export function toHsl(color) {
+    if (isHsl(color))
+        return color;
+    const rgbColor = toRgb(color);
+    return _rgb2hsl(rgbColor);
+}
+/**
+ * Converts any supported color format to HSBA (HSB/HSV).
+ *
+ * @param {Color} color - The color to convert.
+ * @returns {Hsba} The color in HSBA format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
+export function toHsb(color) {
+    if (isHsb(color))
+        return color;
+    const rgbColor = toRgb(color);
+    return _rgb2hsb(rgbColor);
+}
+/**
+ * Converts any supported color format to CMYK.
+ *
+ * @param {Color} color - The color to convert.
+ * @returns {Cmyka} The color in CMYK format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
+export function toCmyk(color) {
+    if (isCmyk(color))
+        return color;
+    const rgbColor = toRgb(color);
+    return _rgb2cmyk(rgbColor);
+}
+export function toCss(color) {
+    if (isCssColor(color))
+        return color;
+    const rgbColor = toRgb(color);
+    return _rgb2css(rgbColor);
+}
+/**
+ * Converts any supported color format to hexadecimal.
+ *
+ * @param {Color} color - The color to convert.
+ * @returns {Hex} The color in hexadecimal format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
+export function toHex(color) {
+    if (isHex(color))
+        return color;
+    const rgbColor = toRgb(color);
+    return _rgb2hex(rgbColor);
+}
+/* * * * * * * * * * * * * * * * * *
+ * Transformers
+ * * * * * * * * * * * * * * * * * */
+/**
+ * Transforms a color by converting it to RGBA, applying a transformation function,
+ * then converting back to the original color format.
+ *
+ * @template C - The input color type.
+ * @param {C} color - The color to transform.
+ * @param {(rgb: Rgba) => Rgba} transformer - Function that transforms the RGBA representation.
+ * @returns {TransformedColor<C>} The transformed color in the original format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
+export function viaRgb(color, transformer) {
+    const _color = color;
+    const rgb = toRgb(_color);
+    const transformedRgb = transformer(rgb);
+    if (isRgb(_color))
+        return transformedRgb;
+    if (isHsl(_color))
+        return toHsl(transformedRgb);
+    if (isHsb(_color))
+        return toHsb(transformedRgb);
+    if (isCmyk(_color))
+        return toCmyk(transformedRgb);
+    if (isXyz(_color))
+        return toXyz(transformedRgb);
+    if (isLab(_color))
+        return toLab(transformedRgb);
+    if (isLch(_color))
+        return toLch(transformedRgb);
+    if (isHex(_color))
+        return toRgb(transformedRgb);
+    if (isCssColor(_color))
+        return transformedRgb;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const _typecheck = true;
+    throw new Error(`Invalid color input: ${unknownToString(_color)}`);
+}
+/**
+ * Transforms a color by converting it to HSLA, applying a transformation function,
+ * then converting back to the original color format.
+ *
+ * @template C - The input color type.
+ * @param {C} color - The color to transform.
+ * @param {(hsl: Hsla) => Hsla} transformer - Function that transforms the HSLA representation.
+ * @returns {TransformedColor<C>} The transformed color in the original format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
+export function viaHsl(color, transformer) {
+    const _color = color;
+    const hsl = toHsl(_color);
+    const transformedHsl = transformer(hsl);
+    if (isHsl(_color))
+        return transformedHsl;
+    if (isRgb(_color))
+        return toRgb(transformedHsl);
+    if (isHsb(_color))
+        return toHsb(transformedHsl);
+    if (isCmyk(_color))
+        return toCmyk(transformedHsl);
+    if (isXyz(_color))
+        return toXyz(transformedHsl);
+    if (isLab(_color))
+        return toLab(transformedHsl);
+    if (isLch(_color))
+        return toLch(transformedHsl);
+    if (isHex(_color))
+        return toHex(transformedHsl);
+    if (isCssColor(_color))
+        return transformedHsl;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const _typecheck = true;
+    throw new Error(`Invalid color input: ${unknownToString(_color)}`);
+}
+/**
+ * Transforms a color by converting it to HSBA, applying a transformation function,
+ * then converting back to the original color format.
+ *
+ * @template C - The input color type.
+ * @param {C} color - The color to transform.
+ * @param {(hsb: Hsba) => Hsba} transformer - Function that transforms the HSBA representation.
+ * @returns {TransformedColor<C>} The transformed color in the original format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
+export function viaHsb(color, transformer) {
+    const _color = color;
+    const hsb = toHsb(_color);
+    const transformedHsb = transformer(hsb);
+    if (isHsb(_color))
+        return transformedHsb;
+    if (isRgb(_color))
+        return toRgb(transformedHsb);
+    if (isHsl(_color))
+        return toHsl(transformedHsb);
+    if (isCmyk(_color))
+        return toCmyk(transformedHsb);
+    if (isXyz(_color))
+        return toXyz(transformedHsb);
+    if (isLab(_color))
+        return toLab(transformedHsb);
+    if (isLch(_color))
+        return toLch(transformedHsb);
+    if (isHex(_color))
+        return toHex(transformedHsb);
+    if (isCssColor(_color))
+        return transformedHsb;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const _typecheck = true;
+    throw new Error(`Invalid color input: ${unknownToString(_color)}`);
+}
+/**
+ * Transforms a color by converting it to CMYK, applying a transformation function,
+ * then converting back to the original color format.
+ *
+ * @template C - The input color type.
+ * @param {C} color - The color to transform.
+ * @param {(cmyk: Cmyka) => Cmyka} transformer - Function that transforms the CMYK representation.
+ * @returns {TransformedColor<C>} The transformed color in the original format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
+export function viaCmyk(color, transformer) {
+    const _color = color;
+    const cmyk = toCmyk(_color);
+    const transformedCmyk = transformer(cmyk);
+    if (isHsb(_color))
+        return transformedCmyk;
+    if (isRgb(_color))
+        return toRgb(transformedCmyk);
+    if (isHsl(_color))
+        return toHsl(transformedCmyk);
+    if (isCmyk(_color))
+        return toCmyk(transformedCmyk);
+    if (isXyz(_color))
+        return toXyz(transformedCmyk);
+    if (isLab(_color))
+        return toLab(transformedCmyk);
+    if (isLch(_color))
+        return toLch(transformedCmyk);
+    if (isHex(_color))
+        return toHex(transformedCmyk);
+    if (isCssColor(_color))
+        return transformedCmyk;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const _typecheck = true;
+    throw new Error(`Invalid color input: ${unknownToString(_color)}`);
+}
+/**
+ * Transforms a color by converting it to CIE XYZ, applying a transformation function,
+ * then converting back to the original color format.
+ *
+ * @template C - The input color type.
+ * @param {C} color - The color to transform.
+ * @param {(xyz: Xyza) => Xyza} transformer - Function that transforms the XYZ representation.
+ * @returns {TransformedColor<C>} The transformed color in the original format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
+export function viaXyz(color, transformer) {
+    const _color = color;
+    const xyz = toXyz(_color);
+    const transformedXyz = transformer(xyz);
+    if (isHsb(_color))
+        return transformedXyz;
+    if (isRgb(_color))
+        return toRgb(transformedXyz);
+    if (isHsl(_color))
+        return toHsl(transformedXyz);
+    if (isCmyk(_color))
+        return toCmyk(transformedXyz);
+    if (isXyz(_color))
+        return toXyz(transformedXyz);
+    if (isLab(_color))
+        return toLab(transformedXyz);
+    if (isLch(_color))
+        return toLch(transformedXyz);
+    if (isHex(_color))
+        return toHex(transformedXyz);
+    if (isCssColor(_color))
+        return transformedXyz;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const _typecheck = true;
+    throw new Error(`Invalid color input: ${unknownToString(_color)}`);
+}
+/**
+ * Transforms a color by converting it to CIELAB, applying a transformation function,
+ * then converting back to the original color format.
+ *
+ * @template C - The input color type.
+ * @param {C} color - The color to transform.
+ * @param {(lab: Laba) => Laba} transformer - Function that transforms the CIELAB representation.
+ * @returns {TransformedColor<C>} The transformed color in the original format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
+export function viaLab(color, transformer) {
+    const _color = color;
+    const lab = toLab(_color);
+    const transformedLab = transformer(lab);
+    if (isHsb(_color))
+        return transformedLab;
+    if (isRgb(_color))
+        return toRgb(transformedLab);
+    if (isHsl(_color))
+        return toHsl(transformedLab);
+    if (isCmyk(_color))
+        return toCmyk(transformedLab);
+    if (isXyz(_color))
+        return toXyz(transformedLab);
+    if (isLab(_color))
+        return toLab(transformedLab);
+    if (isLch(_color))
+        return toLch(transformedLab);
+    if (isHex(_color))
+        return toHex(transformedLab);
+    if (isCssColor(_color))
+        return transformedLab;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const _typecheck = true;
+    throw new Error(`Invalid color input: ${unknownToString(_color)}`);
+}
+/**
+ * Transforms a color by converting it to CIELCh, applying a transformation function,
+ * then converting back to the original color format.
+ *
+ * @template C - The input color type.
+ * @param {C} color - The color to transform.
+ * @param {(lch: Lcha) => Lcha} transformer - Function that transforms the CIELCh representation.
+ * @returns {TransformedColor<C>} The transformed color in the original format.
+ * @throws {Error} If the color format is invalid or unsupported.
+ */
+export function viaLch(color, transformer) {
+    const _color = color;
+    const lch = toLch(_color);
+    const transformedLch = transformer(lch);
+    if (isHsb(_color))
+        return transformedLch;
+    if (isRgb(_color))
+        return toRgb(transformedLch);
+    if (isHsl(_color))
+        return toHsl(transformedLch);
+    if (isCmyk(_color))
+        return toCmyk(transformedLch);
+    if (isXyz(_color))
+        return toXyz(transformedLch);
+    if (isLab(_color))
+        return toLab(transformedLch);
+    if (isLch(_color))
+        return toLch(transformedLch);
+    if (isHex(_color))
+        return toHex(transformedLch);
+    if (isCssColor(_color))
+        return transformedLch;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const _typecheck = true;
+    throw new Error(`Invalid color input: ${unknownToString(_color)}`);
+}
+/* * * * * * * * * * * * * * * * * *
+ * sRGB linearization / delinearization
+ * * * * * * * * * * * * * * * * * */
+/**
+ * Converts an RGBA color to linear sRGB color space by applying inverse gamma correction.
+ *
+ * @param {Rgba} rgb - The RGBA color to linearize.
+ * @returns {Srgba} The linearized color in sRGB color space.
+ */
+export function linearizeToSRgb(rgb) {
+    const cleanRgb = tidy(rgb);
+    const linearChannel = (v) => {
+        const n = v / 255;
+        if (n <= 0.04045)
+            return n / 12.92;
+        else
+            return Math.pow((n + 0.055) / 1.055, 2.4);
+    };
+    return {
+        linearR: linearChannel(cleanRgb.r),
+        linearG: linearChannel(cleanRgb.g),
+        linearB: linearChannel(cleanRgb.b),
+        a: cleanRgb.a
+    };
+}
+/**
+ * Converts a linear sRGB color to RGBA by applying gamma correction.
+ *
+ * @param {Srgba} srgb - The linear sRGB color to delinearize.
+ * @returns {Rgba} The delinearized color in RGBA format.
+ */
+export function delinearizeToRgb(srgb) {
+    const gammaChannel = (v) => {
+        if (v <= 0.0031308)
+            return v * 12.92;
+        else
+            return 1.055 * Math.pow(v, 1 / 2.4) - 0.055;
+    };
+    return tidy({
+        r: gammaChannel(srgb.linearR) * 255,
+        g: gammaChannel(srgb.linearG) * 255,
+        b: gammaChannel(srgb.linearB) * 255,
+        a: srgb.a
+    });
+}