@thi.ng/color 5.6.2 → 5.6.4

package/distance.js

@@ -6,205 +6,114 @@ import { labD50 } from "./lab/lab50.js";
 import { labD65 } from "./lab/lab65.js";
 import { luminanceRgb, luminanceSrgb } from "./luminance-rgb.js";
 const { abs, cos, hypot, sin, sqrt } = Math;
-/**
- * Higher order function. Returns {@link ColorDistance} function for given color
- * channel ID.
- *
- * @param id -
- */
-export const distChannel = (id) => (a, b) => abs(a[id] - b[id]);
-/**
- * Computes distance between two HSV colors, i.e. the eucledian distance between
- * points in a cyclinder.
- *
- * @param a -
- * @param b -
- */
-export const distHsv = (a, b) => {
-    const aa = cossin(a[0] * TAU, a[1]);
-    const bb = cossin(b[0] * TAU, b[1]);
-    return hypot(aa[0] - bb[0], aa[1] - bb[1], a[2] - b[2]);
+const distChannel = (id) => (a, b) => abs(a[id] - b[id]);
+const distHsv = (a, b) => {
+  const aa = cossin(a[0] * TAU, a[1]);
+  const bb = cossin(b[0] * TAU, b[1]);
+  return hypot(aa[0] - bb[0], aa[1] - bb[1], a[2] - b[2]);
 };
-/**
- * Similar to {@link distHsv}, but computes distance between two LCH colors
- * (with different channel order), i.e. the eucledian distance between points in
- * a cyclinder (using Law of Cosines).
- *
- * @remarks
- * Reference:
- * - https://math.stackexchange.com/a/3612602
- * - https://en.wikipedia.org/wiki/Law_of_cosines
- *
- * @param a
- * @param b
- */
-export const distLch = ({ 0: la, 1: ca, 2: ha }, { 0: lb, 1: cb, 2: hb }) => Math.sqrt(ca * ca +
-    cb * cb -
-    2 * ca * cb * Math.cos((ha - hb) * TAU) +
-    (la - lb) ** 2);
-/**
- * Computes difference in saturation between two HSV colors.
- *
- * @param a -
- * @param b -
- */
-export const distHsvSat = distChannel(1);
-/**
- * Computes difference in brightness between two HSV or two HSL colors.
- *
- * @param a -
- * @param b -
- */
-export const distHsvLuma = distChannel(2);
-/**
- * Computes eucledian distance between two colors. Only the first 3 color
- * channels will be considered.
- *
- * @param a -
- * @param b -
- */
-export const distEucledian3 = dist3;
-export const distEucledian4 = dist4;
-/**
- * Computes difference in luminance between two RGB colors.
- *
- * @param a -
- * @param b -
- */
-export const distRgbLuma = (a, b) => abs(luminanceRgb(a) - luminanceRgb(b));
-export const distSrgbLuma = (a, b) => abs(luminanceSrgb(a) - luminanceSrgb(b));
-/**
- * Computes red difference between two RGB colors.
- *
- * @param a -
- * @param b -
- */
-export const distRgbRed = distChannel(0);
-/**
- * Computes green difference between two RGB colors.
- *
- * @param a -
- * @param b -
- */
-export const distRgbGreen = distChannel(1);
-/**
- * Computes blue difference between two RGB colors.
- *
- * @param a -
- * @param b -
- */
-export const distRgbBlue = distChannel(1);
+const distLch = ({ 0: la, 1: ca, 2: ha }, { 0: lb, 1: cb, 2: hb }) => Math.sqrt(
+  ca * ca + cb * cb - 2 * ca * cb * Math.cos((ha - hb) * TAU) + (la - lb) ** 2
+);
+const distHsvSat = distChannel(1);
+const distHsvLuma = distChannel(2);
+const distEucledian3 = dist3;
+const distEucledian4 = dist4;
+const distRgbLuma = (a, b) => abs(luminanceRgb(a) - luminanceRgb(b));
+const distSrgbLuma = (a, b) => abs(luminanceSrgb(a) - luminanceSrgb(b));
+const distRgbRed = distChannel(0);
+const distRgbGreen = distChannel(1);
+const distRgbBlue = distChannel(1);
 const H6 = 6 * DEG2RAD;
 const H25 = 25 * DEG2RAD;
 const H63 = 63 * DEG2RAD;
 const H275 = 275 * DEG2RAD;
-/**
- * Higher order function to compute the CIEDE2000 color difference between 2
- * colors in CIELAB space. Takes a vector of LCH weight coefficients to adjust
- * importance of luminance, chroma and hue differences. By default all are 1.
- * Returns a {@link ColorDistance} function which converts (if needed) input
- * colors to {@link LabD50} and then computes the metric.
- *
- * @remarks
- * References:
- * - https://en.wikipedia.org/wiki/Color_difference#CIEDE2000
- * - http://www2.ece.rochester.edu/~gsharma/ciede2000/ciede2000noteCRNA.pdf
- *
- * @param a - Lab color
- * @param b - Lab color
- */
-export const distCIEDE2000 = (weights = ONE3) => (a, b) => {
-    let { 0: l1, 1: a1, 2: b1 } = labD50(a);
-    let { 0: l2, 1: a2, 2: b2 } = labD50(b);
-    l1 *= 100;
-    a1 *= 100;
-    b1 *= 100;
-    l2 *= 100;
-    a2 *= 100;
-    b2 *= 100;
-    const c1ab = hypot(a1, b1);
-    const c2ab = hypot(a2, b2);
-    const cab = (c1ab + c2ab) * 0.5;
-    const g = 1 + 0.5 * (1 - c7Coeff(cab));
-    a1 *= g;
-    a2 *= g;
-    const c1 = hypot(a1, b1);
-    const c2 = hypot(a2, b2);
-    const cmean = (c1 + c2) * 0.5;
-    const { deltaH, H } = computeDeltaH(a1, b1, a2, b2, c1, c2);
-    const T = 1 -
-        0.17 * cos(H - SIXTH_PI) +
-        0.24 * cos(2 * H) +
-        0.32 * cos(3 * H + H6) -
-        0.2 * cos(4 * H - H63);
-    const Rt = -2 *
-        c7Coeff(cmean) *
-        sin(THIRD_PI * Math.exp(-(((H - H275) / H25) ** 2)));
-    const L50 = ((l1 + l2) * 0.5 - 50) ** 2;
-    const Sl = 1 + (0.015 * L50) / sqrt(20 + L50);
-    const Sc = 1 + 0.045 * cmean;
-    const Sh = 1 + 0.015 * cmean * T;
-    const termL = (l2 - l1) / (weights[0] * Sl);
-    const termC = (c2 - c1) / (weights[1] * Sc);
-    const termH = deltaH / (weights[2] * Sh);
-    return sqrt(termL ** 2 + termC ** 2 + termH ** 2 + Rt * termC * termH);
+const distCIEDE2000 = (weights = ONE3) => (a, b) => {
+  let { 0: l1, 1: a1, 2: b1 } = labD50(a);
+  let { 0: l2, 1: a2, 2: b2 } = labD50(b);
+  l1 *= 100;
+  a1 *= 100;
+  b1 *= 100;
+  l2 *= 100;
+  a2 *= 100;
+  b2 *= 100;
+  const c1ab = hypot(a1, b1);
+  const c2ab = hypot(a2, b2);
+  const cab = (c1ab + c2ab) * 0.5;
+  const g = 1 + 0.5 * (1 - c7Coeff(cab));
+  a1 *= g;
+  a2 *= g;
+  const c1 = hypot(a1, b1);
+  const c2 = hypot(a2, b2);
+  const cmean = (c1 + c2) * 0.5;
+  const { deltaH, H } = computeDeltaH(a1, b1, a2, b2, c1, c2);
+  const T = 1 - 0.17 * cos(H - SIXTH_PI) + 0.24 * cos(2 * H) + 0.32 * cos(3 * H + H6) - 0.2 * cos(4 * H - H63);
+  const Rt = -2 * c7Coeff(cmean) * sin(THIRD_PI * Math.exp(-(((H - H275) / H25) ** 2)));
+  const L50 = ((l1 + l2) * 0.5 - 50) ** 2;
+  const Sl = 1 + 0.015 * L50 / sqrt(20 + L50);
+  const Sc = 1 + 0.045 * cmean;
+  const Sh = 1 + 0.015 * cmean * T;
+  const termL = (l2 - l1) / (weights[0] * Sl);
+  const termC = (c2 - c1) / (weights[1] * Sc);
+  const termH = deltaH / (weights[2] * Sh);
+  return sqrt(termL ** 2 + termC ** 2 + termH ** 2 + Rt * termC * termH);
 };
 const c7Coeff = (c) => {
-    c = c ** 7;
-    return sqrt(c / (c + 25 ** 7));
+  c = c ** 7;
+  return sqrt(c / (c + 25 ** 7));
 };
 const computeDeltaH = (a1, b1, a2, b2, c1, c2, eps = 1e-3) => {
-    const h1 = atan2Abs(b1, a1);
-    const h2 = atan2Abs(b2, a2);
-    if (c1 <= eps || c2 <= eps)
-        return { deltaH: 0, H: h1 + h2 };
-    let dh = h2 - h1;
-    const sumH = h1 + h2;
-    const absH = abs(dh);
-    dh = absH <= PI ? dh : h2 <= h1 ? dh + TAU : dh - TAU;
-    const deltaH = 2 * sqrt(c1 * c2) * sin(dh / 2);
-    const H = 0.5 * (absH <= PI ? sumH : sumH < TAU ? sumH + TAU : sumH - TAU);
-    return { deltaH, H };
+  const h1 = atan2Abs(b1, a1);
+  const h2 = atan2Abs(b2, a2);
+  if (c1 <= eps || c2 <= eps)
+    return { deltaH: 0, H: h1 + h2 };
+  let dh = h2 - h1;
+  const sumH = h1 + h2;
+  const absH = abs(dh);
+  dh = absH <= PI ? dh : h2 <= h1 ? dh + TAU : dh - TAU;
+  const deltaH = 2 * sqrt(c1 * c2) * sin(dh / 2);
+  const H = 0.5 * (absH <= PI ? sumH : sumH < TAU ? sumH + TAU : sumH - TAU);
+  return { deltaH, H };
 };
 const H35 = 35 * DEG2RAD;
 const H164 = 164 * DEG2RAD;
 const H168 = 168 * DEG2RAD;
 const H345 = 345 * DEG2RAD;
-/**
- * Higher order function to compute the CMC l:c (1984) difference measure
- * between 2 colors in the CIELAB (D65) space. Takes lightness and chroma weight
- * coefficients to adjust ratio of L:C. By default both are 1. Returns a
- * {@link ColorDistance} function which converts (if needed) input colors to
- * {@link LabD65} and then computes the metric.
- *
- * @remarks
- * Important: This formular is only a quasimetric & violates symmetry, i.e.
- * `distCMC(a, b) !== distCMC(b, a)`
- *
- * References:
- * - https://en.wikipedia.org/wiki/Color_difference#CMC_l:c_(1984)
- */
-export const distCMC = (kl = 1, kc = 1) => (a, b) => {
-    let { 0: l1, 1: a1, 2: b1 } = labD65(a);
-    let { 0: l2, 1: a2, 2: b2 } = labD65(b);
-    l1 *= 100;
-    a1 *= 100;
-    b1 *= 100;
-    l2 *= 100;
-    a2 *= 100;
-    b2 *= 100;
-    const c1 = hypot(a1, b1);
-    const c2 = hypot(a2, b2);
-    const dC = c1 - c2;
-    const dH = sqrt((a2 - a1) ** 2 + (b2 - b1) ** 2 - dC ** 2);
-    const h1 = atan2Abs(b1, a1);
-    const t = h1 >= H164 && h1 <= H345
-        ? 0.56 + abs(0.2 * cos(h1 + H168))
-        : 0.36 + abs(0.4 * cos(h1 + H35));
-    const c14 = c1 ** 4;
-    const f = sqrt(c14 / (c14 + 1900));
-    const Sl = l1 >= 16 ? (0.040975 * l1) / (1 + 0.01765 * l1) : 0.511;
-    const Sc = (0.0638 * c1) / (1 + 0.0131 * c1) + 0.638;
-    const Sh = Sc * (f * t + 1 - f);
-    return hypot((l1 - l2) / (kl * Sl), dC / (kc * Sc), dH / Sh);
+const distCMC = (kl = 1, kc = 1) => (a, b) => {
+  let { 0: l1, 1: a1, 2: b1 } = labD65(a);
+  let { 0: l2, 1: a2, 2: b2 } = labD65(b);
+  l1 *= 100;
+  a1 *= 100;
+  b1 *= 100;
+  l2 *= 100;
+  a2 *= 100;
+  b2 *= 100;
+  const c1 = hypot(a1, b1);
+  const c2 = hypot(a2, b2);
+  const dC = c1 - c2;
+  const dH = sqrt((a2 - a1) ** 2 + (b2 - b1) ** 2 - dC ** 2);
+  const h1 = atan2Abs(b1, a1);
+  const t = h1 >= H164 && h1 <= H345 ? 0.56 + abs(0.2 * cos(h1 + H168)) : 0.36 + abs(0.4 * cos(h1 + H35));
+  const c14 = c1 ** 4;
+  const f = sqrt(c14 / (c14 + 1900));
+  const Sl = l1 >= 16 ? 0.040975 * l1 / (1 + 0.01765 * l1) : 0.511;
+  const Sc = 0.0638 * c1 / (1 + 0.0131 * c1) + 0.638;
+  const Sh = Sc * (f * t + 1 - f);
+  return hypot((l1 - l2) / (kl * Sl), dC / (kc * Sc), dH / Sh);
+};
+export {
+  distCIEDE2000,
+  distCMC,
+  distChannel,
+  distEucledian3,
+  distEucledian4,
+  distHsv,
+  distHsvLuma,
+  distHsvSat,
+  distLch,
+  distRgbBlue,
+  distRgbGreen,
+  distRgbLuma,
+  distRgbRed,
+  distSrgbLuma
 };

package/gradients.js

@@ -3,43 +3,35 @@ import { setS4 } from "@thi.ng/vectors/sets";
 import { intArgb32Abgr32 } from "./int/int-int.js";
 import { argb32 } from "./int/int.js";
 import { mix as $mix } from "./mix.js";
-export function multiColorGradient(opts, isABGR) {
-    const cols = [...gradient(opts)];
-    if (isABGR === undefined)
-        return cols;
-    const rgba = cols.map((x) => argb32(x)[0]);
-    return isABGR ? rgba.map(intArgb32Abgr32) : rgba;
+function multiColorGradient(opts, isABGR) {
+  const cols = [...gradient(opts)];
+  if (isABGR === void 0)
+    return cols;
+  const rgba = cols.map((x) => argb32(x)[0]);
+  return isABGR ? rgba.map(intArgb32Abgr32) : rgba;
 }
-/**
- * Similar to {@link multiColorGradient}, but writes results into `buffer` from
- * given `offset` and component/element strides. Returns buffer.
- *
- * @remarks
- * Intended use case for this function: 1D texturemap/tonemap generation, e.g.
- * for dataviz etc. Also @see {@link cosineGradientBuffer}.
- *
- * @param opts -
- * @param buffer - target buffer/array
- * @param offset - start index (default: 0)
- * @param cstride - channel stride (default: 1)
- * @param estride - element stride (default: 4)
- */
-export const multiColorGradientBuffer = (opts, buffer = [], offset = 0, cstride = 1, estride = 4) => {
-    for (let col of gradient(opts)) {
-        setS4(buffer, col, offset, 0, cstride);
-        offset += estride;
-    }
-    return buffer;
+const multiColorGradientBuffer = (opts, buffer = [], offset = 0, cstride = 1, estride = 4) => {
+  for (let col of gradient(opts)) {
+    setS4(buffer, col, offset, 0, cstride);
+    offset += estride;
+  }
+  return buffer;
 };
-/** @internal */
-const gradient = ({ num, stops, easing, mix, }) => tween({
-    num: num - 1,
-    stops,
-    easing,
-    min: 0,
-    max: 1,
-    init: (a, b) => [a, b],
-    mix: mix
-        ? ([a, b], t) => mix(a.empty(), a, b, t)
-        : ([a, b], t) => $mix(a.empty(), a, b, t),
+const gradient = ({
+  num,
+  stops,
+  easing,
+  mix
+}) => tween({
+  num: num - 1,
+  stops,
+  easing,
+  min: 0,
+  max: 1,
+  init: (a, b) => [a, b],
+  mix: mix ? ([a, b], t) => mix(a.empty(), a, b, t) : ([a, b], t) => $mix(a.empty(), a, b, t)
 });
+export {
+  multiColorGradient,
+  multiColorGradientBuffer
+};

package/hcy/hcy-rgb.js

@@ -3,17 +3,24 @@ import { setC3 } from "@thi.ng/vectors/setc";
 import { __ensureAlpha } from "../internal/ensure.js";
 import { luminanceRgb } from "../luminance-rgb.js";
 import { hueRgb } from "../rgb/hue-rgb.js";
-export const hcyRgb = (out, src) => {
-    const h = src[0];
-    let c = src[1];
-    const y = src[2];
-    const rgb = hueRgb(out || src, h, __ensureAlpha(src[3]));
-    const lum = luminanceRgb(rgb);
-    if (y < lum) {
-        c *= y / lum;
-    }
-    else if (lum < 1) {
-        c *= (1 - y) / (1 - lum);
-    }
-    return setC3(rgb, clamp01((rgb[0] - lum) * c + y), clamp01((rgb[1] - lum) * c + y), clamp01((rgb[2] - lum) * c + y));
+const hcyRgb = (out, src) => {
+  const h = src[0];
+  let c = src[1];
+  const y = src[2];
+  const rgb = hueRgb(out || src, h, __ensureAlpha(src[3]));
+  const lum = luminanceRgb(rgb);
+  if (y < lum) {
+    c *= y / lum;
+  } else if (lum < 1) {
+    c *= (1 - y) / (1 - lum);
+  }
+  return setC3(
+    rgb,
+    clamp01((rgb[0] - lum) * c + y),
+    clamp01((rgb[1] - lum) * c + y),
+    clamp01((rgb[2] - lum) * c + y)
+  );
+};
+export {
+  hcyRgb
 };

package/hcy/hcy.js

@@ -4,15 +4,13 @@ import { labRgb } from "../lab/lab-rgb.js";
 import { rgbHcy } from "../rgb/rgb-hcy.js";
 import { rgbSrgb } from "../rgb/rgb-srgb.js";
 import { hcyRgb } from "./hcy-rgb.js";
-/**
- * @remarks
- * Note: As with other hue-based color modes in this package, the hue is stored
- * normalized (in [0..1] interval) and NOT as degrees.
- */
-export const hcy = defColor({
-    mode: "hcy",
-    channels: { h: { hue: true } },
-    order: ["h", "c", "y", "alpha"],
-    from: { rgb: rgbHcy, srgb: rgbHcy, lch: [lchLab, labRgb, rgbSrgb, rgbHcy] },
-    toRgb: hcyRgb,
+const hcy = defColor({
+  mode: "hcy",
+  channels: { h: { hue: true } },
+  order: ["h", "c", "y", "alpha"],
+  from: { rgb: rgbHcy, srgb: rgbHcy, lch: [lchLab, labRgb, rgbSrgb, rgbHcy] },
+  toRgb: hcyRgb
 });
+export {
+  hcy
+};

package/hsi/hsi-rgb.js

@@ -1,33 +1,35 @@
 import { setC3 } from "@thi.ng/vectors/setc";
 import { clampH } from "../clamp.js";
-// https://en.wikipedia.org/wiki/HSL_and_HSV#From_HSI
-export const hsiRgb = (out, src) => {
-    out = clampH(out || src, src);
-    const s = out[1];
-    const i = out[2];
-    if (s < 1e-6) {
-        return setC3(out, i, i, i);
-    }
-    const h = (out[0] * 6) % 6;
-    const m = i * (1 - s);
-    const z = 1 - Math.abs((h % 2) - 1);
-    let c = (3 * i * s) / (1 + z);
-    const x = c * z + m;
-    c += m;
-    switch (h | 0) {
-        case 0:
-            return setC3(out, c, x, m);
-        case 1:
-            return setC3(out, x, c, m);
-        case 2:
-            return setC3(out, m, c, x);
-        case 3:
-            return setC3(out, m, x, c);
-        case 4:
-            return setC3(out, x, m, c);
-        case 5:
-            return setC3(out, c, m, x);
-        default:
-            return setC3(out, m, m, m);
-    }
+const hsiRgb = (out, src) => {
+  out = clampH(out || src, src);
+  const s = out[1];
+  const i = out[2];
+  if (s < 1e-6) {
+    return setC3(out, i, i, i);
+  }
+  const h = out[0] * 6 % 6;
+  const m = i * (1 - s);
+  const z = 1 - Math.abs(h % 2 - 1);
+  let c = 3 * i * s / (1 + z);
+  const x = c * z + m;
+  c += m;
+  switch (h | 0) {
+    case 0:
+      return setC3(out, c, x, m);
+    case 1:
+      return setC3(out, x, c, m);
+    case 2:
+      return setC3(out, m, c, x);
+    case 3:
+      return setC3(out, m, x, c);
+    case 4:
+      return setC3(out, x, m, c);
+    case 5:
+      return setC3(out, c, m, x);
+    default:
+      return setC3(out, m, m, m);
+  }
+};
+export {
+  hsiRgb
 };

package/hsi/hsi.js

@@ -4,15 +4,13 @@ import { labRgb } from "../lab/lab-rgb.js";
 import { rgbHsi } from "../rgb/rgb-hsi.js";
 import { rgbSrgb } from "../rgb/rgb-srgb.js";
 import { hsiRgb } from "./hsi-rgb.js";
-/**
- * @remarks
- * Note: As with other hue-based color modes in this package, the hue is stored
- * normalized (in [0..1] interval) and NOT as degrees.
- */
-export const hsi = defColor({
-    mode: "hsi",
-    channels: { h: { hue: true } },
-    order: ["h", "s", "i", "alpha"],
-    from: { rgb: rgbHsi, srgb: rgbHsi, lch: [lchLab, labRgb, rgbSrgb, rgbHsi] },
-    toRgb: hsiRgb,
+const hsi = defColor({
+  mode: "hsi",
+  channels: { h: { hue: true } },
+  order: ["h", "s", "i", "alpha"],
+  from: { rgb: rgbHsi, srgb: rgbHsi, lch: [lchLab, labRgb, rgbSrgb, rgbHsi] },
+  toRgb: hsiRgb
 });
+export {
+  hsi
+};

package/hsl/hsl-css.js

@@ -2,14 +2,13 @@ import { clamp01 } from "@thi.ng/math/interval";
 import { fract } from "@thi.ng/math/prec";
 import { FF, PC } from "../api/constants.js";
 import { __ensureAlpha } from "../internal/ensure.js";
-export const hslCss = (src) => {
-    const h = FF(fract(src[0]) * 360);
-    const s = PC(clamp01(src[1]));
-    const l = PC(clamp01(src[2]));
-    const a = __ensureAlpha(src[3]);
-    // TODO update to new syntax once CSS Color L4 is more widely supported
-    // https://www.w3.org/TR/css-color-4/#serializing-lab-lch
-    // https://test.csswg.org/harness/results/css-color-4_dev/grouped/ (test reports)
-    // return `hsl(${h} ${s} ${l}` + (a < 1 ? `/${FF(a)})` : ")");
-    return a < 1 ? `hsla(${h},${s},${l},${FF(a)})` : `hsl(${h},${s},${l})`;
+const hslCss = (src) => {
+  const h = FF(fract(src[0]) * 360);
+  const s = PC(clamp01(src[1]));
+  const l = PC(clamp01(src[2]));
+  const a = __ensureAlpha(src[3]);
+  return a < 1 ? `hsla(${h},${s},${l},${FF(a)})` : `hsl(${h},${s},${l})`;
+};
+export {
+  hslCss
 };

package/hsl/hsl-hsv.js

@@ -1,11 +1,14 @@
 import { clampH } from "../clamp.js";
-export const hslHsv = (out, src) => {
-    out = clampH(out || src, src);
-    const s = out[1];
-    const l = out[2];
-    const l2 = 2 * l;
-    const v = (l2 + s * (1 - Math.abs(l2 - 1))) * 0.5;
-    out[1] = (2 * (v - l)) / v;
-    out[2] = v;
-    return out;
+const hslHsv = (out, src) => {
+  out = clampH(out || src, src);
+  const s = out[1];
+  const l = out[2];
+  const l2 = 2 * l;
+  const v = (l2 + s * (1 - Math.abs(l2 - 1))) * 0.5;
+  out[1] = 2 * (v - l) / v;
+  out[2] = v;
+  return out;
+};
+export {
+  hslHsv
 };

package/hsl/hsl-rgb.js

@@ -2,10 +2,18 @@ import { clamp01 } from "@thi.ng/math/interval";
 import { setC3 } from "@thi.ng/vectors/setc";
 import { hueRgb } from "../rgb/hue-rgb.js";
 import { __ensureAlpha } from "../internal/ensure.js";
-export const hslRgb = (out, src) => {
-    const s = clamp01(src[1]);
-    const l = clamp01(src[2]);
-    out = hueRgb(out || src, src[0], __ensureAlpha(src[3]));
-    const c = (1 - Math.abs(2 * l - 1)) * s;
-    return setC3(out, (out[0] - 0.5) * c + l, (out[1] - 0.5) * c + l, (out[2] - 0.5) * c + l);
+const hslRgb = (out, src) => {
+  const s = clamp01(src[1]);
+  const l = clamp01(src[2]);
+  out = hueRgb(out || src, src[0], __ensureAlpha(src[3]));
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  return setC3(
+    out,
+    (out[0] - 0.5) * c + l,
+    (out[1] - 0.5) * c + l,
+    (out[2] - 0.5) * c + l
+  );
+};
+export {
+  hslRgb
 };

package/hsl/hsl.js

@@ -5,20 +5,18 @@ import { labRgb } from "../lab/lab-rgb.js";
 import { rgbHsl } from "../rgb/rgb-hsl.js";
 import { rgbSrgb } from "../rgb/rgb-srgb.js";
 import { hslRgb } from "./hsl-rgb.js";
-/**
- * @remarks
- * Note: As with other hue-based color modes in this package, the hue is stored
- * normalized (in [0..1] interval) and NOT as degrees.
- */
-export const hsl = defColor({
-    mode: "hsl",
-    channels: { h: { hue: true } },
-    order: ["h", "s", "l", "alpha"],
-    from: {
-        rgb: rgbHsl,
-        srgb: rgbHsl,
-        hsv: hsvHsl,
-        lch: [lchLab, labRgb, rgbSrgb, rgbHsl],
-    },
-    toRgb: hslRgb,
+const hsl = defColor({
+  mode: "hsl",
+  channels: { h: { hue: true } },
+  order: ["h", "s", "l", "alpha"],
+  from: {
+    rgb: rgbHsl,
+    srgb: rgbHsl,
+    hsv: hsvHsl,
+    lch: [lchLab, labRgb, rgbSrgb, rgbHsl]
+  },
+  toRgb: hslRgb
 });
+export {
+  hsl
+};