@thi.ng/color 5.6.2 → 5.6.4

package/rgb/rgb-hsv.js

@@ -1,7 +1,10 @@
 import { EPS } from "@thi.ng/math/api";
 import { rgbHcv } from "./rgb-hcv.js";
-export const rgbHsv = (out, src) => {
-    out = rgbHcv(out, src);
-    out[1] /= out[2] + EPS;
-    return out;
+const rgbHsv = (out, src) => {
+  out = rgbHcv(out, src);
+  out[1] /= out[2] + EPS;
+  return out;
+};
+export {
+  rgbHsv
 };

package/rgb/rgb-lab.js

@@ -1,20 +1,8 @@
 import { rgbXyz, rgbXyzD65 } from "./rgb-xyz.js";
 import { xyzLab, xyzLabD65 } from "../xyz/xyz-lab.js";
-/**
- * Converts linear RGB to Lab (via XYZ) using {@link D50} white point.
- *
- * @remarks
- * Important: We're using a normalized Lab space w/ all three coordinates
- * divided by 100 (normalized to 100% luminance).
- *
- * @param out -
- * @param src -
- */
-export const rgbLab = (out, src) => xyzLab(null, rgbXyz(out, src));
-/**
- * Same as {@link rgbLab}, but using {@link D65} white point.
- *
- * @param out -
- * @param src -
- */
-export const rgbLabD65 = (out, src) => xyzLabD65(null, rgbXyzD65(out, src));
+const rgbLab = (out, src) => xyzLab(null, rgbXyz(out, src));
+const rgbLabD65 = (out, src) => xyzLabD65(null, rgbXyzD65(out, src));
+export {
+  rgbLab,
+  rgbLabD65
+};

package/rgb/rgb-oklab.js

@@ -1,24 +1,18 @@
 import { powN3 } from "@thi.ng/vectors/pown";
 import { OKLAB_M2 } from "../api/constants.js";
 import { __mulV33 } from "../internal/matrix-ops.js";
-/**
- * @remarks
- * Reference:
- * - https://bottosson.github.io/posts/oklab/#converting-from-linear-srgb-to-oklab
- *
- * @internal
- */
-// prettier-ignore
 const CONE_LMS = [
-    0.4122214708, 0.2119034982, 0.0883024619,
-    0.5363325363, 0.6806995451, 0.2817188376,
-    0.0514459929, 0.1073969566, 0.6299787005,
+  0.4122214708,
+  0.2119034982,
+  0.0883024619,
+  0.5363325363,
+  0.6806995451,
+  0.2817188376,
+  0.0514459929,
+  0.1073969566,
+  0.6299787005
 ];
-/**
- * @remarks
- * Reference: https://bottosson.github.io/posts/oklab/
- *
- * @param out -
- * @param src -
- */
-export const rgbOklab = (out, src) => __mulV33(null, OKLAB_M2, powN3(null, __mulV33(out, CONE_LMS, src), 1 / 3));
+const rgbOklab = (out, src) => __mulV33(null, OKLAB_M2, powN3(null, __mulV33(out, CONE_LMS, src), 1 / 3));
+export {
+  rgbOklab
+};

package/rgb/rgb-srgb.js

@@ -1,12 +1,22 @@
 import { setC4 } from "@thi.ng/vectors/setc";
 import { __ensureAlpha } from "../internal/ensure.js";
 import { linearSrgb } from "../linear.js";
-/**
- * Converts linear RGB to sRGB.
- *
- * @param out - result
- * @param src - source color
- */
-export const rgbSrgb = (out, src) => setC4(out || src, linearSrgb(src[0]), linearSrgb(src[1]), linearSrgb(src[2]), __ensureAlpha(src[3]));
+const rgbSrgb = (out, src) => setC4(
+  out || src,
+  linearSrgb(src[0]),
+  linearSrgb(src[1]),
+  linearSrgb(src[2]),
+  __ensureAlpha(src[3])
+);
 const GAMMA = 1 / 2.2;
-export const rgbSrgbApprox = (out, src) => setC4(out || src, src[0] ** GAMMA, src[1] ** GAMMA, src[2] ** GAMMA, __ensureAlpha(src[3]));
+const rgbSrgbApprox = (out, src) => setC4(
+  out || src,
+  src[0] ** GAMMA,
+  src[1] ** GAMMA,
+  src[2] ** GAMMA,
+  __ensureAlpha(src[3])
+);
+export {
+  rgbSrgb,
+  rgbSrgbApprox
+};

package/rgb/rgb-xyz.js

@@ -1,22 +1,9 @@
 import { RGB_XYZ_D50, RGB_XYZ_D65 } from "../api/constants.js";
 import { clamp } from "../clamp.js";
 import { __mulV33 } from "../internal/matrix-ops.js";
-/**
- * Converts RGB to XYZ using provided transformation matrix (default:
- * {@link RGB_XYZ_D50}).
- *
- * https://en.wikipedia.org/wiki/CIE_1931_color_space
- *
- * @param out - result
- * @param src - source color
- * @param mat - transform matrix
- */
-export const rgbXyz = (out, src, mat = RGB_XYZ_D50) => __mulV33(null, mat, clamp(out, src));
-/**
- * Same as {@link rgbXyz}, but hard coded to use {@link D65} white point (via
- * {@link RGB_XYZ_D65} matrix).
- *
- * @param out -
- * @param src -
- */
-export const rgbXyzD65 = (out, src) => rgbXyz(out, src, RGB_XYZ_D65);
+const rgbXyz = (out, src, mat = RGB_XYZ_D50) => __mulV33(null, mat, clamp(out, src));
+const rgbXyzD65 = (out, src) => rgbXyz(out, src, RGB_XYZ_D65);
+export {
+  rgbXyz,
+  rgbXyzD65
+};

package/rgb/rgb-ycc.js

@@ -2,21 +2,16 @@ import { dot3 } from "@thi.ng/vectors/dot";
 import { setC4 } from "@thi.ng/vectors/setc";
 import { RGB_LUMINANCE_REC709 } from "../api/constants.js";
 import { __ensureAlpha } from "../internal/ensure.js";
-/**
- * @remarks
- * https://en.wikipedia.org/wiki/YCbCr#YCbCr
- *
- * By default uses luminance weights as per BT.709 (aka
- * {@link RGB_LUMINANCE_REC709}):
- *
- * - https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.709_conversion
- * - https://en.wikipedia.org/wiki/Rec._709
- *
- * @param out -
- * @param src -
- * @param luma -
- */
-export const rgbYcc = (out, src, luma = RGB_LUMINANCE_REC709) => {
-    const y = dot3(src, luma);
-    return setC4(out || src, y, (0.5 * (src[2] - y)) / (1 - luma[2]), (0.5 * (src[0] - y)) / (1 - luma[0]), __ensureAlpha(src[3]));
+const rgbYcc = (out, src, luma = RGB_LUMINANCE_REC709) => {
+  const y = dot3(src, luma);
+  return setC4(
+    out || src,
+    y,
+    0.5 * (src[2] - y) / (1 - luma[2]),
+    0.5 * (src[0] - y) / (1 - luma[0]),
+    __ensureAlpha(src[3])
+  );
+};
+export {
+  rgbYcc
 };

package/rgb/rgb.js

@@ -12,26 +12,29 @@ import { srgbRgb } from "../srgb/srgb-rgb.js";
 import { xyyXyz } from "../xyy/xyy-xyz.js";
 import { xyzRgb, xyzRgbD65 } from "../xyz/xyz-rgb.js";
 import { yccRgb } from "../ycc/ycc-rgb.js";
-export const rgb = defColor({
-    mode: "rgb",
-    order: ["r", "g", "b", "alpha"],
-    from: {
-        abgr32: (out, src) => intAbgr32Rgb(out, src[0]),
-        argb32: (out, src) => intArgb32Rgb(out, src[0]),
-        hcy: hcyRgb,
-        hsi: hsiRgb,
-        hsl: hslRgb,
-        hsv: hsvRgb,
-        lab50: labRgb,
-        lab65: labRgbD65,
-        lch: [lchLab, labRgb],
-        oklab: oklabRgb,
-        rgb: set4,
-        srgb: srgbRgb,
-        xyy: [xyyXyz, xyzRgbD65],
-        xyz50: xyzRgb,
-        xyz65: xyzRgbD65,
-        ycc: yccRgb,
-    },
-    toRgb: set4,
+const rgb = defColor({
+  mode: "rgb",
+  order: ["r", "g", "b", "alpha"],
+  from: {
+    abgr32: (out, src) => intAbgr32Rgb(out, src[0]),
+    argb32: (out, src) => intArgb32Rgb(out, src[0]),
+    hcy: hcyRgb,
+    hsi: hsiRgb,
+    hsl: hslRgb,
+    hsv: hsvRgb,
+    lab50: labRgb,
+    lab65: labRgbD65,
+    lch: [lchLab, labRgb],
+    oklab: oklabRgb,
+    rgb: set4,
+    srgb: srgbRgb,
+    xyy: [xyyXyz, xyzRgbD65],
+    xyz50: xyzRgb,
+    xyz65: xyzRgbD65,
+    ycc: yccRgb
+  },
+  toRgb: set4
 });
+export {
+  rgb
+};

package/rotate.js

@@ -3,41 +3,28 @@ import { fract } from "@thi.ng/math/prec";
 import { setC4 } from "@thi.ng/vectors/setc";
 import { __dispatch1 } from "./internal/dispatch.js";
 import { __ensureAlpha } from "./internal/ensure.js";
-/**
- * Color rotation. Rotates hue by given `theta` and writes result color into
- * `out`.
- *
- * @remarks
- * If `out` is null, the resulting will be written back into `src`.
- *
- * As with all hue-based color modes in this package, the hue is stored
- * normalized (in [0..1] interval) and NOT as degrees. The same goes for the
- * rotation angle `theta`.
- *
- * Only supported for hue based color modes:
- *
- * - hcy
- * - hsi
- * - hsl
- * - hsv
- * - lch
- * - oklch
- *
- * @param out
- * @param src
- * @param theta
- */
-export const rotate = defmulti(__dispatch1, { hcy: "hsl", hsi: "hsl", hsv: "hsl", oklch: "lch" }, {
-    hsl: (out, src, theta) => setC4(out || src, fract(src[0] + theta), src[1], src[2], __ensureAlpha(src[3])),
-    lch: (out, src, theta) => setC4(out || src, src[0], src[1], fract(src[2] + theta), __ensureAlpha(src[3])),
-});
-/**
- * Syntax sugar for {@link rotate} with 180 degree rotation.
- *
- * @remarks
- * If `out` is null, the resulting color will be written back into `src`.
- *
- * @param out
- * @param src
- */
-export const complementary = (out, src) => rotate(out, src, 0.5);
+const rotate = defmulti(
+  __dispatch1,
+  { hcy: "hsl", hsi: "hsl", hsv: "hsl", oklch: "lch" },
+  {
+    hsl: (out, src, theta) => setC4(
+      out || src,
+      fract(src[0] + theta),
+      src[1],
+      src[2],
+      __ensureAlpha(src[3])
+    ),
+    lch: (out, src, theta) => setC4(
+      out || src,
+      src[0],
+      src[1],
+      fract(src[2] + theta),
+      __ensureAlpha(src[3])
+    )
+  }
+);
+const complementary = (out, src) => rotate(out, src, 0.5);
+export {
+  complementary,
+  rotate
+};

package/sort.js

@@ -5,77 +5,29 @@ import { swap } from "@thi.ng/arrays/swap";
 import { compareNumAsc, compareNumDesc } from "@thi.ng/compare/numeric";
 import { distEucledian3 } from "./distance.js";
 import { intAbgr32Srgb } from "./int/int-srgb.js";
-export const selectChannel = (id) => (col) => col[id];
-/**
- * Takes a `target` color and optional `distance` function (default:
- * {@link distEucledian3}). Returns a new function which can be used as `key`
- * function for {@link sort} to compute the distance metric of a color to the
- * given `target`.
- *
- * @param target -
- * @param dist -
- */
-export const proximity = (target, dist = distEucledian3) => (col) => dist(target, col);
-/**
- * Similar to {@link proximity}, but intended as syntax sugar for {@link ABGR}
- * input colors. The proximity will still be computed using given distance
- * function (default: {@link distEucledian3}) and will be in sRGB space. Hence
- * given `target` color should be provided in the same space too.
- *
- * @param target -
- * @param dist -
- */
-export const proximityABGR32 = (target, dist = distEucledian3) => (col) => dist(target, intAbgr32Srgb([], col[0]));
-export const sort = (colors, key, isReverse = false) => sortByCachedKey(colors, key, isReverse ? compareNumDesc : compareNumAsc);
-/**
- * Similar to {@link sort}, but only for memory mapped colors (e.g. mapping a
- * pixel buffer). Does NOT change the order of elements in given `colors` array,
- * BUT sorts the **apparent** order by swapping the contents of the backing
- * memory.
- *
- * ```ts
- * // memory buffer of 4 sRGB colors
- * const buf = new Float32Array([0,1,0,1, 0,0.5,0,1, 0,0.25,0,1, 0,0.75,0,1]);
- *
- * // map buffer (creates 4 SRGB instances linked to the buffer)
- * const pix = srgb.mapBuffer(buf);
- *
- * // display original order
- * pix.map(css);
- * // [ '#00ff00', '#008000', '#004000', '#00bf00' ]
- *
- * // sort colors (buffer!) by luminance
- * sortMapped(pix, luminanceSrgb);
- *
- * // new order
- * pix.map(css);
- * // [ '#004000', '#008000', '#00bf00', '#00ff00' ]
- *
- * // buffer contents have been re-ordered
- * buf
- * // Float32Array(16) [
- * //     0, 0.25, 0, 1,    0,
- * //   0.5,    0, 1, 0, 0.75,
- * //     0,    1, 0, 1,    0,
- * //     1
- * // ]
- * ```
- *
- * @param colors -
- * @param key -
- * @param isReverse -
- */
-export const sortMapped = (colors, key, isReverse = false) => {
-    if (!colors.length)
-        return colors;
-    const keys = colors.map(key);
-    const tmp = typedArray(typedArrayType(colors[0].buf), colors[0].length);
-    quickSort(keys, isReverse ? compareNumDesc : compareNumAsc, (_, x, y) => {
-        swap(keys, x, y);
-        tmp.set(colors[x]);
-        colors[x].set(colors[y]);
-        colors[y].set(tmp);
-    });
+const selectChannel = (id) => (col) => col[id];
+const proximity = (target, dist = distEucledian3) => (col) => dist(target, col);
+const proximityABGR32 = (target, dist = distEucledian3) => (col) => dist(target, intAbgr32Srgb([], col[0]));
+const sort = (colors, key, isReverse = false) => sortByCachedKey(colors, key, isReverse ? compareNumDesc : compareNumAsc);
+const sortMapped = (colors, key, isReverse = false) => {
+  if (!colors.length)
     return colors;
+  const keys = colors.map(key);
+  const tmp = typedArray(typedArrayType(colors[0].buf), colors[0].length);
+  quickSort(keys, isReverse ? compareNumDesc : compareNumAsc, (_, x, y) => {
+    swap(keys, x, y);
+    tmp.set(colors[x]);
+    colors[x].set(colors[y]);
+    colors[y].set(tmp);
+  });
+  return colors;
+};
+const mostSimilar = (colors, key) => sort(colors.slice(), key)[0];
+export {
+  mostSimilar,
+  proximity,
+  proximityABGR32,
+  selectChannel,
+  sort,
+  sortMapped
 };
-export const mostSimilar = (colors, key) => sort(colors.slice(), key)[0];

package/srgb/srgb-css.js

@@ -2,13 +2,13 @@ import { U24 } from "@thi.ng/strings/radix";
 import { FF } from "../api/constants.js";
 import { __ensureAlpha } from "../internal/ensure.js";
 import { __scale8bit } from "../internal/scale.js";
-export const srgbCss = (src) => {
-    const r = __scale8bit(src[0]);
-    const g = __scale8bit(src[1]);
-    const b = __scale8bit(src[2]);
-    const a = __ensureAlpha(src[3]);
-    // TODO update to `rgb(${r} ${g} ${b}/${FF(a)})` (CSS L4 syntax)
-    return a < 1
-        ? `rgba(${r},${g},${b},${FF(a)})`
-        : `#${U24((r << 16) | (g << 8) | b)}`;
+const srgbCss = (src) => {
+  const r = __scale8bit(src[0]);
+  const g = __scale8bit(src[1]);
+  const b = __scale8bit(src[2]);
+  const a = __ensureAlpha(src[3]);
+  return a < 1 ? `rgba(${r},${g},${b},${FF(a)})` : `#${U24(r << 16 | g << 8 | b)}`;
+};
+export {
+  srgbCss
 };

package/srgb/srgb-int.js

@@ -1,12 +1,8 @@
 import { clamp01 } from "@thi.ng/math/interval";
 import { __ensureAlpha } from "../internal/ensure.js";
-export const srgbIntArgb32 = (src) => (((__ensureAlpha(src[3]) * 0xff + 0.5) << 24) |
-    ((clamp01(src[0]) * 0xff + 0.5) << 16) |
-    ((clamp01(src[1]) * 0xff + 0.5) << 8) |
-    (clamp01(src[2]) * 0xff + 0.5)) >>>
-    0;
-export const srgbIntAbgr32 = (src) => (((__ensureAlpha(src[3]) * 0xff + 0.5) << 24) |
-    ((clamp01(src[2]) * 0xff + 0.5) << 16) |
-    ((clamp01(src[1]) * 0xff + 0.5) << 8) |
-    (clamp01(src[0]) * 0xff + 0.5)) >>>
-    0;
+const srgbIntArgb32 = (src) => (__ensureAlpha(src[3]) * 255 + 0.5 << 24 | clamp01(src[0]) * 255 + 0.5 << 16 | clamp01(src[1]) * 255 + 0.5 << 8 | clamp01(src[2]) * 255 + 0.5) >>> 0;
+const srgbIntAbgr32 = (src) => (__ensureAlpha(src[3]) * 255 + 0.5 << 24 | clamp01(src[2]) * 255 + 0.5 << 16 | clamp01(src[1]) * 255 + 0.5 << 8 | clamp01(src[0]) * 255 + 0.5) >>> 0;
+export {
+  srgbIntAbgr32,
+  srgbIntArgb32
+};

package/srgb/srgb-rgb.js

@@ -1,12 +1,22 @@
 import { setC4 } from "@thi.ng/vectors/setc";
 import { __ensureAlpha } from "../internal/ensure.js";
 import { srgbLinear } from "../linear.js";
-/**
- * Converts sRGB to linear RGB.
- *
- * @param out - result
- * @param src - source color
- */
-export const srgbRgb = (out, src) => setC4(out || src, srgbLinear(src[0]), srgbLinear(src[1]), srgbLinear(src[2]), __ensureAlpha(src[3]));
+const srgbRgb = (out, src) => setC4(
+  out || src,
+  srgbLinear(src[0]),
+  srgbLinear(src[1]),
+  srgbLinear(src[2]),
+  __ensureAlpha(src[3])
+);
 const GAMMA = 2.2;
-export const srgbRgbApprox = (out, src) => setC4(out || src, src[0] ** GAMMA, src[1] ** GAMMA, src[2] ** GAMMA, __ensureAlpha(src[3]));
+const srgbRgbApprox = (out, src) => setC4(
+  out || src,
+  src[0] ** GAMMA,
+  src[1] ** GAMMA,
+  src[2] ** GAMMA,
+  __ensureAlpha(src[3])
+);
+export {
+  srgbRgb,
+  srgbRgbApprox
+};

package/srgb/srgb.js

@@ -6,17 +6,20 @@ import { hsvRgb } from "../hsv/hsv-rgb.js";
 import { intAbgr32Srgb, intArgb32Srgb } from "../int/int-srgb.js";
 import { rgbSrgb } from "../rgb/rgb-srgb.js";
 import { srgbRgb } from "./srgb-rgb.js";
-export const srgb = defColor({
-    mode: "srgb",
-    order: ["r", "g", "b", "alpha"],
-    from: {
-        abgr32: (out, src) => intAbgr32Srgb(out, src[0]),
-        argb32: (out, src) => intArgb32Srgb(out, src[0]),
-        hcy: hcyRgb,
-        hsi: hsiRgb,
-        hsl: hslRgb,
-        hsv: hsvRgb,
-        rgb: rgbSrgb,
-    },
-    toRgb: srgbRgb,
+const srgb = defColor({
+  mode: "srgb",
+  order: ["r", "g", "b", "alpha"],
+  from: {
+    abgr32: (out, src) => intAbgr32Srgb(out, src[0]),
+    argb32: (out, src) => intArgb32Srgb(out, src[0]),
+    hcy: hcyRgb,
+    hsi: hsiRgb,
+    hsl: hslRgb,
+    hsv: hsvRgb,
+    rgb: rgbSrgb
+  },
+  toRgb: srgbRgb
 });
+export {
+  srgb
+};