@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/named/index.js

@@ -0,0 +1,26 @@
+import Color from "../../Color.js";
+import input from "../input.js";
+import type from "../../utils/type.js";
+import w3cx11 from "../../colors/w3cx11.js";
+import hex2rgb from "../hex/hex2rgb.js";
+import rgb2hex from "../hex/rgb2hex.js";
+Color.prototype.name = function() {
+  const hex = rgb2hex(this._rgb, "rgb");
+  for (let n of Object.keys(w3cx11)) {
+    if (w3cx11[n] === hex) return n.toLowerCase();
+  }
+  return hex;
+};
+input.format.named = (name) => {
+  name = name.toLowerCase();
+  if (w3cx11[name]) return hex2rgb(w3cx11[name]);
+  throw new Error("unknown color name: " + name);
+};
+input.autodetect.push({
+  p: 5,
+  test: (h, ...rest) => {
+    if (!rest.length && type(h) === "string" && w3cx11[h.toLowerCase()]) {
+      return "named";
+    }
+  }
+});

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

@@ -0,0 +1,23 @@
+import chroma from "../../chroma.js";
+import Color from "../../Color.js";
+import input from "../input.js";
+import type from "../../utils/type.js";
+import num2rgb from "./num2rgb.js";
+import rgb2num from "./rgb2num.js";
+Color.prototype.num = function() {
+  return rgb2num(this._rgb);
+};
+const num = (...args) => new Color(...args, "num");
+Object.assign(chroma, { num });
+input.format.num = num2rgb;
+input.autodetect.push({
+  p: 5,
+  test: (...args) => {
+    if (args.length === 1 && type(args[0]) === "number" && args[0] >= 0 && args[0] <= 16777215) {
+      return "num";
+    }
+  }
+});
+export {
+  num
+};

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

@@ -0,0 +1,13 @@
+import type from "../../utils/type.js";
+const num2rgb = (num) => {
+  if (type(num) == "number" && num >= 0 && num <= 16777215) {
+    const r = num >> 16;
+    const g = num >> 8 & 255;
+    const b = num & 255;
+    return [r, g, b, 1];
+  }
+  throw new Error("unknown num color: " + num);
+};
+export {
+  num2rgb as default
+};

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

