@thi.ng/color 5.6.2 → 5.6.4

package/hsv/hsv-css.js

@@ -1,3 +1,6 @@
 import { hslCss } from "../hsl/hsl-css.js";
 import { hsvHsl } from "./hsv-hsl.js";
-export const hsvCss = (src) => hslCss(hsvHsl([], src));
+const hsvCss = (src) => hslCss(hsvHsl([], src));
+export {
+  hsvCss
+};

package/hsv/hsv-hsl.js

@@ -1,10 +1,13 @@
 import { clampH } from "../clamp.js";
-export const hsvHsl = (out, src) => {
-    out = clampH(out || src, src);
-    const s = out[1];
-    const v = out[2];
-    const l = ((2 - s) * v) / 2;
-    out[2] = l;
-    out[1] = l && l < 1 ? (s * v) / (l < 0.5 ? l * 2 : 2 - l * 2) : s;
-    return out;
+const hsvHsl = (out, src) => {
+  out = clampH(out || src, src);
+  const s = out[1];
+  const v = out[2];
+  const l = (2 - s) * v / 2;
+  out[2] = l;
+  out[1] = l && l < 1 ? s * v / (l < 0.5 ? l * 2 : 2 - l * 2) : s;
+  return out;
+};
+export {
+  hsvHsl
 };

package/hsv/hsv-rgb.js

@@ -1,10 +1,18 @@
 import { setC3 } from "@thi.ng/vectors/setc";
 import { clampH } from "../clamp.js";
 import { hueRgb } from "../rgb/hue-rgb.js";
-export const hsvRgb = (out, src) => {
-    out = clampH(out || src, src);
-    const s = out[1];
-    const v = out[2];
-    hueRgb(out, src[0], out[3]);
-    return setC3(out, ((out[0] - 1) * s + 1) * v, ((out[1] - 1) * s + 1) * v, ((out[2] - 1) * s + 1) * v);
+const hsvRgb = (out, src) => {
+  out = clampH(out || src, src);
+  const s = out[1];
+  const v = out[2];
+  hueRgb(out, src[0], out[3]);
+  return setC3(
+    out,
+    ((out[0] - 1) * s + 1) * v,
+    ((out[1] - 1) * s + 1) * v,
+    ((out[2] - 1) * s + 1) * v
+  );
+};
+export {
+  hsvRgb
 };

package/hsv/hsv.js

@@ -5,20 +5,18 @@ 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 } },
-    order: ["h", "s", "v", "alpha"],
-    from: {
-        rgb: rgbHsv,
-        srgb: rgbHsv,
-        hsl: hslHsv,
-        lch: [lchLab, labRgb, rgbSrgb, rgbHsv],
-    },
-    toRgb: hsvRgb,
+const hsv = defColor({
+  mode: "hsv",
+  channels: { h: { hue: true } },
+  order: ["h", "s", "v", "alpha"],
+  from: {
+    rgb: rgbHsv,
+    srgb: rgbHsv,
+    hsl: hslHsv,
+    lch: [lchLab, labRgb, rgbSrgb, rgbHsv]
+  },
+  toRgb: hsvRgb
 });
+export {
+  hsv
+};

package/hue.js

@@ -1,18 +1,18 @@
 import { DEFAULT, defmulti } from "@thi.ng/defmulti/defmulti";
 import { hsv } from "./hsv/hsv.js";
 import { __dispatch0 } from "./internal/dispatch.js";
-/**
- * Returns the (normalized) hue of given color.
- *
- * @remarks
- * Since LCH uses different hue values than the more familiar HSV/HSL color
- * wheel, LCH colors will be first converted to HSV to ensure uniform results.
- */
-export const hue = defmulti(__dispatch0, {
+const hue = defmulti(
+  __dispatch0,
+  {
     hcy: "hsv",
     hsi: "hsv",
-    hsl: "hsv",
-}, {
+    hsl: "hsv"
+  },
+  {
     [DEFAULT]: (col) => hsv(col)[0],
-    hsv: (col) => col[0],
-});
+    hsv: (col) => col[0]
+  }
+);
+export {
+  hue
+};

