@choice-ui/react 1.7.6 → 1.7.7

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/hex/rgb2hex.js

@@ -0,0 +1,31 @@
+import "../../utils/type.js";
+import unpack from "../../utils/unpack.js";
+import last from "../../utils/last.js";
+const { round } = Math;
+const rgb2hex = (...args) => {
+  let [r, g, b, a] = unpack(args, "rgba");
+  let mode = last(args) || "auto";
+  if (a === void 0) a = 1;
+  if (mode === "auto") {
+    mode = a < 1 ? "rgba" : "rgb";
+  }
+  r = round(r);
+  g = round(g);
+  b = round(b);
+  const u = r << 16 | g << 8 | b;
+  let str = "000000" + u.toString(16);
+  str = str.substr(str.length - 6);
+  let hxa = "0" + round(a * 255).toString(16);
+  hxa = hxa.substr(hxa.length - 2);
+  switch (mode.toLowerCase()) {
+    case "rgba":
+      return `#${str}${hxa}`;
+    case "argb":
+      return `#${hxa}${str}`;
+    default:
+      return `#${str}`;
+  }
+};
+export {
+  rgb2hex as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/hsi/hsi2rgb.js

@@ -0,0 +1,36 @@
+import { TWOPI, PITHIRD } from "../../utils/index.js";
+import unpack from "../../utils/unpack.js";
+import limit from "../../utils/limit.js";
+const { cos } = Math;
+const hsi2rgb = (...args) => {
+  args = unpack(args, "hsi");
+  let [h, s, i] = args;
+  let r, g, b;
+  if (isNaN(h)) h = 0;
+  if (isNaN(s)) s = 0;
+  if (h > 360) h -= 360;
+  if (h < 0) h += 360;
+  h /= 360;
+  if (h < 1 / 3) {
+    b = (1 - s) / 3;
+    r = (1 + s * cos(TWOPI * h) / cos(PITHIRD - TWOPI * h)) / 3;
+    g = 1 - (b + r);
+  } else if (h < 2 / 3) {
+    h -= 1 / 3;
+    r = (1 - s) / 3;
+    g = (1 + s * cos(TWOPI * h) / cos(PITHIRD - TWOPI * h)) / 3;
+    b = 1 - (r + g);
+  } else {
+    h -= 2 / 3;
+    g = (1 - s) / 3;
+    b = (1 + s * cos(TWOPI * h) / cos(PITHIRD - TWOPI * h)) / 3;
+    r = 1 - (g + b);
+  }
+  r = limit(i * r * 3);
+  g = limit(i * g * 3);
+  b = limit(i * b * 3);
+  return [r * 255, g * 255, b * 255, args.length > 3 ? args[3] : 1];
+};
+export {
+  hsi2rgb as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/hsi/index.js

@@ -0,0 +1,25 @@
+import type from "../../utils/type.js";
+import unpack from "../../utils/unpack.js";
+import chroma from "../../chroma.js";
+import Color from "../../Color.js";
+import input from "../input.js";
+import hsi2rgb from "./hsi2rgb.js";
+import rgb2hsi from "./rgb2hsi.js";
+Color.prototype.hsi = function() {
+  return rgb2hsi(this._rgb);
+};
+const hsi = (...args) => new Color(...args, "hsi");
+chroma.hsi = hsi;
+input.format.hsi = hsi2rgb;
+input.autodetect.push({
+  p: 2,
+  test: (...args) => {
+    args = unpack(args, "hsi");
+    if (type(args) === "array" && args.length === 3) {
+      return "hsi";
+    }
+  }
+});
+export {
+  hsi
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/hsi/rgb2hsi.js

@@ -0,0 +1,28 @@
+import { TWOPI } from "../../utils/index.js";
+import unpack from "../../utils/unpack.js";
+const { min, sqrt, acos } = Math;
+const rgb2hsi = (...args) => {
+  let [r, g, b] = unpack(args, "rgb");
+  r /= 255;
+  g /= 255;
+  b /= 255;
+  let h;
+  const min_ = min(r, g, b);
+  const i = (r + g + b) / 3;
+  const s = i > 0 ? 1 - min_ / i : 0;
+  if (s === 0) {
+    h = NaN;
+  } else {
+    h = (r - g + (r - b)) / 2;
+    h /= sqrt((r - g) * (r - g) + (r - b) * (g - b));
+    h = acos(h);
+    if (b > g) {
+      h = TWOPI - h;
+    }
+    h /= TWOPI;
+  }
+  return [h * 360, s, i];
+};
+export {
+  rgb2hsi as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/hsl/hsl2rgb.js

@@ -0,0 +1,35 @@
+import "../../utils/type.js";
+import unpack from "../../utils/unpack.js";
+const hsl2rgb = (...args) => {
+  args = unpack(args, "hsl");
+  const [h, s, l] = args;
+  let r, g, b;
+  if (s === 0) {
+    r = g = b = l * 255;
+  } else {
+    const t3 = [0, 0, 0];
+    const c = [0, 0, 0];
+    const t2 = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const t1 = 2 * l - t2;
+    const h_ = h / 360;
+    t3[0] = h_ + 1 / 3;
+    t3[1] = h_;
+    t3[2] = h_ - 1 / 3;
+    for (let i = 0; i < 3; i++) {
+      if (t3[i] < 0) t3[i] += 1;
+      if (t3[i] > 1) t3[i] -= 1;
+      if (6 * t3[i] < 1) c[i] = t1 + (t2 - t1) * 6 * t3[i];
+      else if (2 * t3[i] < 1) c[i] = t2;
+      else if (3 * t3[i] < 2) c[i] = t1 + (t2 - t1) * (2 / 3 - t3[i]) * 6;
+      else c[i] = t1;
+    }
+    [r, g, b] = [c[0] * 255, c[1] * 255, c[2] * 255];
+  }
+  if (args.length > 3) {
+    return [r, g, b, args[3]];
+  }
+  return [r, g, b, 1];
+};
+export {
+  hsl2rgb as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/hsl/index.js

@@ -0,0 +1,25 @@
+import type from "../../utils/type.js";
+import unpack from "../../utils/unpack.js";
+import chroma from "../../chroma.js";
+import Color from "../../Color.js";
+import input from "../input.js";
+import hsl2rgb from "./hsl2rgb.js";
+import rgb2hsl from "./rgb2hsl.js";
+Color.prototype.hsl = function() {
+  return rgb2hsl(this._rgb);
+};
+const hsl = (...args) => new Color(...args, "hsl");
+chroma.hsl = hsl;
+input.format.hsl = hsl2rgb;
+input.autodetect.push({
+  p: 2,
+  test: (...args) => {
+    args = unpack(args, "hsl");
+    if (type(args) === "array" && args.length === 3) {
+      return "hsl";
+    }
+  }
+});
+export {
+  hsl
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/hsl/rgb2hsl.js

@@ -0,0 +1,29 @@
+import { max, min } from "../../utils/index.js";
+import unpack from "../../utils/unpack.js";
+const rgb2hsl = (...args) => {
+  args = unpack(args, "rgba");
+  let [r, g, b] = args;
+  r /= 255;
+  g /= 255;
+  b /= 255;
+  const minRgb = min(r, g, b);
+  const maxRgb = max(r, g, b);
+  const l = (maxRgb + minRgb) / 2;
+  let s, h;
+  if (maxRgb === minRgb) {
+    s = 0;
+    h = Number.NaN;
+  } else {
+    s = l < 0.5 ? (maxRgb - minRgb) / (maxRgb + minRgb) : (maxRgb - minRgb) / (2 - maxRgb - minRgb);
+  }
+  if (r == maxRgb) h = (g - b) / (maxRgb - minRgb);
+  else if (g == maxRgb) h = 2 + (b - r) / (maxRgb - minRgb);
+  else if (b == maxRgb) h = 4 + (r - g) / (maxRgb - minRgb);
+  h *= 60;
+  if (h < 0) h += 360;
+  if (args.length > 3 && args[3] !== void 0) return [h, s, l, args[3]];
+  return [h, s, l];
+};
+export {
+  rgb2hsl as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/hsv/hsv2rgb.js

@@ -0,0 +1,46 @@
+import "../../utils/type.js";
+import unpack from "../../utils/unpack.js";
+const { floor } = Math;
+const hsv2rgb = (...args) => {
+  args = unpack(args, "hsv");
+  let [h, s, v] = args;
+  let r, g, b;
+  v *= 255;
+  if (s === 0) {
+    r = g = b = v;
+  } else {
+    if (h === 360) h = 0;
+    if (h > 360) h -= 360;
+    if (h < 0) h += 360;
+    h /= 60;
+    const i = floor(h);
+    const f = h - i;
+    const p = v * (1 - s);
+    const q = v * (1 - s * f);
+    const t = v * (1 - s * (1 - f));
+    switch (i) {
+      case 0:
+        [r, g, b] = [v, t, p];
+        break;
+      case 1:
+        [r, g, b] = [q, v, p];
+        break;
+      case 2:
+        [r, g, b] = [p, v, t];
+        break;
+      case 3:
+        [r, g, b] = [p, q, v];
+        break;
+      case 4:
+        [r, g, b] = [t, p, v];
+        break;
+      case 5:
+        [r, g, b] = [v, p, q];
+        break;
+    }
+  }
+  return [r, g, b, args.length > 3 ? args[3] : 1];
+};
+export {
+  hsv2rgb as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/hsv/index.js

@@ -0,0 +1,25 @@
+import type from "../../utils/type.js";
+import unpack from "../../utils/unpack.js";
+import chroma from "../../chroma.js";
+import Color from "../../Color.js";
+import input from "../input.js";
+import hsv2rgb from "./hsv2rgb.js";
+import rgb2hsl from "./rgb2hsv.js";
+Color.prototype.hsv = function() {
+  return rgb2hsl(this._rgb);
+};
+const hsv = (...args) => new Color(...args, "hsv");
+chroma.hsv = hsv;
+input.format.hsv = hsv2rgb;
+input.autodetect.push({
+  p: 2,
+  test: (...args) => {
+    args = unpack(args, "hsv");
+    if (type(args) === "array" && args.length === 3) {
+      return "hsv";
+    }
+  }
+});
+export {
+  hsv
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/hsv/rgb2hsv.js

@@ -0,0 +1,27 @@
+import "../../utils/type.js";
+import unpack from "../../utils/unpack.js";
+const { min, max } = Math;
+const rgb2hsl = (...args) => {
+  args = unpack(args, "rgb");
+  let [r, g, b] = args;
+  const min_ = min(r, g, b);
+  const max_ = max(r, g, b);
+  const delta = max_ - min_;
+  let h, s, v;
+  v = max_ / 255;
+  if (max_ === 0) {
+    h = Number.NaN;
+    s = 0;
+  } else {
+    s = delta / max_;
+    if (r === max_) h = (g - b) / delta;
+    if (g === max_) h = 2 + (b - r) / delta;
+    if (b === max_) h = 4 + (r - g) / delta;
+    h *= 60;
+    if (h < 0) h += 360;
+  }
+  return [h, s, v];
+};
+export {
+  rgb2hsl as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/input.js

@@ -0,0 +1,7 @@
+const input = {
+  format: {},
+  autodetect: []
+};
+export {
+  input as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/lab/index.js

@@ -0,0 +1,28 @@
+import type from "../../utils/type.js";
+import unpack from "../../utils/unpack.js";
+import chroma from "../../chroma.js";
+import Color from "../../Color.js";
+import input from "../input.js";
+import lab2rgb from "./lab2rgb.js";
+import rgb2lab from "./rgb2lab.js";
+import { setLabWhitePoint, getLabWhitePoint } from "./lab-constants.js";
+Color.prototype.lab = function() {
+  return rgb2lab(this._rgb);
+};
+const lab = (...args) => new Color(...args, "lab");
+Object.assign(chroma, { lab, getLabWhitePoint, setLabWhitePoint });
+input.format.lab = lab2rgb;
+input.autodetect.push({
+  p: 2,
+  test: (...args) => {
+    args = unpack(args, "lab");
+    if (type(args) === "array" && args.length === 3) {
+      return "lab";
+    }
+  }
+});
+export {
+  getLabWhitePoint,
+  lab,
+  setLabWhitePoint
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/lab/lab-constants.js

@@ -0,0 +1,106 @@
+const labConstants = {
+  // Corresponds roughly to RGB brighter/darker
+  Kn: 18,
+  // D65 standard referent
+  labWhitePoint: "d65",
+  Xn: 0.95047,
+  Yn: 1,
+  Zn: 1.08883,
+  kE: 216 / 24389,
+  kKE: 8,
+  kK: 24389 / 27,
+  RefWhiteRGB: {
+    // sRGB
+    X: 0.95047,
+    Y: 1,
+    Z: 1.08883
+  },
+  MtxRGB2XYZ: {
+    m00: 0.4124564390896922,
+    m01: 0.21267285140562253,
+    m02: 0.0193338955823293,
+    m10: 0.357576077643909,
+    m11: 0.715152155287818,
+    m12: 0.11919202588130297,
+    m20: 0.18043748326639894,
+    m21: 0.07217499330655958,
+    m22: 0.9503040785363679
+  },
+  MtxXYZ2RGB: {
+    m00: 3.2404541621141045,
+    m01: -0.9692660305051868,
+    m02: 0.055643430959114726,
+    m10: -1.5371385127977166,
+    m11: 1.8760108454466942,
+    m12: -0.2040259135167538,
+    m20: -0.498531409556016,
+    m21: 0.041556017530349834,
+    m22: 1.0572251882231791
+  },
+  // used in rgb2xyz
+  As: 0.9414285350000001,
+  Bs: 1.040417467,
+  Cs: 1.089532651,
+  MtxAdaptMa: {
+    m00: 0.8951,
+    m01: -0.7502,
+    m02: 0.0389,
+    m10: 0.2664,
+    m11: 1.7135,
+    m12: -0.0685,
+    m20: -0.1614,
+    m21: 0.0367,
+    m22: 1.0296
+  },
+  MtxAdaptMaI: {
+    m00: 0.9869929054667123,
+    m01: 0.43230526972339456,
+    m02: -0.008528664575177328,
+    m10: -0.14705425642099013,
+    m11: 0.5183602715367776,
+    m12: 0.04004282165408487,
+    m20: 0.15996265166373125,
+    m21: 0.0492912282128556,
+    m22: 0.9684866957875502
+  }
+};
+const ILLUMINANTS = /* @__PURE__ */ new Map([
+  // ASTM E308-01
+  ["a", [1.0985, 0.35585]],
+  // Wyszecki & Stiles, p. 769
+  ["b", [1.0985, 0.35585]],
+  // C ASTM E308-01
+  ["c", [0.98074, 1.18232]],
+  // D50 (ASTM E308-01)
+  ["d50", [0.96422, 0.82521]],
+  // D55 (ASTM E308-01)
+  ["d55", [0.95682, 0.92149]],
+  // D65 (ASTM E308-01)
+  ["d65", [0.95047, 1.08883]],
+  // E (ASTM E308-01)
+  ["e", [1, 1, 1]],
+  // F2 (ASTM E308-01)
+  ["f2", [0.99186, 0.67393]],
+  // F7 (ASTM E308-01)
+  ["f7", [0.95041, 1.08747]],
+  // F11 (ASTM E308-01)
+  ["f11", [1.00962, 0.6435]],
+  ["icc", [0.96422, 0.82521]]
+]);
+function setLabWhitePoint(name) {
+  const ill = ILLUMINANTS.get(String(name).toLowerCase());
+  if (!ill) {
+    throw new Error("unknown Lab illuminant " + name);
+  }
+  labConstants.labWhitePoint = name;
+  labConstants.Xn = ill[0];
+  labConstants.Zn = ill[1];
+}
+function getLabWhitePoint() {
+  return labConstants.labWhitePoint;
+}
+export {
+  labConstants as default,
+  getLabWhitePoint,
+  setLabWhitePoint
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/lab/lab2rgb.js

@@ -0,0 +1,59 @@
+import labConstants from "./lab-constants.js";
+import "../../utils/type.js";
+import unpack from "../../utils/unpack.js";
+const lab2rgb = (...args) => {
+  args = unpack(args, "lab");
+  const [L, a, b] = args;
+  const [x, y, z] = lab2xyz(L, a, b);
+  const [r, g, b_] = xyz2rgb(x, y, z);
+  return [r, g, b_, args.length > 3 ? args[3] : 1];
+};
+const lab2xyz = (L, a, b) => {
+  const { kE, kK, kKE, Xn, Yn, Zn } = labConstants;
+  const fy = (L + 16) / 116;
+  const fx = 2e-3 * a + fy;
+  const fz = fy - 5e-3 * b;
+  const fx3 = fx * fx * fx;
+  const fz3 = fz * fz * fz;
+  const xr = fx3 > kE ? fx3 : (116 * fx - 16) / kK;
+  const yr = L > kKE ? Math.pow((L + 16) / 116, 3) : L / kK;
+  const zr = fz3 > kE ? fz3 : (116 * fz - 16) / kK;
+  const x = xr * Xn;
+  const y = yr * Yn;
+  const z = zr * Zn;
+  return [x, y, z];
+};
+const compand = (linear) => {
+  const sign = Math.sign(linear);
+  linear = Math.abs(linear);
+  return (linear <= 31308e-7 ? linear * 12.92 : 1.055 * Math.pow(linear, 1 / 2.4) - 0.055) * sign;
+};
+const xyz2rgb = (x, y, z) => {
+  const { MtxAdaptMa, MtxAdaptMaI, MtxXYZ2RGB, RefWhiteRGB, Xn, Yn, Zn } = labConstants;
+  const As = Xn * MtxAdaptMa.m00 + Yn * MtxAdaptMa.m10 + Zn * MtxAdaptMa.m20;
+  const Bs = Xn * MtxAdaptMa.m01 + Yn * MtxAdaptMa.m11 + Zn * MtxAdaptMa.m21;
+  const Cs = Xn * MtxAdaptMa.m02 + Yn * MtxAdaptMa.m12 + Zn * MtxAdaptMa.m22;
+  const Ad = RefWhiteRGB.X * MtxAdaptMa.m00 + RefWhiteRGB.Y * MtxAdaptMa.m10 + RefWhiteRGB.Z * MtxAdaptMa.m20;
+  const Bd = RefWhiteRGB.X * MtxAdaptMa.m01 + RefWhiteRGB.Y * MtxAdaptMa.m11 + RefWhiteRGB.Z * MtxAdaptMa.m21;
+  const Cd = RefWhiteRGB.X * MtxAdaptMa.m02 + RefWhiteRGB.Y * MtxAdaptMa.m12 + RefWhiteRGB.Z * MtxAdaptMa.m22;
+  const X1 = (x * MtxAdaptMa.m00 + y * MtxAdaptMa.m10 + z * MtxAdaptMa.m20) * (Ad / As);
+  const Y1 = (x * MtxAdaptMa.m01 + y * MtxAdaptMa.m11 + z * MtxAdaptMa.m21) * (Bd / Bs);
+  const Z1 = (x * MtxAdaptMa.m02 + y * MtxAdaptMa.m12 + z * MtxAdaptMa.m22) * (Cd / Cs);
+  const X2 = X1 * MtxAdaptMaI.m00 + Y1 * MtxAdaptMaI.m10 + Z1 * MtxAdaptMaI.m20;
+  const Y2 = X1 * MtxAdaptMaI.m01 + Y1 * MtxAdaptMaI.m11 + Z1 * MtxAdaptMaI.m21;
+  const Z2 = X1 * MtxAdaptMaI.m02 + Y1 * MtxAdaptMaI.m12 + Z1 * MtxAdaptMaI.m22;
+  const r = compand(
+    X2 * MtxXYZ2RGB.m00 + Y2 * MtxXYZ2RGB.m10 + Z2 * MtxXYZ2RGB.m20
+  );
+  const g = compand(
+    X2 * MtxXYZ2RGB.m01 + Y2 * MtxXYZ2RGB.m11 + Z2 * MtxXYZ2RGB.m21
+  );
+  const b = compand(
+    X2 * MtxXYZ2RGB.m02 + Y2 * MtxXYZ2RGB.m12 + Z2 * MtxXYZ2RGB.m22
+  );
+  return [r * 255, g * 255, b * 255];
+};
+export {
+  lab2rgb as default,
+  xyz2rgb
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/lab/rgb2lab.js

@@ -0,0 +1,51 @@
+import labConstants from "./lab-constants.js";
+import "../../utils/type.js";
+import unpack from "../../utils/unpack.js";
+const rgb2lab = (...args) => {
+  const [r, g, b, ...rest] = unpack(args, "rgb");
+  const [x, y, z] = rgb2xyz(r, g, b);
+  const [L, a, b_] = xyz2lab(x, y, z);
+  return [L, a, b_, ...rest.length > 0 && rest[0] < 1 ? [rest[0]] : []];
+};
+function xyz2lab(x, y, z) {
+  const { Xn, Yn, Zn, kE, kK } = labConstants;
+  const xr = x / Xn;
+  const yr = y / Yn;
+  const zr = z / Zn;
+  const fx = xr > kE ? Math.pow(xr, 1 / 3) : (kK * xr + 16) / 116;
+  const fy = yr > kE ? Math.pow(yr, 1 / 3) : (kK * yr + 16) / 116;
+  const fz = zr > kE ? Math.pow(zr, 1 / 3) : (kK * zr + 16) / 116;
+  return [116 * fy - 16, 500 * (fx - fy), 200 * (fy - fz)];
+}
+function gammaAdjustSRGB(companded) {
+  const sign = Math.sign(companded);
+  companded = Math.abs(companded);
+  const linear = companded <= 0.04045 ? companded / 12.92 : Math.pow((companded + 0.055) / 1.055, 2.4);
+  return linear * sign;
+}
+const rgb2xyz = (r, g, b) => {
+  r = gammaAdjustSRGB(r / 255);
+  g = gammaAdjustSRGB(g / 255);
+  b = gammaAdjustSRGB(b / 255);
+  const { MtxRGB2XYZ, MtxAdaptMa, MtxAdaptMaI, Xn, Yn, Zn, As, Bs, Cs } = labConstants;
+  let x = r * MtxRGB2XYZ.m00 + g * MtxRGB2XYZ.m10 + b * MtxRGB2XYZ.m20;
+  let y = r * MtxRGB2XYZ.m01 + g * MtxRGB2XYZ.m11 + b * MtxRGB2XYZ.m21;
+  let z = r * MtxRGB2XYZ.m02 + g * MtxRGB2XYZ.m12 + b * MtxRGB2XYZ.m22;
+  const Ad = Xn * MtxAdaptMa.m00 + Yn * MtxAdaptMa.m10 + Zn * MtxAdaptMa.m20;
+  const Bd = Xn * MtxAdaptMa.m01 + Yn * MtxAdaptMa.m11 + Zn * MtxAdaptMa.m21;
+  const Cd = Xn * MtxAdaptMa.m02 + Yn * MtxAdaptMa.m12 + Zn * MtxAdaptMa.m22;
+  let X = x * MtxAdaptMa.m00 + y * MtxAdaptMa.m10 + z * MtxAdaptMa.m20;
+  let Y = x * MtxAdaptMa.m01 + y * MtxAdaptMa.m11 + z * MtxAdaptMa.m21;
+  let Z = x * MtxAdaptMa.m02 + y * MtxAdaptMa.m12 + z * MtxAdaptMa.m22;
+  X *= Ad / As;
+  Y *= Bd / Bs;
+  Z *= Cd / Cs;
+  x = X * MtxAdaptMaI.m00 + Y * MtxAdaptMaI.m10 + Z * MtxAdaptMaI.m20;
+  y = X * MtxAdaptMaI.m01 + Y * MtxAdaptMaI.m11 + Z * MtxAdaptMaI.m21;
+  z = X * MtxAdaptMaI.m02 + Y * MtxAdaptMaI.m12 + Z * MtxAdaptMaI.m22;
+  return [x, y, z];
+};
+export {
+  rgb2lab as default,
+  rgb2xyz
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/lch/hcl2rgb.js

@@ -0,0 +1,10 @@
+import { reverse3 } from "../../utils/index.js";
+import lch2rgb from "./lch2rgb.js";
+import unpack from "../../utils/unpack.js";
+const hcl2rgb = (...args) => {
+  const hcl = reverse3(unpack(args, "hcl"));
+  return lch2rgb(...hcl);
+};
+export {
+  hcl2rgb as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/lch/index.js

@@ -0,0 +1,35 @@
+import { reverse3 } from "../../utils/index.js";
+import chroma from "../../chroma.js";
+import Color from "../../Color.js";
+import input from "../input.js";
+import lch2rgb from "./lch2rgb.js";
+import hcl2rgb from "./hcl2rgb.js";
+import rgb2lch from "./rgb2lch.js";
+import unpack from "../../utils/unpack.js";
+import type from "../../utils/type.js";
+Color.prototype.lch = function() {
+  return rgb2lch(this._rgb);
+};
+Color.prototype.hcl = function() {
+  return reverse3(rgb2lch(this._rgb));
+};
+const lch = (...args) => new Color(...args, "lch");
+const hcl = (...args) => new Color(...args, "hcl");
+Object.assign(chroma, { lch, hcl });
+input.format.lch = lch2rgb;
+input.format.hcl = hcl2rgb;
+["lch", "hcl"].forEach(
+  (m) => input.autodetect.push({
+    p: 2,
+    test: (...args) => {
+      args = unpack(args, m);
+      if (type(args) === "array" && args.length === 3) {
+        return m;
+      }
+    }
+  })
+);
+export {
+  hcl,
+  lch
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/lch/lab2lch.js

@@ -0,0 +1,13 @@
+import { RAD2DEG } from "../../utils/index.js";
+import unpack from "../../utils/unpack.js";
+const { sqrt, atan2, round } = Math;
+const lab2lch = (...args) => {
+  const [l, a, b] = unpack(args, "lab");
+  const c = sqrt(a * a + b * b);
+  let h = (atan2(b, a) * RAD2DEG + 360) % 360;
+  if (round(c * 1e4) === 0) h = Number.NaN;
+  return [l, c, h];
+};
+export {
+  lab2lch as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/lch/lch2lab.js

@@ -0,0 +1,12 @@
+import { DEG2RAD } from "../../utils/index.js";
+import unpack from "../../utils/unpack.js";
+const { sin, cos } = Math;
+const lch2lab = (...args) => {
+  let [l, c, h] = unpack(args, "lch");
+  if (isNaN(h)) h = 0;
+  h = h * DEG2RAD;
+  return [l, cos(h) * c, sin(h) * c];
+};
+export {
+  lch2lab as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/lch/lch2rgb.js

@@ -0,0 +1,14 @@
+import "../../utils/type.js";
+import unpack from "../../utils/unpack.js";
+import lch2lab from "./lch2lab.js";
+import lab2rgb from "../lab/lab2rgb.js";
+const lch2rgb = (...args) => {
+  args = unpack(args, "lch");
+  const [l, c, h] = args;
+  const [L, a, b_] = lch2lab(l, c, h);
+  const [r, g, b] = lab2rgb(L, a, b_);
+  return [r, g, b, args.length > 3 ? args[3] : 1];
+};
+export {
+  lch2rgb as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/lch/rgb2lch.js

@@ -0,0 +1,13 @@
+import "../../utils/type.js";
+import unpack from "../../utils/unpack.js";
+import rgb2lab from "../lab/rgb2lab.js";
+import lab2lch from "./lab2lch.js";
+const rgb2lch = (...args) => {
+  const [r, g, b, ...rest] = unpack(args, "rgb");
+  const [l, a, b_] = rgb2lab(r, g, b);
+  const [L, c, h] = lab2lch(l, a, b_);
+  return [L, c, h, ...rest.length > 0 && rest[0] < 1 ? [rest[0]] : []];
+};
+export {
+  rgb2lch as default
+};