@choice-ui/react 1.7.6 → 1.7.7

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/generator/bezier.js

@@ -0,0 +1,68 @@
+import Color from "../Color.js";
+import "../io/lab/index.js";
+import scale from "./scale.js";
+const binom_row = function(n) {
+  let row = [1, 1];
+  for (let i = 1; i < n; i++) {
+    let newrow = [1];
+    for (let j = 1; j <= row.length; j++) {
+      newrow[j] = (row[j] || 0) + row[j - 1];
+    }
+    row = newrow;
+  }
+  return row;
+};
+const bezier = function(colors) {
+  let I, lab0, lab1, lab2;
+  colors = colors.map((c) => new Color(c));
+  if (colors.length === 2) {
+    [lab0, lab1] = colors.map((c) => c.lab());
+    I = function(t) {
+      const lab = [0, 1, 2].map((i) => lab0[i] + t * (lab1[i] - lab0[i]));
+      return new Color(lab, "lab");
+    };
+  } else if (colors.length === 3) {
+    [lab0, lab1, lab2] = colors.map((c) => c.lab());
+    I = function(t) {
+      const lab = [0, 1, 2].map(
+        (i) => (1 - t) * (1 - t) * lab0[i] + 2 * (1 - t) * t * lab1[i] + t * t * lab2[i]
+      );
+      return new Color(lab, "lab");
+    };
+  } else if (colors.length === 4) {
+    let lab3;
+    [lab0, lab1, lab2, lab3] = colors.map((c) => c.lab());
+    I = function(t) {
+      const lab = [0, 1, 2].map(
+        (i) => (1 - t) * (1 - t) * (1 - t) * lab0[i] + 3 * (1 - t) * (1 - t) * t * lab1[i] + 3 * (1 - t) * t * t * lab2[i] + t * t * t * lab3[i]
+      );
+      return new Color(lab, "lab");
+    };
+  } else if (colors.length >= 5) {
+    let labs, row, n;
+    labs = colors.map((c) => c.lab());
+    n = colors.length - 1;
+    row = binom_row(n);
+    I = function(t) {
+      const u = 1 - t;
+      const lab = [0, 1, 2].map(
+        (i) => labs.reduce(
+          (sum, el, j) => sum + row[j] * u ** (n - j) * t ** j * el[i],
+          0
+        )
+      );
+      return new Color(lab, "lab");
+    };
+  } else {
+    throw new RangeError("No point in running bezier with only one color.");
+  }
+  return I;
+};
+const bezier$1 = (colors) => {
+  const f = bezier(colors);
+  f.scale = () => scale(f);
+  return f;
+};
+export {
+  bezier$1 as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/generator/blend.js

@@ -0,0 +1,43 @@
+import "../io/rgb/index.js";
+import chroma from "../chroma.js";
+const blend = (bottom, top, mode) => {
+  if (!blend[mode]) {
+    throw new Error("unknown blend mode " + mode);
+  }
+  return blend[mode](bottom, top);
+};
+const blend_f = (f) => (bottom, top) => {
+  const c0 = chroma(top).rgb();
+  const c1 = chroma(bottom).rgb();
+  return chroma.rgb(f(c0, c1));
+};
+const each = (f) => (c0, c1) => {
+  const out = [];
+  out[0] = f(c0[0], c1[0]);
+  out[1] = f(c0[1], c1[1]);
+  out[2] = f(c0[2], c1[2]);
+  return out;
+};
+const normal = (a) => a;
+const multiply = (a, b) => a * b / 255;
+const darken = (a, b) => a > b ? b : a;
+const lighten = (a, b) => a > b ? a : b;
+const screen = (a, b) => 255 * (1 - (1 - a / 255) * (1 - b / 255));
+const overlay = (a, b) => b < 128 ? 2 * a * b / 255 : 255 * (1 - 2 * (1 - a / 255) * (1 - b / 255));
+const burn = (a, b) => 255 * (1 - (1 - b / 255) / (a / 255));
+const dodge = (a, b) => {
+  if (a === 255) return 255;
+  a = 255 * (b / 255) / (1 - a / 255);
+  return a > 255 ? 255 : a;
+};
+blend.normal = blend_f(each(normal));
+blend.multiply = blend_f(each(multiply));
+blend.screen = blend_f(each(screen));
+blend.overlay = blend_f(each(overlay));
+blend.darken = blend_f(each(darken));
+blend.lighten = blend_f(each(lighten));
+blend.dodge = blend_f(each(dodge));
+blend.burn = blend_f(each(burn));
+export {
+  blend as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/generator/cubehelix.js

@@ -0,0 +1,81 @@
+import { TWOPI } from "../utils/index.js";
+import chroma from "../chroma.js";
+import type from "../utils/type.js";
+import clip_rgb from "../utils/clip_rgb.js";
+const { pow, sin, cos } = Math;
+function cubehelix(start = 300, rotations = -1.5, hue = 1, gamma = 1, lightness = [0, 1]) {
+  let dh = 0, dl;
+  if (type(lightness) === "array") {
+    dl = lightness[1] - lightness[0];
+  } else {
+    dl = 0;
+    lightness = [lightness, lightness];
+  }
+  const f = function(fract) {
+    const a = TWOPI * ((start + 120) / 360 + rotations * fract);
+    const l = pow(lightness[0] + dl * fract, gamma);
+    const h = dh !== 0 ? hue[0] + fract * dh : hue;
+    const amp = h * l * (1 - l) / 2;
+    const cos_a = cos(a);
+    const sin_a = sin(a);
+    const r = l + amp * (-0.14861 * cos_a + 1.78277 * sin_a);
+    const g = l + amp * (-0.29227 * cos_a - 0.90649 * sin_a);
+    const b = l + amp * (1.97294 * cos_a);
+    return chroma(clip_rgb([r * 255, g * 255, b * 255, 1]));
+  };
+  f.start = function(s) {
+    if (s == null) {
+      return start;
+    }
+    start = s;
+    return f;
+  };
+  f.rotations = function(r) {
+    if (r == null) {
+      return rotations;
+    }
+    rotations = r;
+    return f;
+  };
+  f.gamma = function(g) {
+    if (g == null) {
+      return gamma;
+    }
+    gamma = g;
+    return f;
+  };
+  f.hue = function(h) {
+    if (h == null) {
+      return hue;
+    }
+    hue = h;
+    if (type(hue) === "array") {
+      dh = hue[1] - hue[0];
+      if (dh === 0) {
+        hue = hue[1];
+      }
+    } else {
+      dh = 0;
+    }
+    return f;
+  };
+  f.lightness = function(h) {
+    if (h == null) {
+      return lightness;
+    }
+    if (type(h) === "array") {
+      lightness = h;
+      dl = h[1] - h[0];
+    } else {
+      lightness = [h, h];
+      dl = 0;
+    }
+    return f;
+  };
+  f.scale = () => chroma.scale(f);
+  f.hue(hue);
+  return f;
+}
+export {
+  cubehelix as default
+};

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

@@ -0,0 +1,20 @@
+import Color from "../Color.js";
+import type from "../utils/type.js";
+import index from "../interpolator/index.js";
+const mix = (col1, col2, f = 0.5, ...rest) => {
+  let mode = rest[0] || "lrgb";
+  if (!index[mode] && !rest.length) {
+    mode = Object.keys(index)[0];
+  }
+  if (!index[mode]) {
+    throw new Error(`interpolation mode ${mode} is not defined`);
+  }
+  if (type(col1) !== "object") col1 = new Color(col1);
+  if (type(col2) !== "object") col2 = new Color(col2);
+  return index[mode](col1, col2, f).alpha(
+    col1.alpha() + f * (col2.alpha() - col1.alpha())
+  );
+};
+export {
+  mix as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/generator/random.js

@@ -0,0 +1,13 @@
+import Color from "../Color.js";
+const digits = "0123456789abcdef";
+const { floor, random } = Math;
+const random$1 = (rng = random) => {
+  let code = "#";
+  for (let i = 0; i < 6; i++) {
+    code += digits.charAt(floor(rng() * 16));
+  }
+  return new Color(code, "hex");
+};
+export {
+  random$1 as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/generator/scale.js

@@ -0,0 +1,325 @@
+import chroma from "../chroma.js";
+import limit from "../utils/limit.js";
+import type from "../utils/type.js";
+const { pow } = Math;
+function scale(colors) {
+  let _mode = "rgb";
+  let _nacol = chroma("#ccc");
+  let _spread = 0;
+  let _positions = [0, 1];
+  let _domain = [0, 1];
+  let _pos = [];
+  let _padding = [0, 0];
+  let _classes = false;
+  let _colors = [];
+  let _out = false;
+  let _min = 0;
+  let _max = 1;
+  let _correctLightness = false;
+  let _colorCache = {};
+  let _useCache = true;
+  let _gamma = 1;
+  const setColors = function(colors2) {
+    colors2 = colors2 || ["#fff", "#000"];
+    if (colors2 && type(colors2) === "string" && chroma.brewer && chroma.brewer[colors2.toLowerCase()]) {
+      colors2 = chroma.brewer[colors2.toLowerCase()];
+    }
+    if (type(colors2) === "array") {
+      if (colors2.length === 1) {
+        colors2 = [colors2[0], colors2[0]];
+      }
+      colors2 = colors2.slice(0);
+      for (let c = 0; c < colors2.length; c++) {
+        colors2[c] = chroma(colors2[c]);
+      }
+      _pos.length = 0;
+      for (let c = 0; c < colors2.length; c++) {
+        _pos.push(c / (colors2.length - 1));
+      }
+    }
+    resetCache();
+    return _colors = colors2;
+  };
+  const getClass = function(value) {
+    if (_classes != null) {
+      const n = _classes.length - 1;
+      let i = 0;
+      while (i < n && value >= _classes[i]) {
+        i++;
+      }
+      return i - 1;
+    }
+    return 0;
+  };
+  let tMapLightness = (t) => t;
+  let tMapDomain = (t) => t;
+  const getColor = function(val, bypassMap) {
+    let col, t;
+    if (bypassMap == null) {
+      bypassMap = false;
+    }
+    if (isNaN(val) || val === null) {
+      return _nacol;
+    }
+    if (!bypassMap) {
+      if (_classes && _classes.length > 2) {
+        const c = getClass(val);
+        t = c / (_classes.length - 2);
+      } else if (_max !== _min) {
+        t = (val - _min) / (_max - _min);
+      } else {
+        t = 1;
+      }
+    } else {
+      t = val;
+    }
+    t = tMapDomain(t);
+    if (!bypassMap) {
+      t = tMapLightness(t);
+    }
+    if (_gamma !== 1) {
+      t = pow(t, _gamma);
+    }
+    t = _padding[0] + t * (1 - _padding[0] - _padding[1]);
+    t = limit(t, 0, 1);
+    const k = Math.floor(t * 1e4);
+    if (_useCache && _colorCache[k]) {
+      col = _colorCache[k];
+    } else {
+      if (type(_colors) === "array") {
+        for (let i = 0; i < _pos.length; i++) {
+          const p = _pos[i];
+          if (t <= p) {
+            col = _colors[i];
+            break;
+          }
+          if (t >= p && i === _pos.length - 1) {
+            col = _colors[i];
+            break;
+          }
+          if (t > p && t < _pos[i + 1]) {
+            t = (t - p) / (_pos[i + 1] - p);
+            col = chroma.interpolate(
+              _colors[i],
+              _colors[i + 1],
+              t,
+              _mode
+            );
+            break;
+          }
+        }
+      } else if (type(_colors) === "function") {
+        col = _colors(t);
+      }
+      if (_useCache) {
+        _colorCache[k] = col;
+      }
+    }
+    return col;
+  };
+  var resetCache = () => _colorCache = {};
+  setColors(colors);
+  const f = function(v) {
+    const c = chroma(getColor(v));
+    if (_out && c[_out]) {
+      return c[_out]();
+    } else {
+      return c;
+    }
+  };
+  f.classes = function(classes) {
+    if (classes != null) {
+      if (type(classes) === "array") {
+        _classes = classes;
+        _positions = [classes[0], classes[classes.length - 1]];
+      } else {
+        const d = chroma.analyze(_positions);
+        if (classes === 0) {
+          _classes = [d.min, d.max];
+        } else {
+          _classes = chroma.limits(d, "e", classes);
+        }
+      }
+      return f;
+    }
+    return _classes;
+  };
+  f.domain = function(domain) {
+    if (!arguments.length) {
+      return _domain;
+    }
+    _domain = domain.slice(0);
+    _min = domain[0];
+    _max = domain[domain.length - 1];
+    _pos = [];
+    const k = _colors.length;
+    if (domain.length === k && _min !== _max) {
+      for (let d of Array.from(domain)) {
+        _pos.push((d - _min) / (_max - _min));
+      }
+    } else {
+      for (let c = 0; c < k; c++) {
+        _pos.push(c / (k - 1));
+      }
+      if (domain.length > 2) {
+        const tOut = domain.map((d, i) => i / (domain.length - 1));
+        const tBreaks = domain.map((d) => (d - _min) / (_max - _min));
+        if (!tBreaks.every((val, i) => tOut[i] === val)) {
+          tMapDomain = (t) => {
+            if (t <= 0 || t >= 1) return t;
+            let i = 0;
+            while (t >= tBreaks[i + 1]) i++;
+            const f2 = (t - tBreaks[i]) / (tBreaks[i + 1] - tBreaks[i]);
+            const out = tOut[i] + f2 * (tOut[i + 1] - tOut[i]);
+            return out;
+          };
+        }
+      }
+    }
+    _positions = [_min, _max];
+    return f;
+  };
+  f.mode = function(_m) {
+    if (!arguments.length) {
+      return _mode;
+    }
+    _mode = _m;
+    resetCache();
+    return f;
+  };
+  f.range = function(colors2, _pos2) {
+    setColors(colors2);
+    return f;
+  };
+  f.out = function(_o) {
+    _out = _o;
+    return f;
+  };
+  f.spread = function(val) {
+    if (!arguments.length) {
+      return _spread;
+    }
+    _spread = val;
+    return f;
+  };
+  f.correctLightness = function(v) {
+    if (v == null) {
+      v = true;
+    }
+    _correctLightness = v;
+    resetCache();
+    if (_correctLightness) {
+      tMapLightness = function(t) {
+        const L0 = getColor(0, true).lab()[0];
+        const L1 = getColor(1, true).lab()[0];
+        const pol = L0 > L1;
+        let L_actual = getColor(t, true).lab()[0];
+        const L_ideal = L0 + (L1 - L0) * t;
+        let L_diff = L_actual - L_ideal;
+        let t0 = 0;
+        let t1 = 1;
+        let max_iter = 20;
+        while (Math.abs(L_diff) > 0.01 && max_iter-- > 0) {
+          (function() {
+            if (pol) {
+              L_diff *= -1;
+            }
+            if (L_diff < 0) {
+              t0 = t;
+              t += (t1 - t) * 0.5;
+            } else {
+              t1 = t;
+              t += (t0 - t) * 0.5;
+            }
+            L_actual = getColor(t, true).lab()[0];
+            return L_diff = L_actual - L_ideal;
+          })();
+        }
+        return t;
+      };
+    } else {
+      tMapLightness = (t) => t;
+    }
+    return f;
+  };
+  f.padding = function(p) {
+    if (p != null) {
+      if (type(p) === "number") {
+        p = [p, p];
+      }
+      _padding = p;
+      return f;
+    } else {
+      return _padding;
+    }
+  };
+  f.colors = function(numColors, out) {
+    if (arguments.length < 2) {
+      out = "hex";
+    }
+    let result = [];
+    if (arguments.length === 0) {
+      result = _colors.slice(0);
+    } else if (numColors === 1) {
+      result = [f(0.5)];
+    } else if (numColors > 1) {
+      const dm = _positions[0];
+      const dd = _positions[1] - dm;
+      result = __range__(0, numColors).map(
+        (i) => f(dm + i / (numColors - 1) * dd)
+      );
+    } else {
+      colors = [];
+      let samples = [];
+      if (_classes && _classes.length > 2) {
+        for (let i = 1, end = _classes.length, asc = 1 <= end; asc ? i < end : i > end; asc ? i++ : i--) {
+          samples.push((_classes[i - 1] + _classes[i]) * 0.5);
+        }
+      } else {
+        samples = _positions;
+      }
+      result = samples.map((v) => f(v));
+    }
+    if (chroma[out]) {
+      result = result.map((c) => c[out]());
+    }
+    return result;
+  };
+  f.cache = function(c) {
+    if (c != null) {
+      _useCache = c;
+      return f;
+    } else {
+      return _useCache;
+    }
+  };
+  f.gamma = function(g) {
+    if (g != null) {
+      _gamma = g;
+      return f;
+    } else {
+      return _gamma;
+    }
+  };
+  f.nodata = function(d) {
+    if (d != null) {
+      _nacol = chroma(d);
+      return f;
+    } else {
+      return _nacol;
+    }
+  };
+  return f;
+}
+function __range__(left, right, inclusive) {
+  let range = [];
+  let ascending = left < right;
+  let end = right;
+  for (let i = left; ascending ? i < end : i > end; ascending ? i++ : i--) {
+    range.push(i);
+  }
+  return range;
+}
+export {
+  scale as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/interpolator/_hsx.js

@@ -0,0 +1,54 @@
+import Color from "../Color.js";
+const interpolate_hsx = (col1, col2, f, m) => {
+  let xyz0, xyz1;
+  if (m === "hsl") {
+    xyz0 = col1.hsl();
+    xyz1 = col2.hsl();
+  } else if (m === "hsv") {
+    xyz0 = col1.hsv();
+    xyz1 = col2.hsv();
+  } else if (m === "hcg") {
+    xyz0 = col1.hcg();
+    xyz1 = col2.hcg();
+  } else if (m === "hsi") {
+    xyz0 = col1.hsi();
+    xyz1 = col2.hsi();
+  } else if (m === "lch" || m === "hcl") {
+    m = "hcl";
+    xyz0 = col1.hcl();
+    xyz1 = col2.hcl();
+  } else if (m === "oklch") {
+    xyz0 = col1.oklch().reverse();
+    xyz1 = col2.oklch().reverse();
+  }
+  let hue0, hue1, sat0, sat1, lbv0, lbv1;
+  if (m.substr(0, 1) === "h" || m === "oklch") {
+    [hue0, sat0, lbv0] = xyz0;
+    [hue1, sat1, lbv1] = xyz1;
+  }
+  let sat, hue, lbv, dh;
+  if (!isNaN(hue0) && !isNaN(hue1)) {
+    if (hue1 > hue0 && hue1 - hue0 > 180) {
+      dh = hue1 - (hue0 + 360);
+    } else if (hue1 < hue0 && hue0 - hue1 > 180) {
+      dh = hue1 + 360 - hue0;
+    } else {
+      dh = hue1 - hue0;
+    }
+    hue = hue0 + f * dh;
+  } else if (!isNaN(hue0)) {
+    hue = hue0;
+    if ((lbv1 == 1 || lbv1 == 0) && m != "hsv") sat = sat0;
+  } else if (!isNaN(hue1)) {
+    hue = hue1;
+    if ((lbv0 == 1 || lbv0 == 0) && m != "hsv") sat = sat1;
+  } else {
+    hue = Number.NaN;
+  }
+  if (sat === void 0) sat = sat0 + f * (sat1 - sat0);
+  lbv = lbv0 + f * (lbv1 - lbv0);
+  return m === "oklch" ? new Color([lbv, sat, hue], m) : new Color([hue, sat, lbv], m);
+};
+export {
+  interpolate_hsx as default
+};

package/dist/node_modules/.pnpm/chroma-js@3.2.0/node_modules/chroma-js/src/interpolator/hcg.js

@@ -0,0 +1,10 @@
+import "../io/hcg/index.js";
+import interpolate_hsx from "./_hsx.js";
+import index from "./index.js";
+const hcg = (col1, col2, f) => {
+  return interpolate_hsx(col1, col2, f, "hcg");
+};
+index.hcg = hcg;
+export {
+  hcg as default
+};

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

@@ -0,0 +1,10 @@
+import "../io/hsi/index.js";
+import interpolate_hsx from "./_hsx.js";
+import index from "./index.js";
+const hsi = (col1, col2, f) => {
+  return interpolate_hsx(col1, col2, f, "hsi");
+};
+index.hsi = hsi;
+export {
+  hsi as default
+};

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

@@ -0,0 +1,10 @@
+import "../io/hsl/index.js";
+import interpolate_hsx from "./_hsx.js";
+import index from "./index.js";
+const hsl = (col1, col2, f) => {
+  return interpolate_hsx(col1, col2, f, "hsl");
+};
+index.hsl = hsl;
+export {
+  hsl as default
+};

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

@@ -0,0 +1,10 @@
+import "../io/hsv/index.js";
+import interpolate_hsx from "./_hsx.js";
+import index from "./index.js";
+const hsv = (col1, col2, f) => {
+  return interpolate_hsx(col1, col2, f, "hsv");
+};
+index.hsv = hsv;
+export {
+  hsv as default
+};

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

@@ -0,0 +1,4 @@
+const index = {};
+export {
+  index as default
+};

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

@@ -0,0 +1,17 @@
+import "../io/lab/index.js";
+import index from "./index.js";
+import Color from "../Color.js";
+const lab = (col1, col2, f) => {
+  const xyz0 = col1.lab();
+  const xyz1 = col2.lab();
+  return new Color(
+    xyz0[0] + f * (xyz1[0] - xyz0[0]),
+    xyz0[1] + f * (xyz1[1] - xyz0[1]),
+    xyz0[2] + f * (xyz1[2] - xyz0[2]),
+    "lab"
+  );
+};
+index.lab = lab;
+export {
+  lab as default
+};

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

@@ -0,0 +1,11 @@
+import "../io/lch/index.js";
+import interpolate_hsx from "./_hsx.js";
+import index from "./index.js";
+const lch = (col1, col2, f) => {
+  return interpolate_hsx(col1, col2, f, "lch");
+};
+index.lch = lch;
+index.hcl = lch;
+export {
+  lch as default
+};