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

package/dist/oklab-color.mjs

@@ -0,0 +1,370 @@
+import {
+  __publicField
+} from "./chunk-QZ7TP4HQ.mjs";
+
+// src/oklab-color.ts
+import { clampValue, mod, toFixedNumber } from "@zag-js/utils";
+import { Color } from "./color.mjs";
+import { HSBColor } from "./hsb-color.mjs";
+import { RGBColor } from "./rgb-color.mjs";
+import { linearChannelToSrgb, linearRgbToSrgb, oklabToLinearRgb, oklabToOklch, oklchToOklab } from "./oklab-math.mjs";
+function oklabToHsb(L, a, b, alpha) {
+  const lin = oklabToLinearRgb(L, a, b);
+  return HSBColor.fromSrgbFloat(
+    linearChannelToSrgb(lin.r),
+    linearChannelToSrgb(lin.g),
+    linearChannelToSrgb(lin.b),
+    alpha
+  );
+}
+var OKLAB_HEAD = /^oklab\(\s*/i;
+function parseCssNumber(token) {
+  const t = token.trim().toLowerCase();
+  if (t === "none") return void 0;
+  if (t.endsWith("%")) return Number.parseFloat(t) / 100;
+  const n = Number.parseFloat(t);
+  return Number.isFinite(n) ? n : void 0;
+}
+function parseOklabParams(inner) {
+  const [main, alphaPart] = inner.split(/\s*\/\s*/);
+  const tokens = main.trim().split(/\s+/).filter(Boolean);
+  if (tokens.length < 3) return;
+  const L = parseCssNumber(tokens[0]);
+  const a = parseCssNumber(tokens[1]);
+  const b = parseCssNumber(tokens[2]);
+  if (L === void 0 || a === void 0 || b === void 0) return;
+  let alpha = 1;
+  if (alphaPart) {
+    const at = alphaPart.trim().toLowerCase();
+    if (at !== "none") {
+      const av = at.endsWith("%") ? Number.parseFloat(at) / 100 : Number.parseFloat(at);
+      if (Number.isFinite(av)) alpha = clampValue(av, 0, 1);
+    }
+  }
+  return { L: clampValue(L, 0, 1), a, b, alpha };
+}
+var _OklabColor = class _OklabColor extends Color {
+  constructor(lightness, a, b, alpha) {
+    super();
+    __publicField(this, "lightness", lightness);
+    __publicField(this, "a", a);
+    __publicField(this, "b", b);
+    __publicField(this, "alpha", alpha);
+  }
+  static parse(value) {
+    if (!OKLAB_HEAD.test(value)) return;
+    const end = value.lastIndexOf(")");
+    if (end < 0) return;
+    const inner = value.slice(value.indexOf("(") + 1, end);
+    const p = parseOklabParams(inner);
+    if (!p) return;
+    return new _OklabColor(p.L, p.a, p.b, p.alpha);
+  }
+  toString(format = "css") {
+    switch (format) {
+      case "hex":
+        return this.toFormat("rgba").toString("hex");
+      case "hexa":
+        return this.toFormat("rgba").toString("hexa");
+      case "oklab":
+        return formatOklabCss(this.lightness, this.a, this.b, this.alpha);
+      case "css":
+        return formatOklabCss(this.lightness, this.a, this.b, this.alpha);
+      default:
+        return this.toFormat(format).toString(format);
+    }
+  }
+  toFormat(format) {
+    switch (format) {
+      case "oklab":
+        return this;
+      case "oklch":
+        return this.toOklch();
+      case "rgba":
+        return this.toRgb();
+      case "hsla":
+        return this.toRgb().toFormat("hsla");
+      case "hsba":
+        return oklabToHsb(this.lightness, this.a, this.b, this.alpha);
+      default:
+        throw new Error("Unsupported color conversion: oklab -> " + format);
+    }
+  }
+  toRgb() {
+    const { r, g, b } = linearRgbToSrgb(oklabToLinearRgb(this.lightness, this.a, this.b));
+    return new RGBColor(r, g, b, toFixedNumber(this.alpha, 4));
+  }
+  toOklch() {
+    const { L, C, H } = oklabToOklch(this.lightness, this.a, this.b);
+    return new OklchColor(L, H, C, toFixedNumber(this.alpha, 4));
+  }
+  clone() {
+    return new _OklabColor(this.lightness, this.a, this.b, this.alpha);
+  }
+  getChannelValue(channel) {
+    switch (channel) {
+      case "lightness":
+        return this.lightness;
+      case "a":
+        return this.a;
+      case "b":
+        return this.b;
+      case "alpha":
+        return this.alpha;
+      default:
+        throw new Error("Unsupported color channel: " + channel);
+    }
+  }
+  withChannelValue(channel, value) {
+    const { minValue, maxValue } = this.getChannelRange(channel);
+    const v = clampValue(value, minValue, maxValue);
+    switch (channel) {
+      case "lightness":
+        return new _OklabColor(v, this.a, this.b, this.alpha);
+      case "a":
+        return new _OklabColor(this.lightness, v, this.b, this.alpha);
+      case "b":
+        return new _OklabColor(this.lightness, this.a, v, this.alpha);
+      case "alpha":
+        return new _OklabColor(this.lightness, this.a, this.b, v);
+      default:
+        throw new Error("Unsupported color channel: " + channel);
+    }
+  }
+  formatChannelValue(channel, locale) {
+    const options = this.getChannelFormatOptions(channel);
+    const val = this.getChannelValue(channel);
+    return new Intl.NumberFormat(locale, options).format(val);
+  }
+  getChannelFormatOptions(channel) {
+    switch (channel) {
+      case "lightness":
+      case "a":
+      case "b":
+      case "alpha":
+        return { style: "decimal", maximumFractionDigits: 4 };
+      default:
+        throw new Error("Unknown color channel: " + channel);
+    }
+  }
+  getChannelRange(channel) {
+    switch (channel) {
+      case "lightness":
+        return { minValue: 0, maxValue: 1, step: 1e-3, pageSize: 0.05 };
+      case "a":
+      case "b":
+        return { minValue: -0.4, maxValue: 0.4, step: 1e-3, pageSize: 0.02 };
+      case "alpha":
+        return { minValue: 0, maxValue: 1, step: 0.01, pageSize: 0.1 };
+      default:
+        throw new Error("Unknown color channel: " + channel);
+    }
+  }
+  toJSON() {
+    return { l: this.lightness, a: this.a, b: this.b, alpha: this.alpha };
+  }
+  getFormat() {
+    return "oklab";
+  }
+  getChannels() {
+    return _OklabColor.colorChannels;
+  }
+  isEqual(color) {
+    if (color.getFormat() !== "oklab") return super.isEqual(color);
+    const o = color;
+    return this.lightness === o.lightness && this.a === o.a && this.b === o.b && this.alpha === o.alpha;
+  }
+};
+__publicField(_OklabColor, "colorChannels", ["lightness", "a", "b"]);
+var OklabColor = _OklabColor;
+function formatOklabCss(L, a, b, alpha) {
+  const l = toFixedNumber(L, 4);
+  const aa = toFixedNumber(a, 4);
+  const bb = toFixedNumber(b, 4);
+  if (alpha >= 1) return `oklab(${l} ${aa} ${bb})`;
+  return `oklab(${l} ${aa} ${bb} / ${toFixedNumber(alpha, 4)})`;
+}
+var OKLCH_HEAD = /^oklch\(\s*/i;
+function parseCssNumberOrAngle(token) {
+  const t = token.trim().toLowerCase();
+  if (t === "none") return void 0;
+  if (t.endsWith("deg")) return Number.parseFloat(t);
+  if (t.endsWith("turn")) return Number.parseFloat(t) * 360;
+  if (t.endsWith("grad")) return Number.parseFloat(t) / 400 * 360;
+  if (t.endsWith("rad")) return Number.parseFloat(t) * 180 / Math.PI;
+  if (t.endsWith("%")) return Number.parseFloat(t) / 100;
+  const n = Number.parseFloat(t);
+  return Number.isFinite(n) ? n : void 0;
+}
+function parseOklchParams(inner) {
+  const [main, alphaPart] = inner.split(/\s*\/\s*/);
+  const tokens = main.trim().split(/\s+/).filter(Boolean);
+  if (tokens.length < 3) return;
+  const Lraw = parseCssNumberOrAngle(tokens[0]);
+  const Craw = parseCssNumberOrAngle(tokens[1]);
+  const Hraw = parseCssNumberOrAngle(tokens[2]);
+  if (Lraw === void 0 || Craw === void 0 || Hraw === void 0) return;
+  const L = tokens[0].trim().endsWith("%") ? Lraw : clampValue(Lraw, 0, 1);
+  const C = tokens[1].trim().endsWith("%") ? Craw * 0.5 : Craw;
+  const H = mod(Hraw, 360);
+  let alpha = 1;
+  if (alphaPart) {
+    const at = alphaPart.trim().toLowerCase();
+    if (at !== "none") {
+      const av = at.endsWith("%") ? Number.parseFloat(at) / 100 : Number.parseFloat(at);
+      if (Number.isFinite(av)) alpha = clampValue(av, 0, 1);
+    }
+  }
+  return { L, C: clampValue(C, 0, 0.5), H, alpha };
+}
+var _OklchColor = class _OklchColor extends Color {
+  constructor(lightness, hue, chroma, alpha) {
+    super();
+    __publicField(this, "lightness", lightness);
+    __publicField(this, "hue", hue);
+    __publicField(this, "chroma", chroma);
+    __publicField(this, "alpha", alpha);
+  }
+  static parse(value) {
+    if (!OKLCH_HEAD.test(value)) return;
+    const end = value.lastIndexOf(")");
+    if (end < 0) return;
+    const inner = value.slice(value.indexOf("(") + 1, end);
+    const p = parseOklchParams(inner);
+    if (!p) return;
+    return new _OklchColor(p.L, p.H, p.C, p.alpha);
+  }
+  toString(format = "css") {
+    switch (format) {
+      case "hex":
+        return this.toFormat("rgba").toString("hex");
+      case "hexa":
+        return this.toFormat("rgba").toString("hexa");
+      case "oklch":
+        return formatOklchCss(this.lightness, this.chroma, this.hue, this.alpha);
+      case "css":
+        return formatOklchCss(this.lightness, this.chroma, this.hue, this.alpha);
+      default:
+        return this.toFormat(format).toString(format);
+    }
+  }
+  toFormat(format) {
+    switch (format) {
+      case "oklch":
+        return this;
+      case "oklab":
+        return this.toOklab();
+      case "rgba":
+        return this.toRgb();
+      case "hsla":
+        return this.toRgb().toFormat("hsla");
+      case "hsba": {
+        const { a, b, L } = oklchToOklab(this.lightness, this.chroma, this.hue);
+        return oklabToHsb(L, a, b, this.alpha);
+      }
+      default:
+        throw new Error("Unsupported color conversion: oklch -> " + format);
+    }
+  }
+  toOklab() {
+    const { a, b, L } = oklchToOklab(this.lightness, this.chroma, this.hue);
+    return new OklabColor(L, a, b, toFixedNumber(this.alpha, 4));
+  }
+  toRgb() {
+    return this.toOklab().toFormat("rgba");
+  }
+  clone() {
+    return new _OklchColor(this.lightness, this.hue, this.chroma, this.alpha);
+  }
+  getChannelValue(channel) {
+    switch (channel) {
+      case "lightness":
+        return this.lightness;
+      case "hue":
+        return this.hue;
+      case "chroma":
+        return this.chroma;
+      case "alpha":
+        return this.alpha;
+      default:
+        throw new Error("Unsupported color channel: " + channel);
+    }
+  }
+  withChannelValue(channel, value) {
+    const { minValue, maxValue } = this.getChannelRange(channel);
+    let v = clampValue(value, minValue, maxValue);
+    if (channel === "hue") v = mod(v, 360);
+    switch (channel) {
+      case "lightness":
+        return new _OklchColor(v, this.hue, this.chroma, this.alpha);
+      case "hue":
+        return new _OklchColor(this.lightness, v, this.chroma, this.alpha);
+      case "chroma":
+        return new _OklchColor(this.lightness, this.hue, v, this.alpha);
+      case "alpha":
+        return new _OklchColor(this.lightness, this.hue, this.chroma, v);
+      default:
+        throw new Error("Unsupported color channel: " + channel);
+    }
+  }
+  formatChannelValue(channel, locale) {
+    const options = this.getChannelFormatOptions(channel);
+    const val = this.getChannelValue(channel);
+    return new Intl.NumberFormat(locale, options).format(val);
+  }
+  getChannelFormatOptions(channel) {
+    switch (channel) {
+      case "lightness":
+      case "chroma":
+      case "alpha":
+        return { style: "decimal", maximumFractionDigits: 4 };
+      case "hue":
+        return { style: "unit", unit: "degree", unitDisplay: "narrow" };
+      default:
+        throw new Error("Unknown color channel: " + channel);
+    }
+  }
+  getChannelRange(channel) {
+    switch (channel) {
+      case "lightness":
+        return { minValue: 0, maxValue: 1, step: 1e-3, pageSize: 0.05 };
+      case "hue":
+        return { minValue: 0, maxValue: 360, step: 0.01, pageSize: 15 };
+      case "chroma":
+        return { minValue: 0, maxValue: 0.5, step: 1e-3, pageSize: 0.02 };
+      case "alpha":
+        return { minValue: 0, maxValue: 1, step: 0.01, pageSize: 0.1 };
+      default:
+        throw new Error("Unknown color channel: " + channel);
+    }
+  }
+  toJSON() {
+    return { l: this.lightness, h: this.hue, c: this.chroma, alpha: this.alpha };
+  }
+  getFormat() {
+    return "oklch";
+  }
+  getChannels() {
+    return _OklchColor.colorChannels;
+  }
+  isEqual(color) {
+    if (color.getFormat() !== "oklch") return super.isEqual(color);
+    const o = color;
+    return this.lightness === o.lightness && this.hue === o.hue && this.chroma === o.chroma && this.alpha === o.alpha;
+  }
+};
+__publicField(_OklchColor, "colorChannels", ["lightness", "hue", "chroma"]);
+var OklchColor = _OklchColor;
+function formatOklchCss(L, C, H, alpha) {
+  const l = toFixedNumber(L, 4);
+  const c = toFixedNumber(C, 4);
+  const h = toFixedNumber(H, 2);
+  if (alpha >= 1) return `oklch(${l} ${c} ${h})`;
+  return `oklch(${l} ${c} ${h} / ${toFixedNumber(alpha, 4)})`;
+}
+export {
+  OklabColor,
+  OklchColor,
+  parseOklabParams,
+  parseOklchParams
+};

package/dist/oklab-math.d.mts

@@ -0,0 +1,47 @@
+/**
+ * OKLab / linear sRGB conversion (Björn Ottosson / CSS Color 4).
+ * https://bottosson.github.io/posts/oklab/
+ */
+interface LinearRgb {
+    r: number;
+    g: number;
+    b: number;
+}
+interface Oklab {
+    L: number;
+    a: number;
+    b: number;
+}
+declare function srgbChannelToLinear(c: number): number;
+declare function linearChannelToSrgb(c: number): number;
+declare function srgbToLinearRgb(r255: number, g255: number, b255: number): LinearRgb;
+declare function linearRgbToSrgb({ r, g, b }: LinearRgb): {
+    r: number;
+    g: number;
+    b: number;
+};
+declare function linearRgbToOklab({ r, g, b }: LinearRgb): Oklab;
+declare function oklabToLinearRgb(L: number, a: number, b: number): LinearRgb;
+declare function oklchToOklab(L: number, C: number, Hdeg: number): Oklab;
+declare function oklabToOklch(L: number, a: number, b: number): {
+    L: number;
+    C: number;
+    H: number;
+};
+declare function isLinearRgbInSrgbGamut({ r, g, b }: LinearRgb, eps?: number): boolean;
+/** Convert Display P3 linear RGB to linear sRGB via XYZ D65. */
+declare function linearDisplayP3ToLinearSrgb(r: number, g: number, b: number): LinearRgb;
+/**
+ * HSV (0-360, 0-1, 0-1) → RGB (0-1).
+ * Standard HSV-to-RGB conversion; the resulting RGB values are in whichever
+ * gamut the caller considers them to be (sRGB or Display P3).
+ */
+declare function hsvToRgb(h: number, s: number, v: number): [number, number, number];
+/**
+ * Check whether an HSV color (interpreted in the Display P3 gamut) falls
+ * inside the sRGB gamut. This is how Chrome DevTools draws the sRGB boundary
+ * on the color picker when in oklch/oklab mode.
+ */
+declare function isDisplayP3HsvInSrgbGamut(h: number, s: number, v: number, eps?: number): boolean;
+
+export { type LinearRgb, type Oklab, hsvToRgb, isDisplayP3HsvInSrgbGamut, isLinearRgbInSrgbGamut, linearChannelToSrgb, linearDisplayP3ToLinearSrgb, linearRgbToOklab, linearRgbToSrgb, oklabToLinearRgb, oklabToOklch, oklchToOklab, srgbChannelToLinear, srgbToLinearRgb };

package/dist/oklab-math.d.ts

@@ -0,0 +1,47 @@
+/**
+ * OKLab / linear sRGB conversion (Björn Ottosson / CSS Color 4).
+ * https://bottosson.github.io/posts/oklab/
+ */
+interface LinearRgb {
+    r: number;
+    g: number;
+    b: number;
+}
+interface Oklab {
+    L: number;
+    a: number;
+    b: number;
+}
+declare function srgbChannelToLinear(c: number): number;
+declare function linearChannelToSrgb(c: number): number;
+declare function srgbToLinearRgb(r255: number, g255: number, b255: number): LinearRgb;
+declare function linearRgbToSrgb({ r, g, b }: LinearRgb): {
+    r: number;
+    g: number;
+    b: number;
+};
+declare function linearRgbToOklab({ r, g, b }: LinearRgb): Oklab;
+declare function oklabToLinearRgb(L: number, a: number, b: number): LinearRgb;
+declare function oklchToOklab(L: number, C: number, Hdeg: number): Oklab;
+declare function oklabToOklch(L: number, a: number, b: number): {
+    L: number;
+    C: number;
+    H: number;
+};
+declare function isLinearRgbInSrgbGamut({ r, g, b }: LinearRgb, eps?: number): boolean;
+/** Convert Display P3 linear RGB to linear sRGB via XYZ D65. */
+declare function linearDisplayP3ToLinearSrgb(r: number, g: number, b: number): LinearRgb;
+/**
+ * HSV (0-360, 0-1, 0-1) → RGB (0-1).
+ * Standard HSV-to-RGB conversion; the resulting RGB values are in whichever
+ * gamut the caller considers them to be (sRGB or Display P3).
+ */
+declare function hsvToRgb(h: number, s: number, v: number): [number, number, number];
+/**
+ * Check whether an HSV color (interpreted in the Display P3 gamut) falls
+ * inside the sRGB gamut. This is how Chrome DevTools draws the sRGB boundary
+ * on the color picker when in oklch/oklab mode.
+ */
+declare function isDisplayP3HsvInSrgbGamut(h: number, s: number, v: number, eps?: number): boolean;
+
+export { type LinearRgb, type Oklab, hsvToRgb, isDisplayP3HsvInSrgbGamut, isLinearRgbInSrgbGamut, linearChannelToSrgb, linearDisplayP3ToLinearSrgb, linearRgbToOklab, linearRgbToSrgb, oklabToLinearRgb, oklabToOklch, oklchToOklab, srgbChannelToLinear, srgbToLinearRgb };

package/dist/oklab-math.js

@@ -0,0 +1,167 @@
+"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/oklab-math.ts
+var oklab_math_exports = {};
+__export(oklab_math_exports, {
+  hsvToRgb: () => hsvToRgb,
+  isDisplayP3HsvInSrgbGamut: () => isDisplayP3HsvInSrgbGamut,
+  isLinearRgbInSrgbGamut: () => isLinearRgbInSrgbGamut,
+  linearChannelToSrgb: () => linearChannelToSrgb,
+  linearDisplayP3ToLinearSrgb: () => linearDisplayP3ToLinearSrgb,
+  linearRgbToOklab: () => linearRgbToOklab,
+  linearRgbToSrgb: () => linearRgbToSrgb,
+  oklabToLinearRgb: () => oklabToLinearRgb,
+  oklabToOklch: () => oklabToOklch,
+  oklchToOklab: () => oklchToOklab,
+  srgbChannelToLinear: () => srgbChannelToLinear,
+  srgbToLinearRgb: () => srgbToLinearRgb
+});
+module.exports = __toCommonJS(oklab_math_exports);
+function srgbChannelToLinear(c) {
+  return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+}
+function linearChannelToSrgb(c) {
+  return c <= 31308e-7 ? 12.92 * c : 1.055 * c ** (1 / 2.4) - 0.055;
+}
+function srgbToLinearRgb(r255, g255, b255) {
+  return {
+    r: srgbChannelToLinear(r255 / 255),
+    g: srgbChannelToLinear(g255 / 255),
+    b: srgbChannelToLinear(b255 / 255)
+  };
+}
+function linearRgbToSrgb({ r, g, b }) {
+  return {
+    r: Math.round(clamp01(linearChannelToSrgb(r)) * 255),
+    g: Math.round(clamp01(linearChannelToSrgb(g)) * 255),
+    b: Math.round(clamp01(linearChannelToSrgb(b)) * 255)
+  };
+}
+function clamp01(x) {
+  return x < 0 ? 0 : x > 1 ? 1 : x;
+}
+function linearRgbToOklab({ r, g, b }) {
+  const l = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b;
+  const m = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b;
+  const s = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b;
+  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_
+  };
+}
+function oklabToLinearRgb(L, a, b) {
+  const l_ = L + 0.3963377774 * a + 0.2158037573 * b;
+  const m_ = L - 0.1055613458 * a - 0.0638541728 * b;
+  const s_ = L - 0.0894841775 * a - 1.291485548 * b;
+  const l = l_ * l_ * l_;
+  const m = m_ * m_ * m_;
+  const s = s_ * s_ * s_;
+  return {
+    r: 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
+    g: -1.2684380046 * l + 2.6097574011 * m - 0.341319396 * s,
+    b: -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s
+  };
+}
+function oklchToOklab(L, C, Hdeg) {
+  const h = Hdeg * Math.PI / 180;
+  return {
+    L,
+    a: C * Math.cos(h),
+    b: C * Math.sin(h)
+  };
+}
+function oklabToOklch(L, a, b) {
+  const C = Math.sqrt(a * a + b * b);
+  let H = Math.atan2(b, a) * 180 / Math.PI;
+  if (H < 0) H += 360;
+  return { L, C, H };
+}
+function isLinearRgbInSrgbGamut({ r, g, b }, eps = 1e-3) {
+  return r >= -eps && r <= 1 + eps && g >= -eps && g <= 1 + eps && b >= -eps && b <= 1 + eps;
+}
+function linearDisplayP3ToLinearSrgb(r, g, b) {
+  const x = 0.4865709486482162 * r + 0.26566769316909306 * g + 0.1982172852343625 * b;
+  const y = 0.2289745640697488 * r + 0.6917385218365064 * g + 0.079286914093745 * b;
+  const z = 0 * r + 0.04511338185890264 * g + 1.043944368900976 * b;
+  return {
+    r: 3.2404541621141054 * x - 1.5371385940306088 * y - 0.4985314095560158 * z,
+    g: -0.9692660305051868 * x + 1.8760108454466942 * y + 0.0415560175303498 * z,
+    b: 0.0556434309591147 * x - 0.2039769598730574 * y + 1.0572251882231791 * z
+  };
+}
+function hsvToRgb(h, s, v) {
+  const c = v * s;
+  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = v - c;
+  let r1 = 0, g1 = 0, b1 = 0;
+  if (h < 60) {
+    r1 = c;
+    g1 = x;
+    b1 = 0;
+  } else if (h < 120) {
+    r1 = x;
+    g1 = c;
+    b1 = 0;
+  } else if (h < 180) {
+    r1 = 0;
+    g1 = c;
+    b1 = x;
+  } else if (h < 240) {
+    r1 = 0;
+    g1 = x;
+    b1 = c;
+  } else if (h < 300) {
+    r1 = x;
+    g1 = 0;
+    b1 = c;
+  } else {
+    r1 = c;
+    g1 = 0;
+    b1 = x;
+  }
+  return [r1 + m, g1 + m, b1 + m];
+}
+function isDisplayP3HsvInSrgbGamut(h, s, v, eps = 1e-3) {
+  const [r, g, b] = hsvToRgb(h, s, v);
+  const lr = srgbChannelToLinear(r);
+  const lg = srgbChannelToLinear(g);
+  const lb = srgbChannelToLinear(b);
+  const srgb = linearDisplayP3ToLinearSrgb(lr, lg, lb);
+  return isLinearRgbInSrgbGamut(srgb, eps);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  hsvToRgb,
+  isDisplayP3HsvInSrgbGamut,
+  isLinearRgbInSrgbGamut,
+  linearChannelToSrgb,
+  linearDisplayP3ToLinearSrgb,
+  linearRgbToOklab,
+  linearRgbToSrgb,
+  oklabToLinearRgb,
+  oklabToOklch,
+  oklchToOklab,
+  srgbChannelToLinear,
+  srgbToLinearRgb
+});