@thi.ng/color 5.3.3 → 5.4.1

package/css/parse-css.js

@@ -1,3 +1,4 @@
+import { rotateRight } from "@thi.ng/binary/rotate";
 import { interleave4_12_24, interleave4_16_32 } from "@thi.ng/binary/splat";
 import { isString } from "@thi.ng/checks/is-string";
 import { assert } from "@thi.ng/errors/assert";
@@ -7,6 +8,7 @@ import { TAU } from "@thi.ng/math/api";
 import { clamp01 } from "@thi.ng/math/interval";
 import { fract } from "@thi.ng/math/prec";
 import { ParsedColor } from "../api.js";
+import { INV8BIT } from "../api/constants.js";
 import { CSS_NAMES } from "../api/names.js";
 import { CSS_SYSTEM_COLORS } from "../api/system.js";
 import { intArgb32Srgb } from "../int/int-srgb.js";
@@ -29,11 +31,21 @@ import { intArgb32Srgb } from "../int/int-srgb.js";
  * - `hsl(h,s%,l%)`
  * - `hsla(h,s%,l%,a)`
  * - `lab(l a b / alpha?)`
+ * - `lab(l% a% b% / alpha?)`
  * - `lch(l c h / alpha?)`
+ * - `lch(l% c% h / alpha?)`
+ * - `oklab(l a b / alpha?)`
+ * - `oklab(l% a% b% / alpha?)`
+ * - `oklch(l c h / alpha?)`
+ * - `oklch(l% c% h / alpha?)`
  *
  * Hue values can be given according to CSS Color L4 spec (raw, deg, rad, grad,
  * turn): https://www.w3.org/TR/css-color-4/#typedef-hue
  *
+ * For (ok)lab/(ok)lch color channel values given as percentages, the scale
+ * ranges defined in the spec are used:
+ * https://www.w3.org/TR/css-color-4/#specifying-lab-lch
+ *
  * If no alpha channel is given, it will default to 1.0 (fully opaque).
  *
  * Note that any named or system CSS colors, hex colors and any RGB colors will