@@ -0,0 +1,9 @@
+import "../../utils/type.js";
+import unpack from "../../utils/unpack.js";
+const rgb2num = (...args) => {
+  const [r, g, b] = unpack(args, "rgb");
+  return (r << 16) + (g << 8) + b;
+};
+export {
+  rgb2num as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/oklab/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 oklab2rgb from "./oklab2rgb.js";
+import rgb2oklab from "./rgb2oklab.js";
+Color.prototype.oklab = function() {
+  return rgb2oklab(this._rgb);
+};
+const oklab = (...args) => new Color(...args, "oklab");
+Object.assign(chroma, { oklab });
+input.format.oklab = oklab2rgb;
+input.autodetect.push({
+  p: 2,
+  test: (...args) => {
+    args = unpack(args, "oklab");
+    if (type(args) === "array" && args.length === 3) {
+      return "oklab";
+    }
+  }
+});
+export {
+  oklab
+};

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

@@ -0,0 +1,31 @@
+import "../../utils/type.js";
+import unpack from "../../utils/unpack.js";
+import multiplyMatrices from "../../utils/multiply-matrices.js";
+import { xyz2rgb } from "../lab/lab2rgb.js";
+const oklab2rgb = (...args) => {
+  args = unpack(args, "lab");
+  const [L, a, b, ...rest] = args;
+  const [X, Y, Z] = OKLab_to_XYZ([L, a, b]);
+  const [r, g, b_] = xyz2rgb(X, Y, Z);
+  return [r, g, b_, ...rest.length > 0 && rest[0] < 1 ? [rest[0]] : []];
+};
+function OKLab_to_XYZ(OKLab) {
+  var LMStoXYZ = [
+    [1.2268798758459243, -0.5578149944602171, 0.2813910456659647],
+    [-0.0405757452148008, 1.112286803280317, -0.0717110580655164],
+    [-0.0763729366746601, -0.4214933324022432, 1.5869240198367816]
+  ];
+  var OKLabtoLMS = [
+    [1, 0.3963377773761749, 0.2158037573099136],
+    [1, -0.1055613458156586, -0.0638541728258133],
+    [1, -0.0894841775298119, -1.2914855480194092]
+  ];
+  var LMSnl = multiplyMatrices(OKLabtoLMS, OKLab);
+  return multiplyMatrices(
+    LMStoXYZ,
+    LMSnl.map((c) => c ** 3)
+  );
+}
+export {
+  oklab2rgb as default
+};

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

@@ -0,0 +1,30 @@
+import "../../utils/type.js";
+import unpack from "../../utils/unpack.js";
+import multiplyMatrices from "../../utils/multiply-matrices.js";
+import { rgb2xyz } from "../lab/rgb2lab.js";
+const rgb2oklab = (...args) => {
+  const [r, g, b, ...rest] = unpack(args, "rgb");
+  const xyz = rgb2xyz(r, g, b);
+  const oklab = XYZ_to_OKLab(xyz);
+  return [...oklab, ...rest.length > 0 && rest[0] < 1 ? [rest[0]] : []];
+};
+function XYZ_to_OKLab(XYZ) {
+  const XYZtoLMS = [
+    [0.819022437996703, 0.3619062600528904, -0.1288737815209879],
+    [0.0329836539323885, 0.9292868615863434, 0.0361446663506424],
+    [0.0481771893596242, 0.2642395317527308, 0.6335478284694309]
+  ];
+  const LMStoOKLab = [
+    [0.210454268309314, 0.7936177747023054, -0.0040720430116193],
+    [1.9779985324311684, -2.42859224204858, 0.450593709617411],
+    [0.0259040424655478, 0.7827717124575296, -0.8086757549230774]
+  ];
+  const LMS = multiplyMatrices(XYZtoLMS, XYZ);
+  return multiplyMatrices(
+    LMStoOKLab,
+    LMS.map((c) => Math.cbrt(c))
+  );
+}
+export {
+  rgb2oklab as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/io/oklch/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 oklch2rgb from "./oklch2rgb.js";
+import rgb2oklch from "./rgb2oklch.js";
+Color.prototype.oklch = function() {
+  return rgb2oklch(this._rgb);
+};
+const oklch = (...args) => new Color(...args, "oklch");
+Object.assign(chroma, { oklch });
+input.format.oklch = oklch2rgb;
+input.autodetect.push({
+  p: 2,
+  test: (...args) => {
+    args = unpack(args, "oklch");
+    if (type(args) === "array" && args.length === 3) {
+      return "oklch";
+    }
+  }
+});
+export {
+  oklch
+};

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

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

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

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

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

@@ -0,0 +1,34 @@
+import chroma from "../../chroma.js";
+import Color from "../../Color.js";
+import input from "../input.js";
+import type from "../../utils/type.js";
+import unpack from "../../utils/unpack.js";
+const { round } = Math;
+Color.prototype.rgb = function(rnd = true) {
+  if (rnd === false) return this._rgb.slice(0, 3);
+  return this._rgb.slice(0, 3).map(round);
+};
+Color.prototype.rgba = function(rnd = true) {
+  return this._rgb.slice(0, 4).map((v, i) => {
+    return i < 3 ? rnd === false ? v : round(v) : v;
+  });
+};
+const rgb = (...args) => new Color(...args, "rgb");
+Object.assign(chroma, { rgb });
+input.format.rgb = (...args) => {
+  const rgba = unpack(args, "rgba");
+  if (rgba[3] === void 0) rgba[3] = 1;
+  return rgba;
+};
+input.autodetect.push({
+  p: 3,
+  test: (...args) => {
+    args = unpack(args, "rgba");
+    if (type(args) === "array" && (args.length === 3 || args.length === 4 && type(args[3]) == "number" && args[3] >= 0 && args[3] <= 1)) {
+      return "rgb";
+    }
+  }
+});
+export {
+  rgb
+};

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

@@ -0,0 +1,16 @@
+import chroma from "../../chroma.js";
+import Color from "../../Color.js";
+import input from "../input.js";
+import temperature2rgb from "./temperature2rgb.js";
+import rgb2temperature from "./rgb2temperature.js";
+Color.prototype.temp = Color.prototype.kelvin = Color.prototype.temperature = function() {
+  return rgb2temperature(this._rgb);
+};
+const temp = (...args) => new Color(...args, "temp");
+Object.assign(chroma, { temp, kelvin: temp, temperature: temp });
+input.format.temp = input.format.kelvin = input.format.temperature = temperature2rgb;
+export {
+  temp as kelvin,
+  temp,
+  temp as temperature
+};

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

@@ -0,0 +1,25 @@
+import temperature2rgb from "./temperature2rgb.js";
+import "../../utils/type.js";
+import unpack from "../../utils/unpack.js";
+const { round } = Math;
+const rgb2temperature = (...args) => {
+  const rgb = unpack(args, "rgb");
+  const r = rgb[0], b = rgb[2];
+  let minTemp = 1e3;
+  let maxTemp = 4e4;
+  const eps = 0.4;
+  let temp;
+  while (maxTemp - minTemp > eps) {
+    temp = (maxTemp + minTemp) * 0.5;
+    const rgb2 = temperature2rgb(temp);
+    if (rgb2[2] / rgb2[0] >= b / r) {
+      maxTemp = temp;
+    } else {
+      minTemp = temp;
+    }
+  }
+  return round(temp);
+};
+export {
+  rgb2temperature as default
+};

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

@@ -0,0 +1,18 @@
+const { log } = Math;
+const temperature2rgb = (kelvin) => {
+  const temp = kelvin / 100;
+  let r, g, b;
+  if (temp < 66) {
+    r = 255;
+    g = temp < 6 ? 0 : -155.25485562709179 - 0.44596950469579133 * (g = temp - 2) + 104.49216199393888 * log(g);
+    b = temp < 20 ? 0 : -254.76935184120902 + 0.8274096064007395 * (b = temp - 10) + 115.67994401066147 * log(b);
+  } else {
+    r = 351.97690566805693 + 0.114206453784165 * (r = temp - 55) - 40.25366309332127 * log(r);
+    g = 325.4494125711974 + 0.07943456536662342 * (g = temp - 50) - 28.0852963507957 * log(g);
+    b = 255;
+  }
+  return [r, g, b, 1];
+};
+export {
+  temperature2rgb as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/ops/alpha.js

@@ -0,0 +1,12 @@
+import Color from "../Color.js";
+import type from "../utils/type.js";
+Color.prototype.alpha = function(a, mutate = false) {
+  if (a !== void 0 && type(a) === "number") {
+    if (mutate) {
+      this._rgb[3] = a;
+      return this;
+    }
+    return new Color([this._rgb[0], this._rgb[1], this._rgb[2], a], "rgb");
+  }
+  return this._rgb[3];
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/ops/clipped.js

@@ -0,0 +1,4 @@
+import Color from "../Color.js";
+Color.prototype.clipped = function() {
+  return this._rgb._clipped || false;
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/ops/darken.js

@@ -0,0 +1,14 @@
+import "../io/lab/index.js";
+import Color from "../Color.js";
+import labConstants from "../io/lab/lab-constants.js";
+Color.prototype.darken = function(amount = 1) {
+  const me = this;
+  const lab = me.lab();
+  lab[0] -= labConstants.Kn * amount;
+  return new Color(lab, "lab").alpha(me.alpha(), true);
+};
+Color.prototype.brighten = function(amount = 1) {
+  return this.darken(-amount);
+};
+Color.prototype.darker = Color.prototype.darken;
+Color.prototype.brighter = Color.prototype.brighten;

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/ops/get.js

@@ -0,0 +1,12 @@
+import Color from "../Color.js";
+Color.prototype.get = function(mc) {
+  const [mode, channel] = mc.split(".");
+  const src = this[mode]();
+  if (channel) {
+    const i = mode.indexOf(channel) - (mode.substr(0, 2) === "ok" ? 2 : 0);
+    if (i > -1) return src[i];
+    throw new Error(`unknown channel ${channel} in mode ${mode}`);
+  } else {
+    return src;
+  }
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/ops/luminance.js

@@ -0,0 +1,38 @@
+import Color from "../Color.js";
+import type from "../utils/type.js";
+const { pow } = Math;
+const EPS = 1e-7;
+const MAX_ITER = 20;
+Color.prototype.luminance = function(lum, mode = "rgb") {
+  if (lum !== void 0 && type(lum) === "number") {
+    if (lum === 0) {
+      return new Color([0, 0, 0, this._rgb[3]], "rgb");
+    }
+    if (lum === 1) {
+      return new Color([255, 255, 255, this._rgb[3]], "rgb");
+    }
+    let cur_lum = this.luminance();
+    let max_iter = MAX_ITER;
+    const test = (low, high) => {
+      const mid = low.interpolate(high, 0.5, mode);
+      const lm = mid.luminance();
+      if (Math.abs(lum - lm) < EPS || !max_iter--) {
+        return mid;
+      }
+      return lm > lum ? test(low, mid) : test(mid, high);
+    };
+    const rgb = (cur_lum > lum ? test(new Color([0, 0, 0]), this) : test(this, new Color([255, 255, 255]))).rgb();
+    return new Color([...rgb, this._rgb[3]]);
+  }
+  return rgb2luminance(...this._rgb.slice(0, 3));
+};
+const rgb2luminance = (r, g, b) => {
+  r = luminance_x(r);
+  g = luminance_x(g);
+  b = luminance_x(b);
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+};
+const luminance_x = (x) => {
+  x /= 255;
+  return x <= 0.03928 ? x / 12.92 : pow((x + 0.055) / 1.055, 2.4);
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/ops/mix.js

@@ -0,0 +1,5 @@
+import Color from "../Color.js";
+import mix from "../generator/mix.js";
+Color.prototype.mix = Color.prototype.interpolate = function(col2, f = 0.5, ...rest) {
+  return mix(this, col2, f, ...rest);
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/ops/premultiply.js

@@ -0,0 +1,11 @@
+import Color from "../Color.js";
+Color.prototype.premultiply = function(mutate = false) {
+  const rgb = this._rgb;
+  const a = rgb[3];
+  if (mutate) {
+    this._rgb = [rgb[0] * a, rgb[1] * a, rgb[2] * a, a];
+    return this;
+  } else {
+    return new Color([rgb[0] * a, rgb[1] * a, rgb[2] * a, a], "rgb");
+  }
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/ops/saturate.js

@@ -0,0 +1,13 @@
+import "../io/lch/index.js";
+import Color from "../Color.js";
+import labConstants from "../io/lab/lab-constants.js";
+Color.prototype.saturate = function(amount = 1) {
+  const me = this;
+  const lch = me.lch();
+  lch[1] += labConstants.Kn * amount;
+  if (lch[1] < 0) lch[1] = 0;
+  return new Color(lch, "lch").alpha(me.alpha(), true);
+};
+Color.prototype.desaturate = function(amount = 1) {
+  return this.saturate(-amount);
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/ops/set.js

@@ -0,0 +1,42 @@
+import Color from "../Color.js";
+import type from "../utils/type.js";
+Color.prototype.set = function(mc, value, mutate = false) {
+  const [mode, channel] = mc.split(".");
+  const src = this[mode]();
+  if (channel) {
+    const i = mode.indexOf(channel) - (mode.substr(0, 2) === "ok" ? 2 : 0);
+    if (i > -1) {
+      if (type(value) == "string") {
+        switch (value.charAt(0)) {
+          case "+":
+            src[i] += +value;
+            break;
+          case "-":
+            src[i] += +value;
+            break;
+          case "*":
+            src[i] *= +value.substr(1);
+            break;
+          case "/":
+            src[i] /= +value.substr(1);
+            break;
+          default:
+            src[i] = +value;
+        }
+      } else if (type(value) === "number") {
+        src[i] = value;
+      } else {
+        throw new Error(`unsupported value for Color.set`);
+      }
+      const out = new Color(src, mode);
+      if (mutate) {
+        this._rgb = out._rgb;
+        return this;
+      }
+      return out;
+    }
+    throw new Error(`unknown channel ${channel} in mode ${mode}`);
+  } else {
+    return src;
+  }
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/ops/shade.js

@@ -0,0 +1,9 @@
+import "../io/lab/index.js";
+import Color from "../Color.js";
+import mix from "../generator/mix.js";
+Color.prototype.tint = function(f = 0.5, ...rest) {
+  return mix(this, "white", f, ...rest);
+};
+Color.prototype.shade = function(f = 0.5, ...rest) {
+  return mix(this, "black", f, ...rest);
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/utils/analyze.js

@@ -0,0 +1,161 @@
+import type from "./type.js";
+const { log, pow, floor, abs } = Math;
+function analyze(data, key = null) {
+  const r = {
+    min: Number.MAX_VALUE,
+    max: Number.MAX_VALUE * -1,
+    sum: 0,
+    values: [],
+    count: 0
+  };
+  if (type(data) === "object") {
+    data = Object.values(data);
+  }
+  data.forEach((val) => {
+    if (key && type(val) === "object") val = val[key];
+    if (val !== void 0 && val !== null && !isNaN(val)) {
+      r.values.push(val);
+      r.sum += val;
+      if (val < r.min) r.min = val;
+      if (val > r.max) r.max = val;
+      r.count += 1;
+    }
+  });
+  r.domain = [r.min, r.max];
+  r.limits = (mode, num) => limits(r, mode, num);
+  return r;
+}
+function limits(data, mode = "equal", num = 7) {
+  if (type(data) == "array") {
+    data = analyze(data);
+  }
+  const { min, max } = data;
+  const values = data.values.sort((a, b) => a - b);
+  if (num === 1) {
+    return [min, max];
+  }
+  const limits2 = [];
+  if (mode.substr(0, 1) === "c") {
+    limits2.push(min);
+    limits2.push(max);
+  }
+  if (mode.substr(0, 1) === "e") {
+    limits2.push(min);
+    for (let i = 1; i < num; i++) {
+      limits2.push(min + i / num * (max - min));
+    }
+    limits2.push(max);
+  } else if (mode.substr(0, 1) === "l") {
+    if (min <= 0) {
+      throw new Error(
+        "Logarithmic scales are only possible for values > 0"
+      );
+    }
+    const min_log = Math.LOG10E * log(min);
+    const max_log = Math.LOG10E * log(max);
+    limits2.push(min);
+    for (let i = 1; i < num; i++) {
+      limits2.push(pow(10, min_log + i / num * (max_log - min_log)));
+    }
+    limits2.push(max);
+  } else if (mode.substr(0, 1) === "q") {
+    limits2.push(min);
+    for (let i = 1; i < num; i++) {
+      const p = (values.length - 1) * i / num;
+      const pb = floor(p);
+      if (pb === p) {
+        limits2.push(values[pb]);
+      } else {
+        const pr = p - pb;
+        limits2.push(values[pb] * (1 - pr) + values[pb + 1] * pr);
+      }
+    }
+    limits2.push(max);
+  } else if (mode.substr(0, 1) === "k") {
+    let cluster;
+    const n = values.length;
+    const assignments = new Array(n);
+    const clusterSizes = new Array(num);
+    let repeat = true;
+    let nb_iters = 0;
+    let centroids = null;
+    centroids = [];
+    centroids.push(min);
+    for (let i = 1; i < num; i++) {
+      centroids.push(min + i / num * (max - min));
+    }
+    centroids.push(max);
+    while (repeat) {
+      for (let j = 0; j < num; j++) {
+        clusterSizes[j] = 0;
+      }
+      for (let i = 0; i < n; i++) {
+        const value = values[i];
+        let mindist = Number.MAX_VALUE;
+        let best;
+        for (let j = 0; j < num; j++) {
+          const dist = abs(centroids[j] - value);
+          if (dist < mindist) {
+            mindist = dist;
+            best = j;
+          }
+          clusterSizes[best]++;
+          assignments[i] = best;
+        }
+      }
+      const newCentroids = new Array(num);
+      for (let j = 0; j < num; j++) {
+        newCentroids[j] = null;
+      }
+      for (let i = 0; i < n; i++) {
+        cluster = assignments[i];
+        if (newCentroids[cluster] === null) {
+          newCentroids[cluster] = values[i];
+        } else {
+          newCentroids[cluster] += values[i];
+        }
+      }
+      for (let j = 0; j < num; j++) {
+        newCentroids[j] *= 1 / clusterSizes[j];
+      }
+      repeat = false;
+      for (let j = 0; j < num; j++) {
+        if (newCentroids[j] !== centroids[j]) {
+          repeat = true;
+          break;
+        }
+      }
+      centroids = newCentroids;
+      nb_iters++;
+      if (nb_iters > 200) {
+        repeat = false;
+      }
+    }
+    const kClusters = {};
+    for (let j = 0; j < num; j++) {
+      kClusters[j] = [];
+    }
+    for (let i = 0; i < n; i++) {
+      cluster = assignments[i];
+      kClusters[cluster].push(values[i]);
+    }
+    let tmpKMeansBreaks = [];
+    for (let j = 0; j < num; j++) {
+      tmpKMeansBreaks.push(kClusters[j][0]);
+      tmpKMeansBreaks.push(kClusters[j][kClusters[j].length - 1]);
+    }
+    tmpKMeansBreaks = tmpKMeansBreaks.sort((a, b) => a - b);
+    limits2.push(tmpKMeansBreaks[0]);
+    for (let i = 1; i < tmpKMeansBreaks.length; i += 2) {
+      const v = tmpKMeansBreaks[i];
+      if (!isNaN(v) && limits2.indexOf(v) === -1) {
+        limits2.push(v);
+      }
+    }
+  }
+  return limits2;
+}
+export {
+  analyze,
+  limits
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/utils/clip_rgb.js

@@ -0,0 +1,17 @@
+import limit from "./limit.js";
+const clip_rgb = (rgb) => {
+  rgb._clipped = false;
+  rgb._unclipped = rgb.slice(0);
+  for (let i = 0; i <= 3; i++) {
+    if (i < 3) {
+      if (rgb[i] < 0 || rgb[i] > 255) rgb._clipped = true;
+      rgb[i] = limit(rgb[i], 0, 255);
+    } else if (i === 3) {
+      rgb[i] = limit(rgb[i], 0, 1);
+    }
+  }
+  return rgb;
+};
+export {
+  clip_rgb as default
+};