@thi.ng/color 4.1.7 → 5.0.2

package/strategies.d.ts

@@ -0,0 +1,90 @@
+import { LCH } from "./lch/lch.js";
+/**
+ * Returns array of `src` color and its complementary color, possibly adjusted
+ * via optional `deltaL` and `deltaC` args (offsets for L & C channels).
+ *
+ * @param src -
+ * @param deltaL -
+ * @param deltaC -
+ */
+export declare const complementaryStrategy: (src: LCH, deltaL?: number | undefined, deltaC?: number | undefined) => LCH[];
+/**
+ * Returns array of `src` color and 2 neighboring colors, each ±rotated by
+ * normalized `theta` and possibly adjusted via optional `deltaL` and `deltaC`
+ * args (offsets for L & C channels).
+ *
+ * @param src -
+ * @param theta -
+ * @param deltaL -
+ * @param deltaC -
+ */
+export declare const analogStrategy: (src: LCH, theta?: number, deltaL?: number | undefined, deltaC?: number | undefined) => LCH[];
+/**
+ * Similar to {@link splitComplementaryStrategy}. Returns array of `src` color,
+ * its complementary color and 2 of that colors' neighbors, each ±rotated by
+ * normalized `theta` and possibly adjusted via optional `deltaL` and `deltaC`
+ * args (offsets for L & C channels).
+ *
+ * @param src -
+ * @param theta -
+ * @param deltaL -
+ * @param deltaC -
+ */
+export declare const splitAnalogStrategy: (src: LCH, theta?: number, deltaL?: number | undefined, deltaC?: number | undefined) => LCH[];
+/**
+ * Similar to {@link splitAnalogStrategy}. Returns array of `src` color and 2
+ * neighbors of its complementary color, each ±rotated by normalized `theta`
+ * (from the complementary hue) and possibly adjusted via optional `deltaL` and
+ * `deltaC` args (offsets for L & C channels).
+ *
+ * @param src -
+ * @param theta -
+ * @param deltaL -
+ * @param deltaC -
+ */
+export declare const splitComplementaryStrategy: (src: LCH, theta?: number, deltaL?: number | undefined, deltaC?: number | undefined) => LCH[];
+/**
+ * Returns array of 5 colors all sharing same hue and chromacity of given `src`
+ * color, but with these luminance settings: 0.0, 0.25, 0.5, 0.75, 1.0. Chroma
+ * can be adjusted via optional `deltaC` offset.
+ *
+ * @param src -
+ * @param deltaC -
+ */
+export declare const monochromeStrategy: (src: LCH, deltaC?: number) => LCH[];
+/**
+ * Version of {@link splitComplementaryStrategy} with an hardcoded `theta` of
+ * 1/6 to produce 3 colors with hues uniformly distributed on the color wheel
+ * (possibly adjusted via optional `deltaL` and `deltaC` args, aka offsets for L
+ * & C channels).
+ *
+ * @param src -
+ * @param deltaL -
+ * @param deltaC -
+ */
+export declare const triadicStrategy: (src: LCH, deltaL?: number | undefined, deltaC?: number | undefined) => LCH[];
+/**
+ * Returns array of `src` color and 3 other colors whose hues form a rectangle,
+ * using `theta` to define the angular separation. The hues are at: `src`,
+ * `src+theta`, `src+1/2` (complementary) and `src+1/2+theta`. Colors are
+ * possibly adjusted via optional `deltaL` and `deltaC` args (offsets for L & C
+ * channels).
+ *
+ * @param src -
+ * @param theta -
+ * @param deltaL -
+ * @param deltaC -
+ */
+export declare const tetradicStrategy: (src: LCH, theta?: number, deltaL?: number | undefined, deltaC?: number | undefined) => LCH[];
+/**
+ * Version of {@link tetradicStrategy} with an hardcoded `theta` of 1/4 to
+ * produce 4 colors with hues uniformly distributed on the color wheel (possibly
+ * adjusted via optional `deltaL` and `deltaC` args, aka offsets for L & C
+ * channels).
+ *
+ * @param src -
+ * @param deltaL -
+ * @param deltaC -
+ */
+export declare const squareStrategy: (src: LCH, deltaL?: number | undefined, deltaC?: number | undefined) => LCH[];
+//# sourceMappingURL=strategies.d.ts.map

package/strategies.js