@@ -52,82 +64,120 @@ export const parseCss = (src) => {
         return new ParsedColor("srgb", intArgb32Srgb([], parseHex(named || src)));
     const parts = src.split(/[(),/ ]+/);
     const [mode, a, b, c, d] = parts;
-    assert(parts.length === 5 || parts.length === 6, `invalid ${mode} color: ${src}`);
+    assert(parts.length === 5 || parts.length === 6, `invalid color: ${src}`);
     switch (mode) {
         case "rgb":
         case "rgba":
             return new ParsedColor("srgb", [
-                parseNumOrPercent(a),
-                parseNumOrPercent(b),
-                parseNumOrPercent(c),
-                parseAlpha(d),
+                __numOrPercent(a, 1, INV8BIT, true),
+                __numOrPercent(b, 1, INV8BIT, true),
+                __numOrPercent(c, 1, INV8BIT, true),
+                __alpha(d),
             ]);
         case "hsl":
         case "hsla":
             return new ParsedColor("hsl", [
-                parseHue(a),
-                parsePercent(b),
-                parsePercent(c),
-                parseAlpha(d),
+                __hue(a),
+                __percent(b),
+                __percent(c),
+                __alpha(d),
             ]);
         case "lab":
             return new ParsedColor("lab50", [
-                parsePercent(a, false),
-                parseNumber(b) * 0.01,
-                parseNumber(c) * 0.01,
-                parseAlpha(d),
+                __numOrPercent(a),
+                __numOrPercent(b, 1.25),
+                __numOrPercent(c, 1.25),
+                __alpha(d),
             ]);
         case "lch":
-            return new ParsedColor("lch", [
-                parsePercent(a, false),
-                parseNumber(b) * 0.01,
-                parseHue(c),
-                parseAlpha(d),
+            return new ParsedColor(mode, [
+                __numOrPercent(a),
+                __numOrPercent(b, 1.5),
+                __hue(c),
+                __alpha(d),
+            ]);
+        case "oklab":
+            return new ParsedColor(mode, [
+                __numOrPercent(a, 1, 1),
+                __numOrPercent(b, 0.4, 1),
+                __numOrPercent(c, 0.4, 1),
+                __alpha(d),
+            ]);
+        case "oklch":
+            return new ParsedColor(mode, [
+                __numOrPercent(a, 1, 1),
+                __numOrPercent(b, 0.4, 1),
+                __hue(c),
+                __alpha(d),
             ]);
         default:
             unsupported(`color mode: ${mode}`);
     }
 };
+/**
+ * Scale factors for various CSS angle units
+ *
+ * @remarks
+ * Reference:
+ * - https://www.w3.org/TR/css-values-4/#angle-value
+ *
+ * @internal
+ */
 const HUE_NORMS = {
     rad: TAU,
     grad: 400,
     turn: 1,
     deg: 360,
-    undefined: 360,
 };
-const parseHue = (x) => {
+/** @internal */
+const __hue = (x) => {
     const match = /^(-?[0-9.]+)(deg|rad|grad|turn)?$/.exec(x);
     assert(!!match, `expected hue, got: ${x}`);
-    return fract(parseFloat(match[1]) / HUE_NORMS[match[2]]);
+    return fract(parseFloat(match[1]) / (HUE_NORMS[match[2]] || 360));
 };
-const parseAlpha = (x) => (x ? parseNumOrPercent(x, 1) : 1);
-const parsePercent = (x, clamp = true) => {
+/** @internal */
+const __alpha = (x) => (x ? __numOrPercent(x, 1, 1, true) : 1);
+/** @internal */
+const __percent = (x, clamp = true) => {
     assert(/^([0-9.]+)%$/.test(x), `expected percentage, got: ${x}`);
     const res = parseFloat(x) / 100;
     return clamp ? clamp01(res) : res;
 };
-const parseNumber = (x) => {
-    assert(/^-?[0-9.]+$/.test(x), `expected number, got: ${x}`);
-    return parseFloat(x);
-};
-const parseNumOrPercent = (x, norm = 255, clamp = true) => {
+/** @internal */
+const __numOrPercent = (x, scalePerc = 1, scale = 0.01, clamp = false) => {
     assert(/^-?[0-9.]+%?$/.test(x), `expected number or percentage, got: ${x}`);
-    const res = parseFloat(x) / (x.endsWith("%") ? 100 : norm);
+    const res = parseFloat(x) * (x.endsWith("%") ? 0.01 * scalePerc : scale);
     return clamp ? clamp01(res) : res;
 };
+/**
+ * Parses a CSS hex color string into an uint32. Throws an error if given string
+ * doesn't conform to any of the supported formats.
+ *
+ * @remarks
+ * Supports the following input formats (`#` always optional and each letter a
+ * hex digit):
+ *
+ * - `#rgb`
+ * - `#rgba`
+ * - `#rrggbb`
+ * - `#rrggbbaa`
+ *
+ * @param src
+ */
 export const parseHex = (src) => {
     const match = /^#?([0-9a-f]{3,8})$/i.exec(src);
     if (match) {
         const hex = match[1];
+        const val = parseInt(hex, 16);
         switch (hex.length) {
             case 3:
-                return ((interleave4_12_24(parseInt(hex, 16)) | 0xff000000) >>> 0);
+                return (interleave4_12_24(val) | 0xff000000) >>> 0;
             case 4:
-                return interleave4_16_32(parseInt(hex, 16)) >>> 0;
+                return rotateRight(interleave4_16_32(val), 8);
             case 6:
-                return (parseInt(hex, 16) | 0xff000000) >>> 0;
+                return (val | 0xff000000) >>> 0;
             case 8:
-                return parseInt(hex, 16) >>> 0;
+                return rotateRight(val, 8);
             default:
         }
     }

package/defcolor.js

@@ -28,8 +28,8 @@ export const defColor = (spec) => {
         };
         return acc;
     }, channels);
-    const min = order.map((id) => channels[id].range[0]);
-    const max = order.map((id) => channels[id].range[1]);
+    const min = Object.freeze(order.map((id) => channels[id].range[0]));
+    const max = Object.freeze(order.map((id) => channels[id].range[1]));
     // fix alpha channel for randomize()
     const minR = set4([], min);
     const maxR = set4([], max);

package/distance.d.ts

@@ -18,10 +18,15 @@ export declare const distHsv: ColorDistance;
 /**
  * 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.
+ * a cyclinder (using Law of Cosines).
  *
- * @param a -
- * @param b -
+ * @remarks
+ * Reference:
+ * - https://math.stackexchange.com/a/3612602
+ * - https://en.wikipedia.org/wiki/Law_of_cosines
+ *
+ * @param a
+ * @param b
  */
 export declare const distLch: ColorDistance;
 /**

package/distance.js

@@ -28,16 +28,20 @@ export const distHsv = (a, b) => {
 /**
  * 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.
+ * a cyclinder (using Law of Cosines).
  *
- * @param a -
- * @param b -
+ * @remarks
+ * Reference:
+ * - https://math.stackexchange.com/a/3612602
+ * - https://en.wikipedia.org/wiki/Law_of_cosines
+ *
+ * @param a
+ * @param b
  */
-export const distLch = (a, b) => {
-    const aa = cossin(a[2] * TAU, a[1]);
-    const bb = cossin(b[2] * TAU, b[1]);
-    return hypot(aa[0] - bb[0], aa[1] - bb[1], a[0] - b[0]);
-};
+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.
  *

package/hcy/hcy.d.ts

@@ -24,5 +24,10 @@ export declare class HCY implements TypedColor<HCY> {
     set(src: ReadonlyColor): this;
     toJSON(): number[];
 }
+/**
+ * @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 declare const hcy: ColorFactory<HCY>;
 //# sourceMappingURL=hcy.d.ts.map

package/hcy/hcy.js

@@ -4,6 +4,11 @@ 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 } },

package/hsi/hsi.d.ts

@@ -24,5 +24,10 @@ export declare class HSI implements TypedColor<HSI> {
     set(src: ReadonlyColor): this;
     toJSON(): number[];
 }
+/**
+ * @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 declare const hsi: ColorFactory<HSI>;
 //# sourceMappingURL=hsi.d.ts.map

package/hsi/hsi.js

@@ -4,6 +4,11 @@ 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 } },

package/hsl/hsl.d.ts

@@ -24,5 +24,10 @@ export declare class HSL implements TypedColor<HSL> {
     set(src: ReadonlyColor): this;
     toJSON(): number[];
 }
+/**
+ * @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 declare const hsl: ColorFactory<HSL>;
 //# sourceMappingURL=hsl.d.ts.map

package/hsl/hsl.js

@@ -5,6 +5,11 @@ 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 } },

package/hsv/hsv.d.ts

@@ -24,5 +24,10 @@ export declare class HSV implements TypedColor<HSV> {
     set(src: ReadonlyColor): this;
     toJSON(): number[];
 }
+/**
+ * @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 declare const hsv: ColorFactory<HSV>;
 //# sourceMappingURL=hsv.d.ts.map

package/hsv/hsv.js

@@ -5,6 +5,11 @@ import { labRgb } from "../lab/lab-rgb.js";
 import { rgbHsv } from "../rgb/rgb-hsv.js";
 import { rgbSrgb } from "../rgb/rgb-srgb.js";
 import { hsvRgb } from "./hsv-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 hsv = defColor({
     mode: "hsv",
     channels: { h: { hue: true } },

package/index.d.ts

@@ -36,9 +36,14 @@ export * from "./lab/lab50.js";
 export * from "./lab/lab65.js";
 export * from "./lch/lch-css.js";
 export * from "./lch/lch.js";
+export * from "./oklab/oklab-css.js";
 export * from "./oklab/oklab-rgb.js";
 export * from "./oklab/oklab-xyz.js";
 export * from "./oklab/oklab.js";
+export * from "./oklch/oklch-css.js";
+export * from "./oklch/oklch-oklab.js";
+export * from "./oklch/oklab-oklch.js";
+export * from "./oklch/oklch.js";
 export * from "./alpha.js";
 export * from "./analog.js";
 export * from "./clamp.js";

package/index.js

@@ -36,9 +36,14 @@ export * from "./lab/lab50.js";
 export * from "./lab/lab65.js";
 export * from "./lch/lch-css.js";
 export * from "./lch/lch.js";
+export * from "./oklab/oklab-css.js";
 export * from "./oklab/oklab-rgb.js";
 export * from "./oklab/oklab-xyz.js";
 export * from "./oklab/oklab.js";
+export * from "./oklch/oklch-css.js";
+export * from "./oklch/oklch-oklab.js";
+export * from "./oklch/oklab-oklch.js";
+export * from "./oklch/oklch.js";
 export * from "./alpha.js";
 export * from "./analog.js";
 export * from "./clamp.js";

package/internal/css.d.ts

@@ -0,0 +1,4 @@
+import type { ReadonlyColor } from "../api.js";
+export declare const __labCss: (mode: string, src: ReadonlyColor, scale: number) => string;
+export declare const __lchCss: (mode: string, src: ReadonlyColor, scaleC: number) => string;
+//# sourceMappingURL=css.d.ts.map

package/internal/css.js

@@ -0,0 +1,18 @@
+import { clamp0 } from "@thi.ng/math/interval";
+import { fract } from "@thi.ng/math/prec";
+import { FF, PC } from "../api/constants.js";
+import { __ensureAlpha } from "./ensure.js";
+export const __labCss = (mode, src, scale) => {
+    const l = PC(clamp0(src[0]));
+    const a = FF(src[1] * scale);
+    const b = FF(src[2] * scale);
+    const alpha = __ensureAlpha(src[3]);
+    return `${mode}(${l} ${a} ${b}` + (alpha < 1 ? `/${FF(alpha)})` : ")");
+};
+export const __lchCss = (mode, src, scaleC) => {
+    const l = PC(clamp0(src[0]));
+    const c = FF(clamp0(src[1]) * scaleC);
+    const h = FF(fract(src[2]) * 360);
+    const a = __ensureAlpha(src[3]);
+    return `${mode}(${l} ${c} ${h}` + (a < 1 ? `/${FF(a)})` : ")");
+};

package/invert.d.ts

@@ -3,6 +3,8 @@ import type { ColorOp, TypedColor } from "./api.js";
  * Inverts the RGB channels of an RGBA color.
  *
  * @remarks
+ * If `out` is null, the resulting color will be written back into `src`.
+ *
  * Also see {@link TypedColor.invert}.
  *
  * @param out - result
@@ -18,5 +20,12 @@ export declare const invertRgb: ColorOp;
  * @param src - packed RGB int
  */
 export declare const invertInt: (src: number) => number;
+/**
+ * Inverts given color and writes result into `out` (or if null, mutates `src`
+ * in place).
+ *
+ * @param out
+ * @param src
+ */
 export declare const invert: import("@thi.ng/defmulti").MultiFn2<import("@thi.ng/vectors/api").Vec | null, TypedColor<any>, import("@thi.ng/vectors/api").Vec>;
 //# sourceMappingURL=invert.d.ts.map

package/invert.js

@@ -11,6 +11,8 @@ import { __ensureAlpha } from "./internal/ensure.js";
  * Inverts the RGB channels of an RGBA color.
  *
  * @remarks
+ * If `out` is null, the resulting color will be written back into `src`.
+ *
  * Also see {@link TypedColor.invert}.
  *
  * @param out - result
@@ -29,6 +31,13 @@ export const invertRgb = (out, src) => {
  * @param src - packed RGB int
  */
 export const invertInt = (src) => src ^ 0xffffff;
+/**
+ * Inverts given color and writes result into `out` (or if null, mutates `src`
+ * in place).
+ *
+ * @param out
+ * @param src
+ */
 export const invert = defmulti(__dispatch1, {
     hcy: "hsv",
     hsi: "hsv",

package/lab/lab-css.js

@@ -1,6 +1,4 @@
-import { clamp0 } from "@thi.ng/math/interval";
-import { FF, PC } from "../api/constants.js";
-import { __ensureAlpha } from "../internal/ensure.js";
+import { __labCss } from "../internal/css.js";
 /**
  * @remarks
  * Only supported in CSS Color Level 4 onwards
@@ -9,10 +7,4 @@ import { __ensureAlpha } from "../internal/ensure.js";
  *
  * @param src -
  */
-export const labCss = (src) => {
-    const l = PC(clamp0(src[0]));
-    const a = FF(src[1] * 100);
-    const b = FF(src[2] * 100);
-    const alpha = __ensureAlpha(src[3]);
-    return `lab(${l} ${a} ${b}` + (alpha < 1 ? `/${FF(alpha)})` : ")");
-};
+export const labCss = (src) => __labCss("lab", src, 100);

package/lch/lch-css.js

@@ -1,7 +1,4 @@
-import { clamp0 } 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";
+import { __lchCss } from "../internal/css.js";
 /**
  * @remarks
  * Only supported in CSS Color Level 4 onwards
@@ -10,10 +7,4 @@ import { __ensureAlpha } from "../internal/ensure.js";
  *
  * @param src -
  */
-export const lchCss = (src) => {
-    const l = PC(clamp0(src[0]));
-    const c = FF(clamp0(src[1]) * 100);
-    const h = FF(fract(src[2]) * 360);
-    const a = __ensureAlpha(src[3]);
-    return `lch(${l} ${c} ${h}` + (a < 1 ? `/${FF(a)})` : ")");
-};
+export const lchCss = (src) => __lchCss("lch", src, 100);

package/lch/lch.d.ts

@@ -26,7 +26,11 @@ export declare class LCH implements TypedColor<LCH> {
 }
 /**
  * Luminance Chroma Hue (conversions assume {@link D50} white point, as per CSS
- * spec).
+ * spec). Polar version of {@link labD50}.
+ *
+ * @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 declare const lch: ColorFactory<LCH>;
 //# sourceMappingURL=lch.d.ts.map

package/lch/lch.js

@@ -7,7 +7,11 @@ import { xyzLab } from "../xyz/xyz-lab.js";
 import { xyzXyzD65_50 } from "../xyz/xyz-xyz.js";
 /**
  * Luminance Chroma Hue (conversions assume {@link D50} white point, as per CSS
- * spec).
+ * spec). Polar version of {@link labD50}.
+ *
+ * @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 lch = defColor({
     mode: "lch",

package/lighten.d.ts

@@ -3,6 +3,9 @@ import type { TypedColor } from "./api.js";
  * Adjust the "lightness" (luma, brightness etc.) channel of given `src` color
  * and `delta` offset. Writes result into `out` (or if null, back into `src`).
  *
+ * @remarks
+ * If `offset` is negative, then color will be darkened.
+ *
  * @param out -
  * @param src -
  * @param delta -

package/lighten.js

@@ -11,6 +11,9 @@ const $ = (id) => (out, src, n) => {
  * Adjust the "lightness" (luma, brightness etc.) channel of given `src` color
  * and `delta` offset. Writes result into `out` (or if null, back into `src`).
  *
+ * @remarks
+ * If `offset` is negative, then color will be darkened.
+ *
  * @param out -
  * @param src -
  * @param delta -

package/mix.d.ts

@@ -41,10 +41,12 @@ export declare const mixNNHN: ColorMixFn<import("@thi.ng/vectors").ReadonlyVec>;
 export declare const mixNNNN: ColorMixFn;
 /**
  * Channelwise and {@link ColorMode}-aware interpolation between colors `a` and
- * `b` using `t` [0..1] as blend factor. `a` and `b` need to be of same color
+ * `b` using `t` [0..1] as blend factor. `a` and `b` MUST be of same color
  * type.
  *
  * @remarks
+ * If `out` is null, the resulting color will be written back into `a`.
+ *
  * Any hue channel will always be interpolated using the smallest angle
  * difference (using {@link mixH}).
  *

package/mix.js

@@ -56,10 +56,12 @@ export const mixNNHN = defMix(mixN, mixN, mixH, mixN);
 export const mixNNNN = mixN4;
 /**
  * Channelwise and {@link ColorMode}-aware interpolation between colors `a` and
- * `b` using `t` [0..1] as blend factor. `a` and `b` need to be of same color
+ * `b` using `t` [0..1] as blend factor. `a` and `b` MUST be of same color
  * type.
  *
  * @remarks
+ * If `out` is null, the resulting color will be written back into `a`.
+ *
  * Any hue channel will always be interpolated using the smallest angle
  * difference (using {@link mixH}).
  *

package/oklab/oklab-css.d.ts

@@ -0,0 +1,11 @@
+import type { ReadonlyColor } from "../api.js";
+/**
+ * @remarks
+ * Only supported in CSS Color Level 4 onwards
+ * https://www.w3.org/TR/css-color-4/#specifying-lab-lch
+ * https://test.csswg.org/harness/results/css-color-4_dev/grouped/ (test reports)
+ *
+ * @param src -
+ */
+export declare const oklabCss: (src: ReadonlyColor) => string;
+//# sourceMappingURL=oklab-css.d.ts.map

package/oklab/oklab-css.js

@@ -0,0 +1,10 @@
+import { __labCss } from "../internal/css.js";
+/**
+ * @remarks
+ * Only supported in CSS Color Level 4 onwards
+ * https://www.w3.org/TR/css-color-4/#specifying-lab-lch
+ * https://test.csswg.org/harness/results/css-color-4_dev/grouped/ (test reports)
+ *
+ * @param src -
+ */
+export const oklabCss = (src) => __labCss("oklab", src, 1);

package/oklab/oklab-rgb.js

@@ -1,7 +1,16 @@
 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 LMS_CONE = [
-    4.0767245293, -1.2681437731, -0.0041119885, -3.3072168827, 2.6093323231,
-    -0.7034763098, 0.2307590544, -0.341134429, 1.7068625689,
+    4.0767416621, -1.2684380046, -0.0041960863,
+    -3.307711591, 2.6097574011, -0.7034186147,
+    0.2309699292, -0.3413193965, 1.707614701,
 ];
 /**
  * @remarks

package/oklab/oklab.js

@@ -14,8 +14,8 @@ import { oklabRgb } from "./oklab-rgb.js";
 export const oklab = defColor({
     mode: "oklab",
     channels: {
-        a: { range: [-0.2339, 0.2763] },
-        b: { range: [-0.3116, 0.1985] },
+        a: { range: [-0.2339, 0.2762] },
+        b: { range: [-0.3115, 0.1986] },
     },
     order: ["l", "a", "b", "alpha"],
     from: {

package/oklch/oklab-oklch.d.ts

@@ -0,0 +1,3 @@
+import type { ColorOp } from "../api.js";
+export declare const oklabOklch: ColorOp;
+//# sourceMappingURL=oklab-oklch.d.ts.map

package/oklch/oklab-oklch.js

@@ -0,0 +1,15 @@
+import { atan2Abs } from "@thi.ng/math/angle";
+import { INV_TAU } from "@thi.ng/math/api";
+import { setC4 } from "@thi.ng/vectors/setc";
+import { __ensureAlpha } from "../internal/ensure.js";
+export const oklabOklch = (out, src) => setC4(out || src, src[0], Math.hypot(src[1], src[2]), atan2Abs(src[2], src[1]) * INV_TAU, __ensureAlpha(src[3]));
+/*
+export function OKLab_to_OKLCH(OKLab: Color): Color {
+    const hue = Math.atan2(OKLab[2], OKLab[1]) * 180 / Math.PI;
+    return [
+        OKLab[0], // L is still L
+        Math.sqrt(OKLab[1] ** 2 + OKLab[2] ** 2), // Chroma
+        hue >= 0 ? hue : hue + 360, // Hue, in degrees [0 to 360)
+    ];
+}
+*/