package/int/int-css.js

@@ -1,9 +1,13 @@
 import { U24 } from "@thi.ng/strings/radix";
 import { FF, INV8BIT } from "../api/constants.js";
-export const intArgb32Css = (src) => {
-    const a = src >>> 24;
-    return a < 255
-        ? `rgba(${(src >> 16) & 0xff},${(src >> 8) & 0xff},${src & 0xff},${FF(a * INV8BIT)})`
-        : `#${U24(src & 0xffffff)}`;
+const intArgb32Css = (src) => {
+  const a = src >>> 24;
+  return a < 255 ? `rgba(${src >> 16 & 255},${src >> 8 & 255},${src & 255},${FF(
+    a * INV8BIT
+  )})` : `#${U24(src & 16777215)}`;
+};
+const intRgb24Css = (src) => `#${U24(src & 16777215)}`;
+export {
+  intArgb32Css,
+  intRgb24Css
 };
-export const intRgb24Css = (src) => `#${U24(src & 0xffffff)}`;

package/int/int-int.js

@@ -1,11 +1,7 @@
 import { swapLane13 } from "@thi.ng/binary/swizzle";
-/**
- * Convert ARGB int to ABGR and vice versa.
- *
- * @param x -
- */
-export const intArgb32Abgr32 = swapLane13;
-/**
- * Alias for {@link intArgbAbgr}.
- */
-export const intAbgr32Argb32 = swapLane13;
+const intArgb32Abgr32 = swapLane13;
+const intAbgr32Argb32 = swapLane13;
+export {
+  intAbgr32Argb32,
+  intArgb32Abgr32
+};

package/int/int-rgb.js

@@ -1,6 +1,17 @@
 import { srgbRgb } from "../srgb/srgb-rgb.js";
-import { intAbgr32Srgb, intArgb32Srgb, intBgr24Srgb, intRgb24Srgb, } from "./int-srgb.js";
-export const intArgb32Rgb = (out, src) => srgbRgb(null, intArgb32Srgb(out, src));
-export const intRgb24Rgb = (out, src) => srgbRgb(null, intRgb24Srgb(out, src));
-export const intAbgr32Rgb = (out, src) => srgbRgb(null, intAbgr32Srgb(out, src));
-export const intBgr24Rgb = (out, src) => srgbRgb(null, intBgr24Srgb(out, src));
+import {
+  intAbgr32Srgb,
+  intArgb32Srgb,
+  intBgr24Srgb,
+  intRgb24Srgb
+} from "./int-srgb.js";
+const intArgb32Rgb = (out, src) => srgbRgb(null, intArgb32Srgb(out, src));
+const intRgb24Rgb = (out, src) => srgbRgb(null, intRgb24Srgb(out, src));
+const intAbgr32Rgb = (out, src) => srgbRgb(null, intAbgr32Srgb(out, src));
+const intBgr24Rgb = (out, src) => srgbRgb(null, intBgr24Srgb(out, src));
+export {
+  intAbgr32Rgb,
+  intArgb32Rgb,
+  intBgr24Rgb,
+  intRgb24Rgb
+};

package/int/int-srgb.js

@@ -1,6 +1,24 @@
 import { setC4 } from "@thi.ng/vectors/setc";
 import { INV8BIT } from "../api/constants.js";
-export const intArgb32Srgb = (out, src) => setC4(out || [], ((src >>> 16) & 0xff) * INV8BIT, ((src >>> 8) & 0xff) * INV8BIT, (src & 0xff) * INV8BIT, (src >>> 24) * INV8BIT);
-export const intAbgr32Srgb = (out, src) => setC4(out || [], (src & 0xff) * INV8BIT, ((src >>> 8) & 0xff) * INV8BIT, ((src >>> 16) & 0xff) * INV8BIT, (src >>> 24) * INV8BIT);
-export const intRgb24Srgb = (out, src) => intArgb32Srgb(out, src | 0xff000000);
-export const intBgr24Srgb = (out, src) => intAbgr32Srgb(out, src | 0xff000000);
+const intArgb32Srgb = (out, src) => setC4(
+  out || [],
+  (src >>> 16 & 255) * INV8BIT,
+  (src >>> 8 & 255) * INV8BIT,
+  (src & 255) * INV8BIT,
+  (src >>> 24) * INV8BIT
+);
+const intAbgr32Srgb = (out, src) => setC4(
+  out || [],
+  (src & 255) * INV8BIT,
+  (src >>> 8 & 255) * INV8BIT,
+  (src >>> 16 & 255) * INV8BIT,
+  (src >>> 24) * INV8BIT
+);
+const intRgb24Srgb = (out, src) => intArgb32Srgb(out, src | 4278190080);
+const intBgr24Srgb = (out, src) => intAbgr32Srgb(out, src | 4278190080);
+export {
+  intAbgr32Srgb,
+  intArgb32Srgb,
+  intBgr24Srgb,
+  intRgb24Srgb
+};

package/int/int.js

@@ -12,152 +12,146 @@ import { __scale8bit } from "../internal/scale.js";
 import { srgb } from "../srgb/srgb.js";
 import { srgbIntAbgr32, srgbIntArgb32 } from "../srgb/srgb-int.js";
 import { intArgb32Srgb } from "./int-srgb.js";
-export class Int32 {
-    offset;
-    stride;
-    buf;
-    value;
-    constructor(buf, offset = 0, stride = 1) {
-        this.offset = offset;
-        this.stride = stride;
-        this.buf = buf || [0];
-    }
-    eqDelta(o, eps) {
-        return eqDelta4(
-        // channel order irrelevant here...
-        intArgb32Srgb([], this[0]), intArgb32Srgb([], o[0]), eps);
-    }
-    get length() {
-        return 1;
-    }
-    get range() {
-        return [[0], [0xffffffff]];
-    }
-    get alpha() {
-        return (this[0] >>> 24) / 255;
-    }
-    set alpha(x) {
-        this[0] = (this[0] & 0xffffff) | __scale8bit(x, 24);
-    }
-    get xyz() {
-        const val = this[0];
-        return [
-            ((val >> 16) & 0xff) / 0xff,
-            ((val >> 8) & 0xff) / 0xff,
-            (val & 0xff) / 0xff,
-        ];
-    }
-    *[Symbol.iterator]() {
-        yield this[0];
-    }
-    deref() {
-        return [this[0]];
-    }
-    randomize(rnd = SYSTEM) {
-        const x = this[0];
-        this[0] = (x & 0xff000000) | (rnd.int() & 0xffffff);
-        return this;
-    }
-    clamp() {
-        return this;
-    }
-    set(src) {
-        this[0] = src[0];
-        return this;
-    }
-    toJSON() {
-        return [this[0]];
-    }
+class Int32 {
+  constructor(buf, offset = 0, stride = 1) {
+    this.offset = offset;
+    this.stride = stride;
+    this.buf = buf || [0];
+  }
+  buf;
+  value;
+  eqDelta(o, eps) {
+    return eqDelta4(
+      // channel order irrelevant here...
+      intArgb32Srgb([], this[0]),
+      intArgb32Srgb([], o[0]),
+      eps
+    );
+  }
+  get length() {
+    return 1;
+  }
+  get range() {
+    return [[0], [4294967295]];
+  }
+  get alpha() {
+    return (this[0] >>> 24) / 255;
+  }
+  set alpha(x) {
+    this[0] = this[0] & 16777215 | __scale8bit(x, 24);
+  }
+  get xyz() {
+    const val = this[0];
+    return [
+      (val >> 16 & 255) / 255,
+      (val >> 8 & 255) / 255,
+      (val & 255) / 255
+    ];
+  }
+  *[Symbol.iterator]() {
+    yield this[0];
+  }
+  deref() {
+    return [this[0]];
+  }
+  randomize(rnd = SYSTEM) {
+    const x = this[0];
+    this[0] = x & 4278190080 | rnd.int() & 16777215;
+    return this;
+  }
+  clamp() {
+    return this;
+  }
+  set(src) {
+    this[0] = src[0];
+    return this;
+  }
+  toJSON() {
+    return [this[0]];
+  }
 }
-export class ARGB extends Int32 {
-    get mode() {
-        return "argb32";
-    }
-    get r() {
-        return ((this[0] >> 16) & 0xff) / 255;
-    }
-    set r(x) {
-        this[0] = (this[0] & 0xff00ffff) | __scale8bit(x, 16);
-    }
-    get g() {
-        return ((this[0] >> 8) & 0xff) / 255;
-    }
-    set g(x) {
-        this[0] = (this[0] & 0xffff00ff) | __scale8bit(x, 8);
-    }
-    get b() {
-        return (this[0] & 0xff) / 255;
-    }
-    set b(x) {
-        this[0] = (this[0] & 0xffffff00) | __scale8bit(x);
-    }
-    copy() {
-        return new ARGB([this[0]]);
-    }
-    copyView() {
-        return new ARGB(this.buf, this.offset, this.stride);
-    }
-    empty() {
-        return new ARGB();
-    }
+class ARGB extends Int32 {
+  get mode() {
+    return "argb32";
+  }
+  get r() {
+    return (this[0] >> 16 & 255) / 255;
+  }
+  set r(x) {
+    this[0] = this[0] & 4278255615 | __scale8bit(x, 16);
+  }
+  get g() {
+    return (this[0] >> 8 & 255) / 255;
+  }
+  set g(x) {
+    this[0] = this[0] & 4294902015 | __scale8bit(x, 8);
+  }
+  get b() {
+    return (this[0] & 255) / 255;
+  }
+  set b(x) {
+    this[0] = this[0] & 4294967040 | __scale8bit(x);
+  }
+  copy() {
+    return new ARGB([this[0]]);
+  }
+  copyView() {
+    return new ARGB(this.buf, this.offset, this.stride);
+  }
+  empty() {
+    return new ARGB();
+  }
 }
 declareIndex(ARGB.prototype, "value", 0);
-export class ABGR extends Int32 {
-    get mode() {
-        return "abgr32";
-    }
-    get r() {
-        return (this[0] & 0xff) / 255;
-    }
-    set r(x) {
-        this[0] = (this[0] & 0xffffff00) | __scale8bit(x);
-    }
-    get g() {
-        return ((this[0] >> 8) & 0xff) / 255;
-    }
-    set g(x) {
-        this[0] = (this[0] & 0xffff00ff) | __scale8bit(x, 8);
-    }
-    get b() {
-        return ((this[0] >> 16) & 0xff) / 255;
-    }
-    set b(x) {
-        this[0] = (this[0] & 0xff00ffff) | __scale8bit(x, 16);
-    }
-    copy() {
-        return new ABGR([this[0]]);
-    }
-    copyView() {
-        return new ABGR(this.buf, this.offset, this.stride);
-    }
-    empty() {
-        return new ABGR();
-    }
+class ABGR extends Int32 {
+  get mode() {
+    return "abgr32";
+  }
+  get r() {
+    return (this[0] & 255) / 255;
+  }
+  set r(x) {
+    this[0] = this[0] & 4294967040 | __scale8bit(x);
+  }
+  get g() {
+    return (this[0] >> 8 & 255) / 255;
+  }
+  set g(x) {
+    this[0] = this[0] & 4294902015 | __scale8bit(x, 8);
+  }
+  get b() {
+    return (this[0] >> 16 & 255) / 255;
+  }
+  set b(x) {
+    this[0] = this[0] & 4278255615 | __scale8bit(x, 16);
+  }
+  copy() {
+    return new ABGR([this[0]]);
+  }
+  copyView() {
+    return new ABGR(this.buf, this.offset, this.stride);
+  }
+  empty() {
+    return new ABGR();
+  }
 }
 declareIndex(ABGR.prototype, "value", 0);
 const defInt = (ctor, fromSrgb) => {
-    const factory = (src, ...xs) => src == null
-        ? new ctor()
-        : isNumber(src)
-            ? xs.length && xs.every(isNumber)
-                ? new ctor([srgbIntArgb32([src, ...xs])])
-                : new ctor([src], ...xs)
-            : isString(src)
-                ? factory(parseCss(src))
-                : isArrayLike(src)
-                    ? isString(src.mode)
-                        ? new ctor([fromSrgb(srgb(src))], ...xs)
-                        : new ctor(src, ...xs)
-                    : implementsFunction(src, "deref")
-                        ? new ctor([fromSrgb(srgb(src))], ...xs)
-                        : illegalArgs(`can't create a ARGB32 color from: ${src}`);
-    factory.class = ctor;
-    factory.range = [[0], [0xffffffff]];
-    factory.random = (rnd = SYSTEM, buf, idx, stride) => (new ctor(buf, idx, stride).set([
-        (rnd.int() & 0xffffff) | 0xff000000,
-    ]));
-    factory.mapBuffer = (buf, num = buf.length, start = 0, cstride = 1, estride = 1) => mapStridedBuffer(ctor, buf, num, start, cstride, estride);
-    return factory;
+  const factory = (src, ...xs) => src == null ? new ctor() : isNumber(src) ? xs.length && xs.every(isNumber) ? new ctor([srgbIntArgb32([src, ...xs])]) : new ctor([src], ...xs) : isString(src) ? factory(parseCss(src)) : isArrayLike(src) ? isString(src.mode) ? new ctor([fromSrgb(srgb(src))], ...xs) : new ctor(src, ...xs) : implementsFunction(src, "deref") ? new ctor([fromSrgb(srgb(src))], ...xs) : illegalArgs(`can't create a ARGB32 color from: ${src}`);
+  factory.class = ctor;
+  factory.range = [[0], [4294967295]];
+  factory.random = (rnd = SYSTEM, buf, idx, stride) => new ctor(buf, idx, stride).set([
+    rnd.int() & 16777215 | 4278190080
+  ]);
+  factory.mapBuffer = (buf, num = buf.length, start = 0, cstride = 1, estride = 1) => mapStridedBuffer(ctor, buf, num, start, cstride, estride);
+  return factory;
+};
+const argb32 = defInt(ARGB, srgbIntArgb32);
+const abgr32 = defInt(ABGR, srgbIntAbgr32);
+export {
+  ABGR,
+  ARGB,
+  Int32,
+  abgr32,
+  argb32
 };
-export const argb32 = defInt(ARGB, srgbIntArgb32);
-export const abgr32 = defInt(ABGR, srgbIntAbgr32);

package/internal/css.js

@@ -2,17 +2,21 @@ 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)})` : ")");
+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)})` : ")");
+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)})` : ")");
+};
+export {
+  __labCss,
+  __lchCss
 };

package/internal/dispatch.js

@@ -1,2 +1,6 @@
-export const __dispatch0 = (src) => src.mode;
-export const __dispatch1 = (_, src) => src.mode;
+const __dispatch0 = (src) => src.mode;
+const __dispatch1 = (_, src) => src.mode;
+export {
+  __dispatch0,
+  __dispatch1
+};

package/internal/ensure.js

@@ -1,19 +1,21 @@
 import { clamp01 } from "@thi.ng/math/interval";
-/** @internal */
-export const __ensureAlpha = (x, def = 1) => x != undefined ? clamp01(x) : def;
-/** @internal */
-export const __ensureArgs = (args) => {
-    if (typeof args[0] === "number") {
-        switch (args.length) {
-            case 1:
-                return args.push(0, 0, 1), [args];
-            case 2:
-                return args.push(0, 1), [args];
-            case 3:
-                return args.push(1), [args];
-            default:
-                return [args];
-        }
+const __ensureAlpha = (x, def = 1) => x != void 0 ? clamp01(x) : def;
+const __ensureArgs = (args) => {
+  if (typeof args[0] === "number") {
+    switch (args.length) {
+      case 1:
+        return args.push(0, 0, 1), [args];
+      case 2:
+        return args.push(0, 1), [args];
+      case 3:
+        return args.push(1), [args];
+      default:
+        return [args];
     }
-    return args;
+  }
+  return args;
+};
+export {
+  __ensureAlpha,
+  __ensureArgs
 };