@@ -0,0 +1,122 @@
+import { clamp, clamp01 } from "@thi.ng/math/interval";
+import { lch } from "./lch/lch.js";
+import { rotate } from "./rotate.js";
+const $ = (src, l = 0, c = 0) => {
+    src.l = clamp01(src.l + l);
+    src.c = clamp(src.c + c, 0, 1.312);
+    return src;
+};
+/**
+ * Returns array of `src` color and its complementary color, possibly adjusted
+ * via optional `deltaL` and `deltaC` args (offsets for L & C channels).
+ *
+ * @param src -
+ * @param deltaL -
+ * @param deltaC -
+ */
+export const complementaryStrategy = (src, deltaL, deltaC) => [src, $(rotate(lch(), src, 0.5), deltaL, deltaC)];
+/**
+ * Returns array of `src` color and 2 neighboring colors, each ±rotated by
+ * normalized `theta` and possibly adjusted via optional `deltaL` and `deltaC`
+ * args (offsets for L & C channels).
+ *
+ * @param src -
+ * @param theta -
+ * @param deltaL -
+ * @param deltaC -
+ */
+export const analogStrategy = (src, theta = 1 / 12, deltaL, deltaC) => [
+    src,
+    $(rotate(lch(), src, -theta), deltaL, deltaC),
+    $(rotate(lch(), src, theta), deltaL, deltaC),
+];
+/**
+ * Similar to {@link splitComplementaryStrategy}. Returns array of `src` color,
+ * its complementary color and 2 of that colors' neighbors, each ±rotated by
+ * normalized `theta` and possibly adjusted via optional `deltaL` and `deltaC`
+ * args (offsets for L & C channels).
+ *
+ * @param src -
+ * @param theta -
+ * @param deltaL -
+ * @param deltaC -
+ */
+export const splitAnalogStrategy = (src, theta = 1 / 12, deltaL, deltaC) => [
+    ...splitComplementaryStrategy(src, theta, deltaL, deltaC),
+    $(rotate(lch(), src, theta), deltaL, deltaC),
+];
+/**
+ * Similar to {@link splitAnalogStrategy}. Returns array of `src` color and 2
+ * neighbors of its complementary color, each ±rotated by normalized `theta`
+ * (from the complementary hue) and possibly adjusted via optional `deltaL` and
+ * `deltaC` args (offsets for L & C channels).
+ *
+ * @param src -
+ * @param theta -
+ * @param deltaL -
+ * @param deltaC -
+ */
+export const splitComplementaryStrategy = (src, theta = 1 / 12, deltaL, deltaC) => [
+    src,
+    $(rotate(lch(), src, 0.5 - theta), deltaL, deltaC),
+    $(rotate(lch(), src, 0.5 + theta), deltaL, deltaC),
+];
+/**
+ * Returns array of 5 colors all sharing same hue and chromacity of given `src`
+ * color, but with these luminance settings: 0.0, 0.25, 0.5, 0.75, 1.0. Chroma
+ * can be adjusted via optional `deltaC` offset.
+ *
+ * @param src -
+ * @param deltaC -
+ */
+export const monochromeStrategy = (src, deltaC = 0) => {
+    let [_, c, h, a] = src;
+    c = clamp(c + deltaC, 0, 1.312);
+    return [
+        lch(0.0, c, h, a),
+        lch(0.25, c, h, a),
+        lch(0.5, c, h, a),
+        lch(0.75, c, h, a),
+        lch(1, c, h, a),
+    ];
+};
+/**
+ * Version of {@link splitComplementaryStrategy} with an hardcoded `theta` of
+ * 1/6 to produce 3 colors with hues uniformly distributed on the color wheel
+ * (possibly adjusted via optional `deltaL` and `deltaC` args, aka offsets for L
+ * & C channels).
+ *
+ * @param src -
+ * @param deltaL -
+ * @param deltaC -
+ */
+export const triadicStrategy = (src, deltaL, deltaC) => splitComplementaryStrategy(src, 1 / 6, deltaL, deltaC);
+/**
+ * Returns array of `src` color and 3 other colors whose hues form a rectangle,
+ * using `theta` to define the angular separation. The hues are at: `src`,
+ * `src+theta`, `src+1/2` (complementary) and `src+1/2+theta`. Colors are
+ * possibly adjusted via optional `deltaL` and `deltaC` args (offsets for L & C
+ * channels).
+ *
+ * @param src -
+ * @param theta -
+ * @param deltaL -
+ * @param deltaC -
+ */
+export const tetradicStrategy = (src, theta = 1 / 12, deltaL, deltaC) => [
+    src,
+    $(rotate(lch(), src, theta), deltaL, deltaC),
+    $(rotate(lch(), src, 0.5), deltaL, deltaC),
+    $(rotate(lch(), src, 0.5 + theta), deltaL, deltaC),
+];
+/**
+ * Version of {@link tetradicStrategy} with an hardcoded `theta` of 1/4 to
+ * produce 4 colors with hues uniformly distributed on the color wheel (possibly
+ * adjusted via optional `deltaL` and `deltaC` args, aka offsets for L & C
+ * channels).
+ *
+ * @param src -
+ * @param deltaL -
+ * @param deltaC -
+ */
+export const squareStrategy = (src, deltaL, deltaC) => tetradicStrategy(src, 0.25, deltaL, deltaC);

