@fluixi/utils 1.0.0-alpha.53

package/dist/lib/color/conversions.js

@@ -0,0 +1,766 @@
+/**
+ * @fileoverview Comprehensive color conversion utilities
+ * Supports conversions between: RGB, HSL, HSV, HWB, CMYK, LAB, LCH, OKLAB, OKLCH, XYZ
+ */
+/**
+ * Constants for color conversions
+ */
+const D65_WHITE = { x: 0.95047, y: 1.0, z: 1.08883 };
+const EPSILON = 0.008856;
+const KAPPA = 903.3;
+/**
+ * Utility function to clamp values
+ */
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+/**
+ * Round to specified precision
+ */
+function roundToPrecision(value, precision = 2) {
+    const multiplier = Math.pow(10, precision);
+    return Math.round(value * multiplier) / multiplier;
+}
+// ============================================================================
+// RGB CONVERSIONS
+// ============================================================================
+/**
+ * Convert RGB to HSL
+ */
+export function rgbToHsl(rgb) {
+    const r = rgb.r / 255;
+    const g = rgb.g / 255;
+    const b = rgb.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);
+        switch (max) {
+            case r:
+                h = ((g - b) / delta + (g < b ? 6 : 0)) / 6;
+                break;
+            case g:
+                h = ((b - r) / delta + 2) / 6;
+                break;
+            case b:
+                h = ((r - g) / delta + 4) / 6;
+                break;
+        }
+    }
+    return {
+        h: h * 360,
+        s: s * 100,
+        l: l * 100,
+        a: rgb.a,
+    };
+}
+/**
+ * Convert RGB to HSV
+ */
+export function rgbToHsv(rgb) {
+    const r = rgb.r / 255;
+    const g = rgb.g / 255;
+    const b = rgb.b / 255;
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    const delta = max - min;
+    let h = 0;
+    const s = max === 0 ? 0 : delta / max;
+    const v = max;
+    if (delta !== 0) {
+        switch (max) {
+            case r:
+                h = ((g - b) / delta + (g < b ? 6 : 0)) / 6;
+                break;
+            case g:
+                h = ((b - r) / delta + 2) / 6;
+                break;
+            case b:
+                h = ((r - g) / delta + 4) / 6;
+                break;
+        }
+    }
+    return {
+        h: h * 360,
+        s: s * 100,
+        v: v * 100,
+        a: rgb.a,
+    };
+}
+/**
+ * Convert RGB to HWB
+ */
+export function rgbToHwb(rgb) {
+    const hsv = rgbToHsv(rgb);
+    const w = ((100 - hsv.s) * hsv.v) / 100;
+    const b = 100 - hsv.v;
+    return {
+        h: hsv.h,
+        w,
+        b,
+        a: rgb.a,
+    };
+}
+/**
+ * Convert RGB to CMYK
+ */
+export function rgbToCmyk(rgb) {
+    const r = rgb.r / 255;
+    const g = rgb.g / 255;
+    const b = rgb.b / 255;
+    const k = 1 - Math.max(r, g, b);
+    const c = k === 1 ? 0 : (1 - r - k) / (1 - k);
+    const m = k === 1 ? 0 : (1 - g - k) / (1 - k);
+    const y = k === 1 ? 0 : (1 - b - k) / (1 - k);
+    return {
+        c: c * 100,
+        m: m * 100,
+        y: y * 100,
+        k: k * 100,
+        a: rgb.a,
+    };
+}
+/**
+ * Convert RGB to XYZ
+ */
+export function rgbToXyz(rgb) {
+    let r = rgb.r / 255;
+    let g = rgb.g / 255;
+    let b = rgb.b / 255;
+    // Apply gamma correction
+    r = r > 0.04045 ? Math.pow((r + 0.055) / 1.055, 2.4) : r / 12.92;
+    g = g > 0.04045 ? Math.pow((g + 0.055) / 1.055, 2.4) : g / 12.92;
+    b = b > 0.04045 ? Math.pow((b + 0.055) / 1.055, 2.4) : b / 12.92;
+    // Convert to XYZ using sRGB matrix
+    const x = r * 0.4124564 + g * 0.3575761 + b * 0.1804375;
+    const y = r * 0.2126729 + g * 0.7151522 + b * 0.072175;
+    const z = r * 0.0193339 + g * 0.119192 + b * 0.9503041;
+    return {
+        x: x * 100,
+        y: y * 100,
+        z: z * 100,
+        alpha: rgb.a,
+    };
+}
+/**
+ * Convert RGB to LAB
+ */
+export function rgbToLab(rgb) {
+    const xyz = rgbToXyz(rgb);
+    return xyzToLab(xyz);
+}
+/**
+ * Convert RGB to LCH
+ */
+export function rgbToLch(rgb) {
+    const lab = rgbToLab(rgb);
+    return labToLch(lab);
+}
+/**
+ * Convert RGB to OKLAB
+ */
+export function rgbToOklab(rgb) {
+    const r = rgb.r / 255;
+    const g = rgb.g / 255;
+    const b = rgb.b / 255;
+    // Linear RGB
+    const lr = r > 0.04045 ? Math.pow((r + 0.055) / 1.055, 2.4) : r / 12.92;
+    const lg = g > 0.04045 ? Math.pow((g + 0.055) / 1.055, 2.4) : g / 12.92;
+    const lb = b > 0.04045 ? Math.pow((b + 0.055) / 1.055, 2.4) : b / 12.92;
+    // Convert to LMS cone space
+    const l = 0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb;
+    const m = 0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb;
+    const s = 0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb;
+    const l_ = Math.cbrt(l);
+    const m_ = Math.cbrt(m);
+    const s_ = Math.cbrt(s);
+    return {
+        l: 0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_,
+        a: 1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_,
+        b: 0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_,
+        alpha: rgb.a,
+    };
+}
+/**
+ * Convert RGB to OKLCH
+ */
+export function rgbToOklch(rgb) {
+    const oklab = rgbToOklab(rgb);
+    return oklabToOklch(oklab);
+}
+// ============================================================================
+// HSL CONVERSIONS
+// ============================================================================
+/**
+ * Convert HSL to RGB
+ */
+export function hslToRgb(hsl) {
+    const h = hsl.h / 360;
+    const s = hsl.s / 100;
+    const l = hsl.l / 100;
+    let r, g, b;
+    if (s === 0) {
+        r = g = b = l;
+    }
+    else {
+        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;
+        };
+        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: hsl.a,
+    };
+}
+/**
+ * Convert HSL to HSV
+ */
+export function hslToHsv(hsl) {
+    const rgb = hslToRgb(hsl);
+    return rgbToHsv(rgb);
+}
+/**
+ * Convert HSL to HWB
+ */
+export function hslToHwb(hsl) {
+    const rgb = hslToRgb(hsl);
+    return rgbToHwb(rgb);
+}
+// ============================================================================
+// HSV CONVERSIONS
+// ============================================================================
+/**
+ * Convert HSV to RGB
+ */
+export function hsvToRgb(hsv) {
+    const h = hsv.h / 360;
+    const s = hsv.s / 100;
+    const v = hsv.v / 100;
+    const i = Math.floor(h * 6);
+    const f = h * 6 - i;
+    const p = v * (1 - s);
+    const q = v * (1 - f * s);
+    const t = v * (1 - (1 - f) * s);
+    let r, g, b;
+    switch (i % 6) {
+        case 0:
+            r = v;
+            g = t;
+            b = p;
+            break;
+        case 1:
+            r = q;
+            g = v;
+            b = p;
+            break;
+        case 2:
+            r = p;
+            g = v;
+            b = t;
+            break;
+        case 3:
+            r = p;
+            g = q;
+            b = v;
+            break;
+        case 4:
+            r = t;
+            g = p;
+            b = v;
+            break;
+        case 5:
+        default:
+            r = v;
+            g = p;
+            b = q;
+            break;
+    }
+    return {
+        r: Math.round(r * 255),
+        g: Math.round(g * 255),
+        b: Math.round(b * 255),
+        a: hsv.a,
+    };
+}
+/**
+ * Convert HSV to HSL
+ */
+export function hsvToHsl(hsv) {
+    const rgb = hsvToRgb(hsv);
+    return rgbToHsl(rgb);
+}
+/**
+ * Convert HSV to HWB
+ */
+export function hsvToHwb(hsv) {
+    const w = ((100 - hsv.s) * hsv.v) / 100;
+    const b = 100 - hsv.v;
+    return {
+        h: hsv.h,
+        w,
+        b,
+        a: hsv.a,
+    };
+}
+// ============================================================================
+// HWB CONVERSIONS
+// ============================================================================
+/**
+ * Convert HWB to RGB
+ */
+export function hwbToRgb(hwb) {
+    const h = hwb.h;
+    let w = hwb.w / 100;
+    let b = hwb.b / 100;
+    const sum = w + b;
+    if (sum > 1) {
+        w /= sum;
+        b /= sum;
+    }
+    const v = 1 - b;
+    const s = v === 0 ? 0 : 1 - w / v;
+    return hsvToRgb({ h, s: s * 100, v: v * 100, a: hwb.a });
+}
+/**
+ * Convert HWB to HSL
+ */
+export function hwbToHsl(hwb) {
+    const rgb = hwbToRgb(hwb);
+    return rgbToHsl(rgb);
+}
+/**
+ * Convert HWB to HSV
+ */
+export function hwbToHsv(hwb) {
+    const rgb = hwbToRgb(hwb);
+    return rgbToHsv(rgb);
+}
+// ============================================================================
+// CMYK CONVERSIONS
+// ============================================================================
+/**
+ * Convert CMYK to RGB
+ */
+export function cmykToRgb(cmyk) {
+    const c = cmyk.c / 100;
+    const m = cmyk.m / 100;
+    const y = cmyk.y / 100;
+    const k = cmyk.k / 100;
+    const r = 255 * (1 - c) * (1 - k);
+    const g = 255 * (1 - m) * (1 - k);
+    const b = 255 * (1 - y) * (1 - k);
+    return {
+        r: Math.round(r),
+        g: Math.round(g),
+        b: Math.round(b),
+        a: cmyk.a,
+    };
+}
+/**
+ * Convert CMYK to HSL
+ */
+export function cmykToHsl(cmyk) {
+    const rgb = cmykToRgb(cmyk);
+    return rgbToHsl(rgb);
+}
+/**
+ * Convert CMYK to HSV
+ */
+export function cmykToHsv(cmyk) {
+    const rgb = cmykToRgb(cmyk);
+    return rgbToHsv(rgb);
+}
+// ============================================================================
+// XYZ CONVERSIONS
+// ============================================================================
+/**
+ * Convert XYZ to RGB
+ */
+export function xyzToRgb(xyz) {
+    const x = xyz.x / 100;
+    const y = xyz.y / 100;
+    const z = xyz.z / 100;
+    // Convert XYZ to linear RGB using sRGB matrix
+    let r = x * 3.2404542 + y * -1.5371385 + z * -0.4985314;
+    let g = x * -0.969266 + y * 1.8760108 + z * 0.041556;
+    let b = x * 0.0556434 + y * -0.2040259 + z * 1.0572252;
+    // Apply gamma correction
+    r = r > 0.0031308 ? 1.055 * Math.pow(r, 1 / 2.4) - 0.055 : 12.92 * r;
+    g = g > 0.0031308 ? 1.055 * Math.pow(g, 1 / 2.4) - 0.055 : 12.92 * g;
+    b = b > 0.0031308 ? 1.055 * Math.pow(b, 1 / 2.4) - 0.055 : 12.92 * b;
+    return {
+        r: Math.round(clamp(r * 255, 0, 255)),
+        g: Math.round(clamp(g * 255, 0, 255)),
+        b: Math.round(clamp(b * 255, 0, 255)),
+        a: xyz.alpha || 1,
+    };
+}
+/**
+ * Convert XYZ to LAB
+ */
+export function xyzToLab(xyz) {
+    const xr = xyz.x / D65_WHITE.x / 100;
+    const yr = xyz.y / D65_WHITE.y / 100;
+    const zr = xyz.z / D65_WHITE.z / 100;
+    const fx = xr > EPSILON ? Math.cbrt(xr) : (KAPPA * xr + 16) / 116;
+    const fy = yr > EPSILON ? Math.cbrt(yr) : (KAPPA * yr + 16) / 116;
+    const fz = zr > EPSILON ? Math.cbrt(zr) : (KAPPA * zr + 16) / 116;
+    const l = 116 * fy - 16;
+    const a = 500 * (fx - fy);
+    const b = 200 * (fy - fz);
+    return {
+        l: clamp(l, 0, 100),
+        a,
+        b,
+        alpha: xyz.alpha,
+    };
+}
+// ============================================================================
+// LAB CONVERSIONS
+// ============================================================================
+/**
+ * Convert LAB to XYZ
+ */
+export function labToXyz(lab) {
+    const fy = (lab.l + 16) / 116;
+    const fx = lab.a / 500 + fy;
+    const fz = fy - lab.b / 200;
+    const xr = fx * fx * fx > EPSILON ? fx * fx * fx : (116 * fx - 16) / KAPPA;
+    const yr = lab.l > KAPPA * EPSILON ? Math.pow((lab.l + 16) / 116, 3) : lab.l / KAPPA;
+    const zr = fz * fz * fz > EPSILON ? fz * fz * fz : (116 * fz - 16) / KAPPA;
+    return {
+        x: xr * D65_WHITE.x * 100,
+        y: yr * D65_WHITE.y * 100,
+        z: zr * D65_WHITE.z * 100,
+        alpha: lab.alpha,
+    };
+}
+/**
+ * Convert LAB to RGB
+ */
+export function labToRgb(lab) {
+    const xyz = labToXyz(lab);
+    return xyzToRgb(xyz);
+}
+/**
+ * Convert LAB to LCH
+ */
+export function labToLch(lab) {
+    const c = Math.sqrt(lab.a * lab.a + lab.b * lab.b);
+    let h = (Math.atan2(lab.b, lab.a) * 180) / Math.PI;
+    if (h < 0) {
+        h += 360;
+    }
+    return {
+        l: lab.l,
+        c,
+        h,
+        alpha: lab.alpha,
+    };
+}
+// ============================================================================
+// LCH CONVERSIONS
+// ============================================================================
+/**
+ * Convert LCH to LAB
+ */
+export function lchToLab(lch) {
+    const h = (lch.h * Math.PI) / 180;
+    const a = lch.c * Math.cos(h);
+    const b = lch.c * Math.sin(h);
+    return {
+        l: lch.l,
+        a,
+        b,
+        alpha: lch.alpha,
+    };
+}
+/**
+ * Convert LCH to RGB
+ */
+export function lchToRgb(lch) {
+    const lab = lchToLab(lch);
+    return labToRgb(lab);
+}
+/**
+ * Convert LCH to XYZ
+ */
+export function lchToXyz(lch) {
+    const lab = lchToLab(lch);
+    return labToXyz(lab);
+}
+// ============================================================================
+// OKLAB CONVERSIONS
+// ============================================================================
+/**
+ * Convert OKLAB to RGB
+ */
+export function oklabToRgb(oklab) {
+    const l_ = oklab.l + 0.3963377774 * oklab.a + 0.2158037573 * oklab.b;
+    const m_ = oklab.l - 0.1055613458 * oklab.a - 0.0638541728 * oklab.b;
+    const s_ = oklab.l - 0.0894841775 * oklab.a - 1.291485548 * oklab.b;
+    const l = l_ * l_ * l_;
+    const m = m_ * m_ * m_;
+    const s = s_ * s_ * s_;
+    let lr = +4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;
+    let lg = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;
+    let lb = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;
+    // Apply gamma correction
+    lr = lr > 0.0031308 ? 1.055 * Math.pow(lr, 1 / 2.4) - 0.055 : 12.92 * lr;
+    lg = lg > 0.0031308 ? 1.055 * Math.pow(lg, 1 / 2.4) - 0.055 : 12.92 * lg;
+    lb = lb > 0.0031308 ? 1.055 * Math.pow(lb, 1 / 2.4) - 0.055 : 12.92 * lb;
+    return {
+        r: Math.round(clamp(lr * 255, 0, 255)),
+        g: Math.round(clamp(lg * 255, 0, 255)),
+        b: Math.round(clamp(lb * 255, 0, 255)),
+        a: oklab.alpha,
+    };
+}
+/**
+ * Convert OKLAB to OKLCH
+ */
+export function oklabToOklch(oklab) {
+    const c = Math.sqrt(oklab.a * oklab.a + oklab.b * oklab.b);
+    let h = (Math.atan2(oklab.b, oklab.a) * 180) / Math.PI;
+    if (h < 0) {
+        h += 360;
+    }
+    return {
+        l: oklab.l,
+        c,
+        h,
+        alpha: oklab.alpha,
+    };
+}
+// ============================================================================
+// OKLCH CONVERSIONS
+// ============================================================================
+/**
+ * Convert OKLCH to OKLAB
+ */
+export function oklchToOklab(oklch) {
+    const h = (oklch.h * Math.PI) / 180;
+    const a = oklch.c * Math.cos(h);
+    const b = oklch.c * Math.sin(h);
+    return {
+        l: oklch.l,
+        a,
+        b,
+        alpha: oklch.alpha,
+    };
+}
+/**
+ * Convert OKLCH to RGB
+ */
+export function oklchToRgb(oklch) {
+    const oklab = oklchToOklab(oklch);
+    return oklabToRgb(oklab);
+}
+// ============================================================================
+// UNIVERSAL CONVERTER
+// ============================================================================
+/**
+ * Convert any color to RGB
+ */
+export function anyToRgb(color) {
+    // Check which color space we have based on properties
+    if ('r' in color && 'g' in color && 'b' in color) {
+        return color;
+    }
+    if ('h' in color && 's' in color && 'l' in color) {
+        return hslToRgb(color);
+    }
+    if ('h' in color && 's' in color && 'v' in color) {
+        return hsvToRgb(color);
+    }
+    if ('h' in color && 'w' in color && 'b' in color) {
+        return hwbToRgb(color);
+    }
+    if ('c' in color && 'm' in color && 'y' in color && 'k' in color) {
+        return cmykToRgb(color);
+    }
+    if ('x' in color && 'y' in color && 'z' in color) {
+        return xyzToRgb(color);
+    }
+    if ('l' in color &&
+        'a' in color &&
+        'b' in color &&
+        !('c' in color) &&
+        !('h' in color)) {
+        return labToRgb(color);
+    }
+    if ('l' in color && 'c' in color && 'h' in color) {
+        // Could be LCH or OKLCH - we'll treat as LCH by default
+        // For better detection, check if values are in OKLCH range
+        const lchColor = color;
+        if (lchColor.l <= 1) {
+            // Likely OKLCH (0-1 range)
+            return oklchToRgb(color);
+        }
+        return lchToRgb(lchColor);
+    }
+    throw new Error('Unknown color format');
+}
+/**
+ * Generic conversion function
+ */
+export function convertColor(color, targetFormat, options = {}) {
+    const { round = true, precision = 2, preserveAlpha = true } = options;
+    // First convert to RGB as intermediate format
+    const rgb = anyToRgb(color);
+    let result;
+    switch (targetFormat.toLowerCase()) {
+        case 'rgb':
+            result = rgb;
+            break;
+        case 'hsl':
+            result = rgbToHsl(rgb);
+            break;
+        case 'hsv':
+            result = rgbToHsv(rgb);
+            break;
+        case 'hwb':
+            result = rgbToHwb(rgb);
+            break;
+        case 'cmyk':
+            result = rgbToCmyk(rgb);
+            break;
+        case 'xyz':
+            result = rgbToXyz(rgb);
+            break;
+        case 'lab':
+            result = rgbToLab(rgb);
+            break;
+        case 'lch':
+            result = rgbToLch(rgb);
+            break;
+        case 'oklab':
+            result = rgbToOklab(rgb);
+            break;
+        case 'oklch':
+            result = rgbToOklch(rgb);
+            break;
+        default:
+            result = rgb;
+    }
+    // Apply rounding if requested
+    if (round && result) {
+        Object.keys(result).forEach((key) => {
+            if (typeof result[key] === 'number' && key !== 'a' && key !== 'alpha') {
+                result[key] = roundToPrecision(result[key], precision);
+            }
+        });
+    }
+    // Handle alpha channel
+    if (!preserveAlpha) {
+        delete result.a;
+        delete result.alpha;
+    }
+    return result;
+}
+/**
+ * Batch convert multiple colors
+ */
+export function batchConvert(colors, targetFormat, options = {}) {
+    return colors.map((color) => convertColor(color, targetFormat, options));
+}
+/**
+ * Get conversion path between two formats
+ */
+export function getConversionPath(from, to) {
+    // Direct conversions
+    const directConversions = {
+        rgb: ['hsl', 'hsv', 'hwb', 'cmyk', 'xyz', 'lab', 'lch', 'oklab', 'oklch'],
+        hsl: ['rgb', 'hsv', 'hwb'],
+        hsv: ['rgb', 'hsl', 'hwb'],
+        hwb: ['rgb', 'hsl', 'hsv'],
+        cmyk: ['rgb', 'hsl', 'hsv'],
+        xyz: ['rgb', 'lab'],
+        lab: ['rgb', 'xyz', 'lch'],
+        lch: ['rgb', 'lab', 'xyz'],
+        oklab: ['rgb', 'oklch'],
+        oklch: ['rgb', 'oklab'],
+    };
+    from = from.toLowerCase();
+    to = to.toLowerCase();
+    if (from === to) {
+        return [from];
+    }
+    // Check for direct conversion
+    if (directConversions[from]?.includes(to)) {
+        return [from, to];
+    }
+    // Use RGB as intermediate (most common case)
+    if (directConversions[from]?.includes('rgb') &&
+        directConversions['rgb']?.includes(to)) {
+        return [from, 'rgb', to];
+    }
+    // Use XYZ as intermediate for LAB/LCH conversions
+    if (['lab', 'lch'].includes(from) &&
+        ['lab', 'lch'].includes(to) &&
+        from !== to) {
+        return [from, 'xyz', to];
+    }
+    // Use OKLAB as intermediate for OKLCH
+    if (['oklab', 'oklch'].includes(from) &&
+        ['oklab', 'oklch'].includes(to) &&
+        from !== to) {
+        return [from, 'oklab', to];
+    }
+    // Complex path through RGB
+    if (directConversions[from] && directConversions['rgb']?.includes(to)) {
+        return [from, 'rgb', to];
+    }
+    return null;
+}
+/**
+ * Check if direct conversion exists between two formats
+ */
+export function hasDirectConversion(from, to) {
+    const path = getConversionPath(from, to);
+    return path !== null && path.length <= 2;
+}
+/**
+ * Get all supported color formats
+ */
+export function getSupportedFormats() {
+    return [
+        'rgb',
+        'hsl',
+        'hsv',
+        'hwb',
+        'cmyk',
+        'xyz',
+        'lab',
+        'lch',
+        'oklab',
+        'oklch',
+    ];
+}
+/**
+ * Validate color format
+ */
+export function isValidFormat(format) {
+    return getSupportedFormats().includes(format.toLowerCase());
+}