@zag-js/color-utils 1.41.0 → 2.0.0-next.0

package/dist/area-gradient.js

@@ -74,6 +74,11 @@ function getColorAreaGradient(color, options) {
       break;
     }
     case "lightness": {
+      if (color.getFormat() === "oklab") {
+        dir = xChannel === "b";
+        background = (0, import_color_format_gradient.generateOKLAB_AB)(orientation, dir, zValue);
+        break;
+      }
       dir = xChannel === "hue";
       background = (0, import_color_format_gradient.generateHSL_L)(orientation, dir, zValue);
       break;

package/dist/area-gradient.mjs

@@ -10,7 +10,8 @@ import {
   generateHSL_S,
   generateHSB_S,
   generateHSB_B,
-  generateHSL_L
+  generateHSL_L,
+  generateOKLAB_AB
 } from "./color-format-gradient.mjs";
 function getColorAreaGradient(color, options) {
   const { xChannel, yChannel, dir: dirProp = "ltr" } = options;
@@ -62,6 +63,11 @@ function getColorAreaGradient(color, options) {
       break;
     }
     case "lightness": {
+      if (color.getFormat() === "oklab") {
+        dir = xChannel === "b";
+        background = generateOKLAB_AB(orientation, dir, zValue);
+        break;
+      }
       dir = xChannel === "hue";
       background = generateHSL_L(orientation, dir, zValue);
       break;

package/dist/color-format-gradient.d.mts

@@ -64,5 +64,27 @@ declare const generateHSB_B: (orientation: [string, string], dir: boolean, alpha
         background: string;
     };
 };
+/** oklab: x = a, y = b, z = lightness (fixed L) */
+declare const generateOKLAB_AB: (orientation: [string, string], dir: boolean, L: number) => {
+    areaStyles: {
+        background: string;
+    };
+    areaGradientStyles: {
+        background: string;
+        maskImage: string;
+        WebkitMaskImage: string;
+    };
+};
+/** oklch: x = lightness, y = chroma, z = hue (fixed H) */
+declare const generateOKLCH_LC: (orientation: [string, string], dir: boolean, H: number) => {
+    areaStyles: {
+        background: string;
+    };
+    areaGradientStyles: {
+        background: string;
+        maskImage: string;
+        WebkitMaskImage: string;
+    };
+};
 
-export { generateHSB_B, generateHSB_H, generateHSB_S, generateHSL_H, generateHSL_L, generateHSL_S, generateRGB_B, generateRGB_G, generateRGB_R };
+export { generateHSB_B, generateHSB_H, generateHSB_S, generateHSL_H, generateHSL_L, generateHSL_S, generateOKLAB_AB, generateOKLCH_LC, generateRGB_B, generateRGB_G, generateRGB_R };

package/dist/color-format-gradient.d.ts

@@ -64,5 +64,27 @@ declare const generateHSB_B: (orientation: [string, string], dir: boolean, alpha
         background: string;
     };
 };
+/** oklab: x = a, y = b, z = lightness (fixed L) */
+declare const generateOKLAB_AB: (orientation: [string, string], dir: boolean, L: number) => {
+    areaStyles: {
+        background: string;
+    };
+    areaGradientStyles: {
+        background: string;
+        maskImage: string;
+        WebkitMaskImage: string;
+    };
+};
+/** oklch: x = lightness, y = chroma, z = hue (fixed H) */
+declare const generateOKLCH_LC: (orientation: [string, string], dir: boolean, H: number) => {
+    areaStyles: {
+        background: string;
+    };
+    areaGradientStyles: {
+        background: string;
+        maskImage: string;
+        WebkitMaskImage: string;
+    };
+};
 
-export { generateHSB_B, generateHSB_H, generateHSB_S, generateHSL_H, generateHSL_L, generateHSL_S, generateRGB_B, generateRGB_G, generateRGB_R };
+export { generateHSB_B, generateHSB_H, generateHSB_S, generateHSL_H, generateHSL_L, generateHSL_S, generateOKLAB_AB, generateOKLCH_LC, generateRGB_B, generateRGB_G, generateRGB_R };

package/dist/color-format-gradient.js

@@ -26,6 +26,8 @@ __export(color_format_gradient_exports, {
   generateHSL_H: () => generateHSL_H,
   generateHSL_L: () => generateHSL_L,
   generateHSL_S: () => generateHSL_S,
+  generateOKLAB_AB: () => generateOKLAB_AB,
+  generateOKLCH_LC: () => generateOKLCH_LC,
   generateRGB_B: () => generateRGB_B,
   generateRGB_G: () => generateRGB_G,
   generateRGB_R: () => generateRGB_R
@@ -150,6 +152,35 @@ var generateHSB_B = (orientation, dir, alphaValue) => {
   };
   return result;
 };
+var generateOKLAB_AB = (orientation, dir, L) => {
+  const l = L === 0 ? "none" : `${(L * 100).toFixed(2)}%`;
+  const maskImage = `linear-gradient(to ${orientation[Number(!dir)]}, black, transparent)`;
+  const result = {
+    areaStyles: {
+      background: `linear-gradient(to ${orientation[Number(dir)]} in oklab, oklab(${l} -100% 100%), oklab(${l} 100% 100%))`
+    },
+    areaGradientStyles: {
+      background: `linear-gradient(to ${orientation[Number(dir)]} in oklab, oklab(${l} -100% -100%), oklab(${l} 100% -100%))`,
+      maskImage,
+      WebkitMaskImage: maskImage
+    }
+  };
+  return result;
+};
+var generateOKLCH_LC = (orientation, dir, H) => {
+  const maskImage = `linear-gradient(to ${orientation[Number(dir)]}, transparent, black)`;
+  const result = {
+    areaStyles: {
+      background: `linear-gradient(to ${orientation[Number(!dir)]} in oklch, oklch(0 0.001 ${H}), oklch(1 0.001 ${H}))`
+    },
+    areaGradientStyles: {
+      background: `linear-gradient(to ${orientation[Number(!dir)]} in oklch, oklch(0 0.5 ${H}), oklch(1 0.5 ${H}))`,
+      maskImage,
+      WebkitMaskImage: maskImage
+    }
+  };
+  return result;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   generateHSB_B,
@@ -158,6 +189,8 @@ var generateHSB_B = (orientation, dir, alphaValue) => {
   generateHSL_H,
   generateHSL_L,
   generateHSL_S,
+  generateOKLAB_AB,
+  generateOKLCH_LC,
   generateRGB_B,
   generateRGB_G,
   generateRGB_R

package/dist/color-format-gradient.mjs

@@ -120,6 +120,35 @@ var generateHSB_B = (orientation, dir, alphaValue) => {
   };
   return result;
 };
+var generateOKLAB_AB = (orientation, dir, L) => {
+  const l = L === 0 ? "none" : `${(L * 100).toFixed(2)}%`;
+  const maskImage = `linear-gradient(to ${orientation[Number(!dir)]}, black, transparent)`;
+  const result = {
+    areaStyles: {
+      background: `linear-gradient(to ${orientation[Number(dir)]} in oklab, oklab(${l} -100% 100%), oklab(${l} 100% 100%))`
+    },
+    areaGradientStyles: {
+      background: `linear-gradient(to ${orientation[Number(dir)]} in oklab, oklab(${l} -100% -100%), oklab(${l} 100% -100%))`,
+      maskImage,
+      WebkitMaskImage: maskImage
+    }
+  };
+  return result;
+};
+var generateOKLCH_LC = (orientation, dir, H) => {
+  const maskImage = `linear-gradient(to ${orientation[Number(dir)]}, transparent, black)`;
+  const result = {
+    areaStyles: {
+      background: `linear-gradient(to ${orientation[Number(!dir)]} in oklch, oklch(0 0.001 ${H}), oklch(1 0.001 ${H}))`
+    },
+    areaGradientStyles: {
+      background: `linear-gradient(to ${orientation[Number(!dir)]} in oklch, oklch(0 0.5 ${H}), oklch(1 0.5 ${H}))`,
+      maskImage,
+      WebkitMaskImage: maskImage
+    }
+  };
+  return result;
+};
 export {
   generateHSB_B,
   generateHSB_H,
@@ -127,6 +156,8 @@ export {
   generateHSL_H,
   generateHSL_L,
   generateHSL_S,
+  generateOKLAB_AB,
+  generateOKLCH_LC,
   generateRGB_B,
   generateRGB_G,
   generateRGB_R

package/dist/gamut.d.mts

@@ -0,0 +1,6 @@
+import { ColorType } from './types.mjs';
+
+/** Whether the color lies inside the sRGB gamut (checks in linear RGB space, no clamping). */
+declare function isInSrgbGamut(color: ColorType): boolean;
+
+export { isInSrgbGamut };

package/dist/gamut.d.ts

@@ -0,0 +1,6 @@
+import { ColorType } from './types.js';
+
+/** Whether the color lies inside the sRGB gamut (checks in linear RGB space, no clamping). */
+declare function isInSrgbGamut(color: ColorType): boolean;
+
+export { isInSrgbGamut };

package/dist/gamut.js

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/gamut.ts
+var gamut_exports = {};
+__export(gamut_exports, {
+  isInSrgbGamut: () => isInSrgbGamut
+});
+module.exports = __toCommonJS(gamut_exports);
+var import_oklab_math = require("./oklab-math.js");
+function isInSrgbGamut(color) {
+  const oklab = color.toFormat("oklab");
+  const L = oklab.getChannelValue("lightness");
+  const a = oklab.getChannelValue("a");
+  const b = oklab.getChannelValue("b");
+  return (0, import_oklab_math.isLinearRgbInSrgbGamut)((0, import_oklab_math.oklabToLinearRgb)(L, a, b));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isInSrgbGamut
+});

package/dist/gamut.mjs

@@ -0,0 +1,14 @@
+import "./chunk-QZ7TP4HQ.mjs";
+
+// src/gamut.ts
+import { isLinearRgbInSrgbGamut, oklabToLinearRgb } from "./oklab-math.mjs";
+function isInSrgbGamut(color) {
+  const oklab = color.toFormat("oklab");
+  const L = oklab.getChannelValue("lightness");
+  const a = oklab.getChannelValue("a");
+  const b = oklab.getChannelValue("b");
+  return isLinearRgbInSrgbGamut(oklabToLinearRgb(L, a, b));
+}
+export {
+  isInSrgbGamut
+};

package/dist/hsb-color.d.mts

@@ -7,6 +7,11 @@ declare class HSBColor extends Color {
     private brightness;
     private alpha;
     constructor(hue: number, saturation: number, brightness: number, alpha: number);
+    /**
+     * Create HSBColor from float sRGB values (0-1 range, clamped).
+     * Higher precision than going through integer RGBColor (0-255).
+     */
+    static fromSrgbFloat(r: number, g: number, b: number, alpha: number): HSBColor;
     static parse(value: string): HSBColor | void;
     toString(format?: ColorStringFormat): string;
     toFormat(format: ColorFormat): ColorType;

package/dist/hsb-color.d.ts

@@ -7,6 +7,11 @@ declare class HSBColor extends Color {
     private brightness;
     private alpha;
     constructor(hue: number, saturation: number, brightness: number, alpha: number);
+    /**
+     * Create HSBColor from float sRGB values (0-1 range, clamped).
+     * Higher precision than going through integer RGBColor (0-255).
+     */
+    static fromSrgbFloat(r: number, g: number, b: number, alpha: number): HSBColor;
     static parse(value: string): HSBColor | void;
     toString(format?: ColorStringFormat): string;
     toFormat(format: ColorFormat): ColorType;

package/dist/hsb-color.js

@@ -38,6 +38,40 @@ var _HSBColor = class _HSBColor extends import_color.Color {
     __publicField(this, "brightness", brightness);
     __publicField(this, "alpha", alpha);
   }
+  /**
+   * Create HSBColor from float sRGB values (0-1 range, clamped).
+   * Higher precision than going through integer RGBColor (0-255).
+   */
+  static fromSrgbFloat(r, g, b, alpha) {
+    const rc = Math.max(0, Math.min(1, r));
+    const gc = Math.max(0, Math.min(1, g));
+    const bc = Math.max(0, Math.min(1, b));
+    const min = Math.min(rc, gc, bc);
+    const brightness = Math.max(rc, gc, bc);
+    const chroma = brightness - min;
+    const saturation = brightness === 0 ? 0 : chroma / brightness;
+    let hue = 0;
+    if (chroma !== 0) {
+      switch (brightness) {
+        case rc:
+          hue = (gc - bc) / chroma + (gc < bc ? 6 : 0);
+          break;
+        case gc:
+          hue = (bc - rc) / chroma + 2;
+          break;
+        case bc:
+          hue = (rc - gc) / chroma + 4;
+          break;
+      }
+      hue /= 6;
+    }
+    return new _HSBColor(
+      (0, import_utils.toFixedNumber)(hue * 360, 4),
+      (0, import_utils.toFixedNumber)(saturation * 100, 4),
+      (0, import_utils.toFixedNumber)(brightness * 100, 4),
+      (0, import_utils.toFixedNumber)(alpha, 4)
+    );
+  }
   static parse(value) {
     let m;
     if (m = value.match(HSB_REGEX)) {
@@ -73,6 +107,9 @@ var _HSBColor = class _HSBColor extends import_color.Color {
         return this.toHSL();
       case "rgba":
         return this.toRGB();
+      case "oklab":
+      case "oklch":
+        return this.toRGB().toFormat(format);
       default:
         throw new Error("Unsupported color conversion: hsb -> " + format);
     }

package/dist/hsb-color.mjs

@@ -16,6 +16,40 @@ var _HSBColor = class _HSBColor extends Color {
     __publicField(this, "brightness", brightness);
     __publicField(this, "alpha", alpha);
   }
+  /**
+   * Create HSBColor from float sRGB values (0-1 range, clamped).
+   * Higher precision than going through integer RGBColor (0-255).
+   */
+  static fromSrgbFloat(r, g, b, alpha) {
+    const rc = Math.max(0, Math.min(1, r));
+    const gc = Math.max(0, Math.min(1, g));
+    const bc = Math.max(0, Math.min(1, b));
+    const min = Math.min(rc, gc, bc);
+    const brightness = Math.max(rc, gc, bc);
+    const chroma = brightness - min;
+    const saturation = brightness === 0 ? 0 : chroma / brightness;
+    let hue = 0;
+    if (chroma !== 0) {
+      switch (brightness) {
+        case rc:
+          hue = (gc - bc) / chroma + (gc < bc ? 6 : 0);
+          break;
+        case gc:
+          hue = (bc - rc) / chroma + 2;
+          break;
+        case bc:
+          hue = (rc - gc) / chroma + 4;
+          break;
+      }
+      hue /= 6;
+    }
+    return new _HSBColor(
+      toFixedNumber(hue * 360, 4),
+      toFixedNumber(saturation * 100, 4),
+      toFixedNumber(brightness * 100, 4),
+      toFixedNumber(alpha, 4)
+    );
+  }
   static parse(value) {
     let m;
     if (m = value.match(HSB_REGEX)) {
@@ -51,6 +85,9 @@ var _HSBColor = class _HSBColor extends Color {
         return this.toHSL();
       case "rgba":
         return this.toRGB();
+      case "oklab":
+      case "oklch":
+        return this.toRGB().toFormat(format);
       default:
         throw new Error("Unsupported color conversion: hsb -> " + format);
     }

package/dist/hsl-color.js

@@ -73,6 +73,9 @@ var _HSLColor = class _HSLColor extends import_color.Color {
         return this.toHSB();
       case "rgba":
         return this.toRGB();
+      case "oklab":
+      case "oklch":
+        return this.toRGB().toFormat(format);
       default:
         throw new Error("Unsupported color conversion: hsl -> " + format);
     }

package/dist/hsl-color.mjs

@@ -50,6 +50,9 @@ var _HSLColor = class _HSLColor extends Color {
         return this.toHSB();
       case "rgba":
         return this.toRGB();
+      case "oklab":
+      case "oklch":
+        return this.toRGB().toFormat(format);
       default:
         throw new Error("Unsupported color conversion: hsl -> " + format);
     }

package/dist/index.d.mts

@@ -1,4 +1,7 @@
 export { getColorAreaGradient } from './area-gradient.mjs';
 export { Color } from './color.mjs';
+export { isDisplayP3HsvInSrgbGamut, isLinearRgbInSrgbGamut, linearRgbToOklab, oklabToLinearRgb, oklabToOklch, oklchToOklab, srgbToLinearRgb } from './oklab-math.mjs';
+export { isInSrgbGamut } from './gamut.mjs';
+export { OklabColor, OklchColor } from './oklab-color.mjs';
 export { normalizeColor, parseColor } from './parse-color.mjs';
 export { ColorAxes, ColorChannel, ColorChannelRange, ColorFormat, ColorStringFormat, ColorType } from './types.mjs';

package/dist/index.d.ts

@@ -1,4 +1,7 @@
 export { getColorAreaGradient } from './area-gradient.js';
 export { Color } from './color.js';
+export { isDisplayP3HsvInSrgbGamut, isLinearRgbInSrgbGamut, linearRgbToOklab, oklabToLinearRgb, oklabToOklch, oklchToOklab, srgbToLinearRgb } from './oklab-math.js';
+export { isInSrgbGamut } from './gamut.js';
+export { OklabColor, OklchColor } from './oklab-color.js';
 export { normalizeColor, parseColor } from './parse-color.js';
 export { ColorAxes, ColorChannel, ColorChannelRange, ColorFormat, ColorStringFormat, ColorType } from './types.js';

package/dist/index.js

@@ -21,18 +21,41 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   Color: () => import_color.Color,
+  OklabColor: () => import_oklab_color.OklabColor,
+  OklchColor: () => import_oklab_color.OklchColor,
   getColorAreaGradient: () => import_area_gradient.getColorAreaGradient,
+  isDisplayP3HsvInSrgbGamut: () => import_oklab_math.isDisplayP3HsvInSrgbGamut,
+  isInSrgbGamut: () => import_gamut.isInSrgbGamut,
+  isLinearRgbInSrgbGamut: () => import_oklab_math.isLinearRgbInSrgbGamut,
+  linearRgbToOklab: () => import_oklab_math.linearRgbToOklab,
   normalizeColor: () => import_parse_color.normalizeColor,
-  parseColor: () => import_parse_color.parseColor
+  oklabToLinearRgb: () => import_oklab_math.oklabToLinearRgb,
+  oklabToOklch: () => import_oklab_math.oklabToOklch,
+  oklchToOklab: () => import_oklab_math.oklchToOklab,
+  parseColor: () => import_parse_color.parseColor,
+  srgbToLinearRgb: () => import_oklab_math.srgbToLinearRgb
 });
 module.exports = __toCommonJS(index_exports);
 var import_area_gradient = require("./area-gradient.js");
 var import_color = require("./color.js");
+var import_oklab_math = require("./oklab-math.js");
+var import_gamut = require("./gamut.js");
+var import_oklab_color = require("./oklab-color.js");
 var import_parse_color = require("./parse-color.js");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Color,
+  OklabColor,
+  OklchColor,
   getColorAreaGradient,
+  isDisplayP3HsvInSrgbGamut,
+  isInSrgbGamut,
+  isLinearRgbInSrgbGamut,
+  linearRgbToOklab,
   normalizeColor,
-  parseColor
+  oklabToLinearRgb,
+  oklabToOklch,
+  oklchToOklab,
+  parseColor,
+  srgbToLinearRgb
 });

package/dist/index.mjs

@@ -3,10 +3,31 @@ import "./chunk-QZ7TP4HQ.mjs";
 // src/index.ts
 import { getColorAreaGradient } from "./area-gradient.mjs";
 import { Color } from "./color.mjs";
+import {
+  isDisplayP3HsvInSrgbGamut,
+  isLinearRgbInSrgbGamut,
+  linearRgbToOklab,
+  oklabToLinearRgb,
+  oklabToOklch,
+  oklchToOklab,
+  srgbToLinearRgb
+} from "./oklab-math.mjs";
+import { isInSrgbGamut } from "./gamut.mjs";
+import { OklabColor, OklchColor } from "./oklab-color.mjs";
 import { normalizeColor, parseColor } from "./parse-color.mjs";
 export {
   Color,
+  OklabColor,
+  OklchColor,
   getColorAreaGradient,
+  isDisplayP3HsvInSrgbGamut,
+  isInSrgbGamut,
+  isLinearRgbInSrgbGamut,
+  linearRgbToOklab,
   normalizeColor,
-  parseColor
+  oklabToLinearRgb,
+  oklabToOklch,
+  oklchToOklab,
+  parseColor,
+  srgbToLinearRgb
 };

package/dist/oklab-color.d.mts

@@ -0,0 +1,64 @@
+import { Color } from './color.mjs';
+import { ColorStringFormat, ColorFormat, ColorType, ColorChannel, ColorChannelRange } from './types.mjs';
+
+/** Parse `oklab(L a b)` / `oklab(L a b / alpha)` body (inside parentheses). */
+declare function parseOklabParams(inner: string): {
+    L: number;
+    a: number;
+    b: number;
+    alpha: number;
+} | void;
+declare class OklabColor extends Color {
+    private lightness;
+    private a;
+    private b;
+    private alpha;
+    constructor(lightness: number, a: number, b: number, alpha: number);
+    static parse(value: string): OklabColor | void;
+    toString(format?: ColorStringFormat): string;
+    toFormat(format: ColorFormat): ColorType;
+    private toRgb;
+    private toOklch;
+    clone(): ColorType;
+    getChannelValue(channel: ColorChannel): number;
+    withChannelValue(channel: ColorChannel, value: number): ColorType;
+    formatChannelValue(channel: ColorChannel, locale: string): string;
+    private getChannelFormatOptions;
+    getChannelRange(channel: ColorChannel): ColorChannelRange;
+    toJSON(): Record<string, number>;
+    getFormat(): ColorFormat;
+    private static colorChannels;
+    getChannels(): [ColorChannel, ColorChannel, ColorChannel];
+    isEqual(color: ColorType): boolean;
+}
+declare function parseOklchParams(inner: string): {
+    L: number;
+    C: number;
+    H: number;
+    alpha: number;
+} | void;
+declare class OklchColor extends Color {
+    private lightness;
+    private hue;
+    private chroma;
+    private alpha;
+    constructor(lightness: number, hue: number, chroma: number, alpha: number);
+    static parse(value: string): OklchColor | void;
+    toString(format?: ColorStringFormat): string;
+    toFormat(format: ColorFormat): ColorType;
+    private toOklab;
+    private toRgb;
+    clone(): ColorType;
+    getChannelValue(channel: ColorChannel): number;
+    withChannelValue(channel: ColorChannel, value: number): ColorType;
+    formatChannelValue(channel: ColorChannel, locale: string): string;
+    private getChannelFormatOptions;
+    getChannelRange(channel: ColorChannel): ColorChannelRange;
+    toJSON(): Record<string, number>;
+    getFormat(): ColorFormat;
+    private static colorChannels;
+    getChannels(): [ColorChannel, ColorChannel, ColorChannel];
+    isEqual(color: ColorType): boolean;
+}
+
+export { OklabColor, OklchColor, parseOklabParams, parseOklchParams };

package/dist/oklab-color.d.ts

@@ -0,0 +1,64 @@
+import { Color } from './color.js';
+import { ColorStringFormat, ColorFormat, ColorType, ColorChannel, ColorChannelRange } from './types.js';
+
+/** Parse `oklab(L a b)` / `oklab(L a b / alpha)` body (inside parentheses). */
+declare function parseOklabParams(inner: string): {
+    L: number;
+    a: number;
+    b: number;
+    alpha: number;
+} | void;
+declare class OklabColor extends Color {
+    private lightness;
+    private a;
+    private b;
+    private alpha;
+    constructor(lightness: number, a: number, b: number, alpha: number);
+    static parse(value: string): OklabColor | void;
+    toString(format?: ColorStringFormat): string;
+    toFormat(format: ColorFormat): ColorType;
+    private toRgb;
+    private toOklch;
+    clone(): ColorType;
+    getChannelValue(channel: ColorChannel): number;
+    withChannelValue(channel: ColorChannel, value: number): ColorType;
+    formatChannelValue(channel: ColorChannel, locale: string): string;
+    private getChannelFormatOptions;
+    getChannelRange(channel: ColorChannel): ColorChannelRange;
+    toJSON(): Record<string, number>;
+    getFormat(): ColorFormat;
+    private static colorChannels;
+    getChannels(): [ColorChannel, ColorChannel, ColorChannel];
+    isEqual(color: ColorType): boolean;
+}
+declare function parseOklchParams(inner: string): {
+    L: number;
+    C: number;
+    H: number;
+    alpha: number;
+} | void;
+declare class OklchColor extends Color {
+    private lightness;
+    private hue;
+    private chroma;
+    private alpha;
+    constructor(lightness: number, hue: number, chroma: number, alpha: number);
+    static parse(value: string): OklchColor | void;
+    toString(format?: ColorStringFormat): string;
+    toFormat(format: ColorFormat): ColorType;
+    private toOklab;
+    private toRgb;
+    clone(): ColorType;
+    getChannelValue(channel: ColorChannel): number;
+    withChannelValue(channel: ColorChannel, value: number): ColorType;
+    formatChannelValue(channel: ColorChannel, locale: string): string;
+    private getChannelFormatOptions;
+    getChannelRange(channel: ColorChannel): ColorChannelRange;
+    toJSON(): Record<string, number>;
+    getFormat(): ColorFormat;
+    private static colorChannels;
+    getChannels(): [ColorChannel, ColorChannel, ColorChannel];
+    isEqual(color: ColorType): boolean;
+}
+
+export { OklabColor, OklchColor, parseOklabParams, parseOklchParams };