package/tint.d.ts

@@ -0,0 +1,6 @@
+import type { MultiFn3O } from "@thi.ng/defmulti";
+import type { Color, TypedColor } from "./api.js";
+export declare const tint: MultiFn3O<Color | null, TypedColor<any>, number, number, Color>;
+export declare const tone: (out: Color | null, src: TypedColor<any>, n: number) => import("@thi.ng/vectors").Vec;
+export declare const shade: (out: Color | null, src: TypedColor<any>, n: number) => import("@thi.ng/vectors").Vec;
+//# sourceMappingURL=tint.d.ts.map

package/tint.js

@@ -0,0 +1,11 @@
+import { defmulti } from "@thi.ng/defmulti/defmulti";
+import { mix } from "@thi.ng/math/mix";
+import { setC4 } from "@thi.ng/vectors";
+import { __dispatch1 } from "./internal/dispatch.js";
+import { __ensureAlpha } from "./internal/ensure.js";
+export const tint = defmulti(__dispatch1, { hcy: "hsv", hsi: "hsv", hsl: "hsv" }, {
+    hsv: (out, src, n, l = 1) => setC4(out || src, src[0], src[1] * (1 - n), mix(src[2], l, n), __ensureAlpha(src[3])),
+    lch: (out, src, n, l = 1) => setC4(out || src, mix(src[0], l, n), src[1] * (1 - n), src[2], __ensureAlpha(src[3])),
+});
+export const tone = (out, src, n) => tint(out, src, n, 0.5);
+export const shade = (out, src, n) => tint(out, src, n, 0);

package/transform.d.ts

@@ -36,7 +36,7 @@ export declare const IDENTITY: ColorMatrix;
  *
  * @param src - source color
  */
-export declare const subtract: (src?: ReadonlyColor) => ColorMatrix;
+export declare const subtractMat: (src?: ReadonlyColor) => ColorMatrix;
 /**
  * Returns a transformation matrix which adds the given constant offset
  * `x` to RGB channels. Does NOT modify alpha channel.
@@ -46,14 +46,14 @@ export declare const subtract: (src?: ReadonlyColor) => ColorMatrix;
  *
  * @param x - brightness offset
  */
-export declare const brightness: (x: number) => ColorMatrix;
-export declare const contrast: (x: number, o?: number) => ColorMatrix;
-export declare const exposure: (x: number) => ColorMatrix;
-export declare const saturation: (x: number) => ColorMatrix;
-export declare const hueRotate: (theta: number) => ColorMatrix;
-export declare const temperature: (x: number) => ColorMatrix;
-export declare const sepia: (x?: number) => ColorMatrix;
-export declare const tint: (x: number) => ColorMatrix;
+export declare const brightnessMat: (x: number) => ColorMatrix;
+export declare const contrastMat: (x: number, o?: number) => ColorMatrix;
+export declare const exposureMat: (x: number) => ColorMatrix;
+export declare const saturationMat: (x: number) => ColorMatrix;
+export declare const hueRotateMat: (theta: number) => ColorMatrix;
+export declare const temperatureMat: (x: number) => ColorMatrix;
+export declare const sepiaMat: (x?: number) => ColorMatrix;
+export declare const tintMat: (x: number) => ColorMatrix;
 /**
  * Returns transformation matrix which computes luminance of user color
  * (optionally with custom coefficients). Does NOT modify alpha channel.
@@ -64,7 +64,7 @@ export declare const tint: (x: number) => ColorMatrix;
  * @param coeffs - luminance coefficients
  * @param offset - brightness offset
  */
-export declare const grayscale: ([r, g, b]?: number[], offset?: number) => ColorMatrix;
+export declare const grayscaleMat: ([r, g, b]?: number[], offset?: number) => ColorMatrix;
 /**
  * Returns transformation matrix which computes luminance of user color
  * (optionally with custom coefficients), uses result as alpha channel
@@ -75,5 +75,5 @@ export declare const grayscale: ([r, g, b]?: number[], offset?: number) => Color
  *
  * @param coeffs - luminance coefficients
  */
-export declare const luminanceAlpha: ([r, g, b]?: number[]) => ColorMatrix;
+export declare const luminanceAlphaMat: ([r, g, b]?: number[]) => ColorMatrix;
 //# sourceMappingURL=transform.d.ts.map

package/transform.js

@@ -55,7 +55,7 @@ export const IDENTITY = [
  * @param src - source color
  */
 // prettier-ignore
-export const subtract = (src = WHITE) => [
+export const subtractMat = (src = WHITE) => [
     -1, 0, 0, 0, src[0],
     0, -1, 0, 0, src[1],
     0, 0, -1, 0, src[2],
@@ -71,35 +71,35 @@ export const subtract = (src = WHITE) => [
  * @param x - brightness offset
  */
 // prettier-ignore
-export const brightness = (x) => [
+export const brightnessMat = (x) => [
     1, 0, 0, 0, x,
     0, 1, 0, 0, x,
     0, 0, 1, 0, x,
     0, 0, 0, 1, 0
 ];
 // prettier-ignore
-export const contrast = (x, o = 0.5 * (1 - x)) => [
+export const contrastMat = (x, o = 0.5 * (1 - x)) => [
     x, 0, 0, 0, o,
     0, x, 0, 0, o,
     0, 0, x, 0, o,
     0, 0, 0, 1, 0
 ];
 // prettier-ignore
-export const exposure = (x) => [
+export const exposureMat = (x) => [
     x, 0, 0, 0, 0,
     0, x, 0, 0, 0,
     0, 0, x, 0, 0,
     0, 0, 0, 1, 0
 ];
 // prettier-ignore
-export const saturation = (x) => [
+export const saturationMat = (x) => [
     S1 + S4 * x, S3 - S3 * x, S0 - S0 * x, 0, 0,
     S1 - S1 * x, S3 + S2 * x, S0 - S0 * x, 0, 0,
     S1 - S1 * x, S3 - S3 * x, S0 + S5 * x, 0, 0,
     0, 0, 0, 1, 0
 ];
 // prettier-ignore
-export const hueRotate = (theta) => {
+export const hueRotateMat = (theta) => {
     const s = Math.sin(theta);
     const c = Math.cos(theta);
     return [
@@ -110,21 +110,21 @@ export const hueRotate = (theta) => {
     ];
 };
 // prettier-ignore
-export const temperature = (x) => [
+export const temperatureMat = (x) => [
     1 + x, 0, 0, 0, 0,
     0, 1, 0, 0, 0,
     0, 0, 1 - x, 0, 0,
     0, 0, 0, 1, 0
 ];
 // prettier-ignore
-export const sepia = (x = 1) => [
+export const sepiaMat = (x = 1) => [
     mix(1, 0.393, x), 0.769 * x, 0.189 * x, 0, 0,
     0.349 * x, mix(1, 0.686, x), 0.168 * x, 0, 0,
     0.272 * x, 0.534 * x, mix(1, 0.131, x), 0, 0,
     0, 0, 0, 1, 0
 ];
 // prettier-ignore
-export const tint = (x) => [
+export const tintMat = (x) => [
     1 + x, 0, 0, 0, 0,
     0, 1, 0, 0, 0,
     0, 0, 1 + x, 0, 0,
@@ -141,7 +141,7 @@ export const tint = (x) => [
  * @param offset - brightness offset
  */
 // prettier-ignore
-export const grayscale = ([r, g, b] = RGB_LUMINANCE_REC709, offset = 0) => [
+export const grayscaleMat = ([r, g, b] = RGB_LUMINANCE_REC709, offset = 0) => [
     r, g, b, 0, offset,
     r, g, b, 0, offset,
     r, g, b, 0, offset,
@@ -158,7 +158,7 @@ export const grayscale = ([r, g, b] = RGB_LUMINANCE_REC709, offset = 0) => [
  * @param coeffs - luminance coefficients
  */
 // prettier-ignore
-export const luminanceAlpha = ([r, g, b] = RGB_LUMINANCE_REC709) => [
+export const luminanceAlphaMat = ([r, g, b] = RGB_LUMINANCE_REC709) => [
     0, 0, 0, 0, 0,
     0, 0, 0, 0, 0,
     0, 0, 0, 0, 0,

package/variations.d.ts

@@ -0,0 +1,29 @@
+import type { IRandom } from "@thi.ng/random";
+import type { TypedColor } from "./api.js";
+export interface VariationOpts {
+    /**
+     * Max. number of color variations to produce.
+     *
+     * @defaultValue Infinity
+     */
+    num: number;
+    /**
+     * Weights (given in same order as colors) for randomly selecting colors. By
+     * default colors will be chosen with uniform distribution.
+     */
+    weights: number[];
+    /**
+     * Normalized tolerance value for randomizing channel values
+     *
+     * @defaultValue 0.05
+     */
+    delta: number;
+    /**
+     * PRNG instance to use.
+     *
+     * @defaultValue SYSTEM (aka `Math.random()`)
+     */
+    rnd: IRandom;
+}
+export declare function variations<T extends TypedColor<any>>(src: T[], opts?: Partial<VariationOpts>): Generator<T, void, unknown>;
+//# sourceMappingURL=variations.d.ts.map

package/variations.js

@@ -0,0 +1,14 @@
+import { pickRandom } from "@thi.ng/random/pick-random";
+import { SYSTEM } from "@thi.ng/random/system";
+import { weightedRandom } from "@thi.ng/random/weighted-random";
+import { analog } from "./analog.js";
+export function* variations(src, opts) {
+    opts = { rnd: SYSTEM, delta: 0.05, num: Infinity, ...opts };
+    const pick = opts.weights
+        ? weightedRandom(src, opts.weights, opts.rnd)
+        : () => pickRandom(src, opts.rnd);
+    for (let i = opts.num; i-- > 0;) {
+        const col = pick();
+        yield analog(col.empty(), col, opts.delta, opts.rnd);
+    }
+}

package/xyy/xyy-xyz.d.ts

@@ -4,8 +4,8 @@ import type { ColorOp } from "../api.js";
  * https://en.wikipedia.org/wiki/CIE_1931_color_space#CIE_xy_chromaticity_diagram_and_the_CIE_xyY_color_space
  * https://gamedev.stackexchange.com/a/70049
  *
- * @param out
- * @param src
+ * @param out -
+ * @param src -
  */
 export declare const xyyXyz: ColorOp;
 //# sourceMappingURL=xyy-xyz.d.ts.map

package/xyy/xyy-xyz.js

@@ -6,8 +6,8 @@ import { __ensureAlpha } from "../internal/ensure.js";
  * https://en.wikipedia.org/wiki/CIE_1931_color_space#CIE_xy_chromaticity_diagram_and_the_CIE_xyY_color_space
  * https://gamedev.stackexchange.com/a/70049
  *
- * @param out
- * @param src
+ * @param out -
+ * @param src -
  */
 export const xyyXyz = (out, src) => {
     const { 0: x, 1: y, 2: Y } = src;

package/xyz/wavelength-xyz.d.ts

@@ -14,9 +14,9 @@ import { XYZD65 } from "./xyz65.js";
  * - 570 => yellow
  * - 610 => red
  *
- * @param out
- * @param lambda
- * @param alpha
+ * @param out -
+ * @param lambda -
+ * @param alpha -
  */
 export declare const wavelengthXyz: (out: XYZD65 | null, lambda: number, alpha?: number) => XYZD65;
 //# sourceMappingURL=wavelength-xyz.d.ts.map

package/xyz/wavelength-xyz.js

@@ -15,9 +15,9 @@ import { xyzD65 } from "./xyz65.js";
  * - 570 => yellow
  * - 610 => red
  *
- * @param out
- * @param lambda
- * @param alpha
+ * @param out -
+ * @param lambda -
+ * @param alpha -
  */
 export const wavelengthXyz = (out, lambda, alpha = 1) => {
     lambda *= 10;

package/xyz/xyz-lab.d.ts

@@ -7,16 +7,16 @@ import type { Color, ColorOp, ReadonlyColor } from "../api.js";
  * Important: We're using a normalized Lab space w/ all three coordinates
  * divided by 100 (normalized to 100% luminance).
  *
- * @param out
- * @param src
- * @param white
+ * @param out -
+ * @param src -
+ * @param white -
  */
 export declare const xyzLab: (out: Color | null, src: ReadonlyColor, white?: number[]) => import("@thi.ng/vectors").Vec;
 /**
  * Same as {@link xyzLab}, but hard coded to use {@link D65} white point.
  *
- * @param out
- * @param src
+ * @param out -
+ * @param src -
  */
 export declare const xyzLabD65: ColorOp;
 //# sourceMappingURL=xyz-lab.d.ts.map

package/xyz/xyz-lab.js

@@ -11,9 +11,9 @@ const transform = (x) => x > 0.00885645 ? Math.cbrt(x) : 7.787037 * x + 16 / 116
  * Important: We're using a normalized Lab space w/ all three coordinates
  * divided by 100 (normalized to 100% luminance).
  *
- * @param out
- * @param src
- * @param white
+ * @param out -
+ * @param src -
+ * @param white -
  */
 export const xyzLab = (out, src, white = D50) => {
     const x = transform(src[0] / white[0]);
@@ -24,7 +24,7 @@ export const xyzLab = (out, src, white = D50) => {
 /**
  * Same as {@link xyzLab}, but hard coded to use {@link D65} white point.
  *
- * @param out
- * @param src
+ * @param out -
+ * @param src -
  */
 export const xyzLabD65 = (out, src) => xyzLab(out, src, D65);

package/xyz/xyz-rgb.d.ts

@@ -13,8 +13,8 @@ export declare const xyzRgb: (out: Color | null, src: ReadonlyColor, mat?: numbe
  * Same as {@link xyzRgb}, but hard coded to use {@link D65} white point (via
  * {@link XYZ_RGB_D65} matrix).
  *
- * @param out
- * @param src
+ * @param out -
+ * @param src -
  */
 export declare const xyzRgbD65: ColorOp;
 //# sourceMappingURL=xyz-rgb.d.ts.map

package/xyz/xyz-rgb.js

@@ -14,7 +14,7 @@ export const xyzRgb = (out, src, mat = XYZ_RGB_D50) => __mulV33(out, mat, src);
  * Same as {@link xyzRgb}, but hard coded to use {@link D65} white point (via
  * {@link XYZ_RGB_D65} matrix).
  *
- * @param out
- * @param src
+ * @param out -
+ * @param src -
  */
 export const xyzRgbD65 = (out, src) => xyzRgb(out, src, XYZ_RGB_D65);

package/xyz/xyz-xyy.d.ts

@@ -4,8 +4,8 @@ import type { ColorOp } from "../api.js";
  * https://en.wikipedia.org/wiki/CIE_1931_color_space#CIE_xy_chromaticity_diagram_and_the_CIE_xyY_color_space
  * https://gamedev.stackexchange.com/a/70049
  *
- * @param out
- * @param src
+ * @param out -
+ * @param src -
  */
 export declare const xyzXyy: ColorOp;
 //# sourceMappingURL=xyz-xyy.d.ts.map

package/xyz/xyz-xyy.js

@@ -6,8 +6,8 @@ import { __ensureAlpha } from "../internal/ensure.js";
  * https://en.wikipedia.org/wiki/CIE_1931_color_space#CIE_xy_chromaticity_diagram_and_the_CIE_xyY_color_space
  * https://gamedev.stackexchange.com/a/70049
  *
- * @param out
- * @param src
+ * @param out -
+ * @param src -
  */
 export const xyzXyy = (out, src) => {
     const { 0: x, 1: Y } = src;

package/ycc/ycc-rgb.d.ts

@@ -9,9 +9,9 @@ import type { Color, ReadonlyColor } from "../api.js";
  * - https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.709_conversion
  * - https://en.wikipedia.org/wiki/Rec._709
  *
- * @param out
- * @param src
- * @param luma
+ * @param out -
+ * @param src -
+ * @param luma -
  */
 export declare const yccRgb: (out: Color | null, src: ReadonlyColor, luma?: number[]) => import("@thi.ng/vectors").Vec;
 //# sourceMappingURL=ycc-rgb.d.ts.map

package/ycc/ycc-rgb.js

@@ -11,9 +11,9 @@ import { __ensureAlpha } from "../internal/ensure.js";
  * - https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.709_conversion
  * - https://en.wikipedia.org/wiki/Rec._709
  *
- * @param out
- * @param src
- * @param luma
+ * @param out -
+ * @param src -
+ * @param luma -
  */
 export const yccRgb = (out, src, luma = RGB_LUMINANCE_REC709) => {
     const y = src[0];