@thi.ng/color 3.2.6 → 4.0.3

package/lib/index.js

@@ -1,2236 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var strings = require('@thi.ng/strings');
-var checks = require('@thi.ng/checks');
-var errors = require('@thi.ng/errors');
-var math = require('@thi.ng/math');
-var vectors = require('@thi.ng/vectors');
-var api = require('@thi.ng/api');
-var binary = require('@thi.ng/binary');
-var random = require('@thi.ng/random');
-var defmulti = require('@thi.ng/defmulti');
-var arrays = require('@thi.ng/arrays');
-var compose = require('@thi.ng/compose');
-var transducers = require('@thi.ng/transducers');
-var compare = require('@thi.ng/compare');
-
-exports.Hue = void 0;
-(function (Hue) {
-    Hue[Hue["RED"] = 0] = "RED";
-    Hue[Hue["ORANGE"] = 1] = "ORANGE";
-    Hue[Hue["YELLOW"] = 2] = "YELLOW";
-    Hue[Hue["CHARTREUSE"] = 3] = "CHARTREUSE";
-    Hue[Hue["GREEN"] = 4] = "GREEN";
-    Hue[Hue["SPRING_GREEN"] = 5] = "SPRING_GREEN";
-    Hue[Hue["CYAN"] = 6] = "CYAN";
-    Hue[Hue["AZURE"] = 7] = "AZURE";
-    Hue[Hue["BLUE"] = 8] = "BLUE";
-    Hue[Hue["VIOLET"] = 9] = "VIOLET";
-    Hue[Hue["MAGENTA"] = 10] = "MAGENTA";
-    Hue[Hue["ROSE"] = 11] = "ROSE";
-})(exports.Hue || (exports.Hue = {}));
-class ParsedColor {
-    constructor(mode, value) {
-        this.mode = mode;
-        this.value = value;
-    }
-    deref() {
-        return this.value;
-    }
-}
-
-const BLACK = Object.freeze([0, 0, 0, 1]);
-const WHITE = Object.freeze([1, 1, 1, 1]);
-const RED = Object.freeze([1, 0, 0, 1]);
-const GREEN = Object.freeze([0, 1, 0, 1]);
-const BLUE = Object.freeze([0, 0, 1, 1]);
-const CYAN = Object.freeze([0, 1, 1, 1]);
-const MAGENTA = Object.freeze([1, 0, 1, 1]);
-const YELLOW = Object.freeze([1, 1, 0, 1]);
-const RGB_LUMINANCE_REC601 = [0.299, 0.587, 0.114];
-const RGB_LUMINANCE_REC709 = [0.2126, 0.7152, 0.0722];
-const RGB_LUMINANCE_REC2020 = [0.2627, 0.678, 0.0593];
-const RGB_XYZ_D50 = [
-    0.4360747,
-    0.2225045,
-    0.0139322,
-    0.3850649,
-    0.7168786,
-    0.0971045,
-    0.1430804,
-    0.0606169,
-    0.7141733,
-];
-const XYZ_RGB_D50 = [
-    3.1338561,
-    -0.9787684,
-    0.0719453,
-    -1.6168667,
-    1.9161415,
-    -0.2289914,
-    -0.4906146,
-    0.033454,
-    1.4052427,
-];
-const RGB_XYZ_D65 = [
-    0.4124564,
-    0.2126729,
-    0.0193339,
-    0.3575761,
-    0.7151522,
-    0.119192,
-    0.1804375,
-    0.072175,
-    0.9503041,
-];
-const XYZ_RGB_D65 = [
-    3.2404542,
-    -0.969266,
-    0.0556434,
-    -1.5371385,
-    1.8760108,
-    -0.2040259,
-    -0.4985314,
-    0.041556,
-    1.0572252,
-];
-const BRADFORD_D50_D65 = [
-    0.9555766,
-    -0.0282895,
-    0.0122982,
-    -0.0230393,
-    1.0099416,
-    -0.020483,
-    0.0631636,
-    0.0210077,
-    1.3299098,
-];
-const BRADFORD_D65_D50 = [
-    1.0478112,
-    0.0295424,
-    -0.0092345,
-    0.0228866,
-    0.9904844,
-    0.0150436,
-    -0.050127,
-    -0.0170491,
-    0.7521316,
-];
-const D50 = [0.96422, 1, 0.82521];
-const D65 = [0.95047, 1, 1.08883];
-const OKLAB_M1 = [
-    0.8189330101,
-    0.0329845436,
-    0.0482003018,
-    0.3618667424,
-    0.9293118715,
-    0.2643662691,
-    -0.1288597137,
-    0.0361456387,
-    0.633851707,
-];
-const OKLAB_M2 = [
-    0.2104542553,
-    1.9779984951,
-    0.0259040371,
-    0.793617785,
-    -2.428592205,
-    0.7827717662,
-    -0.0040720468,
-    0.4505937099,
-    -0.808675766,
-];
-exports.FF = strings.float(3);
-exports.PC = strings.percent(3);
-const setPrecision = (x) => {
-    exports.FF = strings.float(x);
-    exports.PC = strings.percent(x);
-};
-const INV8BIT = 1 / 0xff;
-const EPS = 1 / 256;
-
-const CSS_NAMES = {
-    aliceblue: "f0f8ff",
-    antiquewhite: "faebd7",
-    aqua: "0ff",
-    aquamarine: "7fffd4",
-    azure: "f0ffff",
-    beige: "f5f5dc",
-    bisque: "ffe4c4",
-    black: "000",
-    blanchedalmond: "ffebcd",
-    blue: "00f",
-    blueviolet: "8a2be2",
-    brown: "a52a2a",
-    burlywood: "deb887",
-    cadetblue: "5f9ea0",
-    chartreuse: "7fff00",
-    chocolate: "d2691e",
-    coral: "ff7f50",
-    cornflowerblue: "6495ed",
-    cornsilk: "fff8dc",
-    crimson: "dc143c",
-    cyan: "0ff",
-    darkblue: "00008b",
-    darkcyan: "008b8b",
-    darkgoldenrod: "b8860b",
-    darkgray: "a9a9a9",
-    darkgreen: "006400",
-    darkgrey: "a9a9a9",
-    darkkhaki: "bdb76b",
-    darkmagenta: "8b008b",
-    darkolivegreen: "556b2f",
-    darkorange: "ff8c00",
-    darkorchid: "9932cc",
-    darkred: "8b0000",
-    darksalmon: "e9967a",
-    darkseagreen: "8fbc8f",
-    darkslateblue: "483d8b",
-    darkslategray: "2f4f4f",
-    darkslategrey: "2f4f4f",
-    darkturquoise: "00ced1",
-    darkviolet: "9400d3",
-    deeppink: "ff1493",
-    deepskyblue: "00bfff",
-    dimgray: "696969",
-    dimgrey: "696969",
-    dodgerblue: "1e90ff",
-    firebrick: "b22222",
-    floralwhite: "fffaf0",
-    forestgreen: "228b22",
-    fuchsia: "f0f",
-    gainsboro: "dcdcdc",
-    ghostwhite: "f8f8ff",
-    gold: "ffd700",
-    goldenrod: "daa520",
-    gray: "808080",
-    grey: "808080",
-    green: "008000",
-    greenyellow: "adff2f",
-    honeydew: "f0fff0",
-    hotpink: "ff69b4",
-    indianred: "cd5c5c",
-    indigo: "4b0082",
-    ivory: "fffff0",
-    khaki: "f0e68c",
-    lavender: "e6e6fa",
-    lavenderblush: "fff0f5",
-    lawngreen: "7cfc00",
-    lemonchiffon: "fffacd",
-    lightblue: "add8e6",
-    lightcoral: "f08080",
-    lightcyan: "e0ffff",
-    lightgoldenrodyellow: "fafad2",
-    lightgray: "d3d3d3",
-    lightgreen: "90ee90",
-    lightgrey: "d3d3d3",
-    lightpink: "ffb6c1",
-    lightsalmon: "ffa07a",
-    lightseagreen: "20b2aa",
-    lightskyblue: "87cefa",
-    lightslategray: "789",
-    lightslategrey: "789",
-    lightsteelblue: "b0c4de",
-    lightyellow: "ffffe0",
-    lime: "0f0",
-    limegreen: "32cd32",
-    linen: "faf0e6",
-    magenta: "f0f",
-    maroon: "800000",
-    mediumaquamarine: "66cdaa",
-    mediumblue: "0000cd",
-    mediumorchid: "ba55d3",
-    mediumpurple: "9370db",
-    mediumseagreen: "3cb371",
-    mediumslateblue: "7b68ee",
-    mediumspringgreen: "00fa9a",
-    mediumturquoise: "48d1cc",
-    mediumvioletred: "c71585",
-    midnightblue: "191970",
-    mintcream: "f5fffa",
-    mistyrose: "ffe4e1",
-    moccasin: "ffe4b5",
-    navajowhite: "ffdead",
-    navy: "000080",
-    oldlace: "fdf5e6",
-    olive: "808000",
-    olivedrab: "6b8e23",
-    orange: "ffa500",
-    orangered: "ff4500",
-    orchid: "da70d6",
-    palegoldenrod: "eee8aa",
-    palegreen: "98fb98",
-    paleturquoise: "afeeee",
-    palevioletred: "db7093",
-    papayawhip: "ffefd5",
-    peachpuff: "ffdab9",
-    peru: "cd853f",
-    pink: "ffc0cb",
-    plum: "dda0dd",
-    powderblue: "b0e0e6",
-    purple: "800080",
-    red: "f00",
-    rosybrown: "bc8f8f",
-    royalblue: "4169e1",
-    saddlebrown: "8b4513",
-    salmon: "fa8072",
-    sandybrown: "f4a460",
-    seagreen: "2e8b57",
-    seashell: "fff5ee",
-    sienna: "a0522d",
-    silver: "c0c0c0",
-    skyblue: "87ceeb",
-    slateblue: "6a5acd",
-    slategray: "708090",
-    slategrey: "708090",
-    snow: "fffafa",
-    springgreen: "00ff7f",
-    steelblue: "4682b4",
-    tan: "d2b48c",
-    teal: "008080",
-    thistle: "d8bfd8",
-    tomato: "ff6347",
-    turquoise: "40e0d0",
-    violet: "ee82ee",
-    wheat: "f5deb3",
-    white: "fff",
-    whitesmoke: "f5f5f5",
-    yellow: "ff0",
-    yellowgreen: "9acd32",
-    transparent: "0000",
-    rebeccapurple: "639",
-};
-
-let CSS_SYSTEM_COLORS = {
-    canvas: "fff",
-    canvastext: "000",
-    linktext: "001ee4",
-    visitedtext: "4e2386",
-    activetext: "eb3323",
-    buttonface: "ddd",
-    buttontext: "000",
-    buttonborder: "000",
-    field: "fff",
-    fieldtext: "000",
-    highlight: "bbd5fb",
-    highlighttext: "000",
-    mark: "000",
-    marktext: "fff",
-    graytext: "808080",
-};
-const setSystemColors = (cols) => Object.assign(CSS_SYSTEM_COLORS, cols);
-
-const CONVERSIONS = {};
-const defConversions = (mode, spec) => {
-    for (let id in spec) {
-        const val = spec[id];
-        if (checks.isArray(val)) {
-            const [a, b, c, d] = val;
-            spec[id] =
-                val.length === 2
-                    ? (out, src) => b(out, a(out, src))
-                    : val.length === 3
-                        ? (out, src) => c(out, b(out, a(out, src)))
-                        : (out, src) => d(out, c(out, b(out, a(out, src))));
-        }
-    }
-    CONVERSIONS[mode] = spec;
-};
-const convert = (res, src, destMode, srcMode) => {
-    const spec = CONVERSIONS[destMode];
-    api.assert(!!spec, `no conversions available for ${destMode}`);
-    let $convert = spec[srcMode];
-    return $convert
-        ? $convert(res, src)
-        : CONVERSIONS.rgb[srcMode]
-            ? spec.rgb(res, CONVERSIONS.rgb[srcMode]([], src))
-            : errors.unsupported(`can't convert: ${srcMode} -> ${destMode}`);
-};
-
-const intArgb32Srgb = (out, src) => vectors.setC4(out || [], ((src >>> 16) & 0xff) * INV8BIT, ((src >>> 8) & 0xff) * INV8BIT, (src & 0xff) * INV8BIT, (src >>> 24) * INV8BIT);
-const intAbgr32Srgb = (out, src) => vectors.setC4(out || [], (src & 0xff) * INV8BIT, ((src >>> 8) & 0xff) * INV8BIT, ((src >>> 16) & 0xff) * INV8BIT, (src >>> 24) * INV8BIT);
-const intRgb24Srgb = (out, src) => intArgb32Srgb(out, src | 0xff000000);
-const intBgr24Srgb = (out, src) => intAbgr32Srgb(out, src | 0xff000000);
-
-const parseCss = (src) => {
-    src = (checks.isString(src) ? src : src.deref()).toLowerCase();
-    const named = CSS_NAMES[src] || CSS_SYSTEM_COLORS[src];
-    if (named || src[0] === "#")
-        return new ParsedColor("srgb", intArgb32Srgb([], parseHex(named || src)));
-    const parts = src.split(/[(),/ ]+/);
-    const [mode, a, b, c, d] = parts;
-    api.assert(parts.length === 5 || parts.length === 6, `invalid ${mode} color: ${src}`);
-    switch (mode) {
-        case "rgb":
-        case "rgba":
-            return new ParsedColor("srgb", [
-                parseNumOrPercent(a),
-                parseNumOrPercent(b),
-                parseNumOrPercent(c),
-                parseAlpha(d),
-            ]);
-        case "hsl":
-        case "hsla":
-            return new ParsedColor("hsl", [
-                parseHue(a),
-                parsePercent(b),
-                parsePercent(c),
-                parseAlpha(d),
-            ]);
-        case "lab":
-            return new ParsedColor("lab50", [
-                parsePercent(a, false),
-                parseNumber(b) * 0.01,
-                parseNumber(c) * 0.01,
-                parseAlpha(d),
-            ]);
-        case "lch":
-            return new ParsedColor("lch", [
-                parsePercent(a, false),
-                parseNumber(b) * 0.01,
-                parseHue(c),
-                parseAlpha(d),
-            ]);
-        default:
-            errors.unsupported(`color mode: ${mode}`);
-    }
-};
-const HUE_NORMS = {
-    rad: math.TAU,
-    grad: 400,
-    turn: 1,
-    deg: 360,
-    undefined: 360,
-};
-const parseHue = (x) => {
-    const match = /^(-?[0-9.]+)(deg|rad|grad|turn)?$/.exec(x);
-    api.assert(!!match, `expected hue, got: ${x}`);
-    return math.fract(parseFloat(match[1]) / HUE_NORMS[match[2]]);
-};
-const parseAlpha = (x) => (x ? parseNumOrPercent(x, 1) : 1);
-const parsePercent = (x, clamp = true) => {
-    api.assert(/^([0-9.]+)%$/.test(x), `expected percentage, got: ${x}`);
-    const res = parseFloat(x) / 100;
-    return clamp ? math.clamp01(res) : res;
-};
-const parseNumber = (x) => {
-    api.assert(/^-?[0-9.]+$/.test(x), `expected number, got: ${x}`);
-    return parseFloat(x);
-};
-const parseNumOrPercent = (x, norm = 255, clamp = true) => {
-    api.assert(/^-?[0-9.]+%?$/.test(x), `expected number or percentage, got: ${x}`);
-    const res = parseFloat(x) / (x.endsWith("%") ? 100 : norm);
-    return clamp ? math.clamp01(res) : res;
-};
-const parseHex = (src) => {
-    const match = /^#?([0-9a-f]{3,8})$/i.exec(src);
-    if (match) {
-        const hex = match[1];
-        switch (hex.length) {
-            case 3:
-                return ((binary.interleave4_12_24(parseInt(hex, 16)) | 0xff000000) >>> 0);
-            case 4:
-                return binary.interleave4_16_32(parseInt(hex, 16)) >>> 0;
-            case 6:
-                return (parseInt(hex, 16) | 0xff000000) >>> 0;
-            case 8:
-                return parseInt(hex, 16) >>> 0;
-        }
-    }
-    return errors.illegalArgs(`invalid hex color: "${src}"`);
-};
-
-const ensureAlpha = (x, def = 1) => x != undefined ? math.clamp01(x) : def;
-
-const linearSrgb = (x) => x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055;
-const srgbLinear = (x) => x <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4);
-
-const srgbRgb = (out, src) => vectors.setC4(out || src, srgbLinear(src[0]), srgbLinear(src[1]), srgbLinear(src[2]), ensureAlpha(src[3]));
-const GAMMA$1 = 2.2;
-const srgbRgbApprox = (out, src) => vectors.setC4(out || src, src[0] ** GAMMA$1, src[1] ** GAMMA$1, src[2] ** GAMMA$1, ensureAlpha(src[3]));
-
-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));
-
-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;
-};
-
-const defColor = (spec) => {
-    const channels = spec.channels || {};
-    const order = spec.order;
-    const numChannels = order.length;
-    order.reduce((acc, id) => {
-        acc[id] = Object.assign({ range: [0, 1] }, channels[id]);
-        return acc;
-    }, channels);
-    const min = order.map((id) => channels[id].range[0]);
-    const max = order.map((id) => channels[id].range[1]);
-    const minR = vectors.set4([], min);
-    const maxR = vectors.set4([], max);
-    minR[numChannels - 1] = 1;
-    const $Color = class {
-        constructor(buf, offset = 0, stride = 1) {
-            this.offset = offset;
-            this.stride = stride;
-            this.buf = buf || [0, 0, 0, 0];
-            this.offset = offset;
-            this.stride = stride;
-        }
-        get mode() {
-            return spec.mode;
-        }
-        get length() {
-            return numChannels;
-        }
-        get range() {
-            return [min, max];
-        }
-        get [Symbol.toStringTag]() {
-            return spec.mode;
-        }
-        [Symbol.iterator]() {
-            return vectors.stridedValues(this.buf, this.length, this.offset, this.stride);
-        }
-        copy() {
-            return new $Color(this.deref());
-        }
-        copyView() {
-            return new $Color(this.buf, this.offset, this.stride);
-        }
-        empty() {
-            return new $Color();
-        }
-        deref() {
-            return [this[0], this[1], this[2], this[3]];
-        }
-        set(src) {
-            return vectors.set4(this, src);
-        }
-        clamp() {
-            return vectors.clamp4(null, this, min, max);
-        }
-        eqDelta(o, eps = math.EPS) {
-            return vectors.eqDelta4(this, o, eps);
-        }
-        randomize(rnd) {
-            return vectors.randMinMax(this, minR, maxR, rnd);
-        }
-        toJSON() {
-            return this.deref();
-        }
-        toString() {
-            return strings.vector(4, 4)(this);
-        }
-    };
-    vectors.declareIndices($Color.prototype, order);
-    defConversions(spec.mode, spec.from);
-    const fromColor = (src, mode, xs) => {
-        const res = new $Color(...xs);
-        return mode !== spec.mode
-            ? convert(res, src, spec.mode, mode)
-            : res.set(src);
-    };
-    const factory = (src, ...xs) => src == null
-        ? new $Color()
-        : checks.isString(src)
-            ? factory(parseCss(src), ...xs)
-            : checks.isArrayLike(src)
-                ? checks.isString(src.mode)
-                    ? fromColor(src, src.mode, xs)
-                    : new $Color(src, ...xs)
-                : checks.implementsFunction(src, "deref")
-                    ? fromColor(src.deref(), src.mode, xs)
-                    : checks.isNumber(src)
-                        ? xs.length && xs.every(checks.isNumber)
-                            ? new $Color(...ensureArgs([src, ...xs]))
-                            : fromColor(intArgb32Rgb([], src), "rgb", xs)
-                        : errors.illegalArgs(`can't create a ${spec.mode} color from: ${src}`);
-    factory.class = $Color;
-    factory.range = [min, max];
-    factory.random = (rnd, buf, idx, stride) => new $Color(buf, idx, stride).randomize(rnd);
-    factory.mapBuffer = (buf, num = (buf.length / numChannels) | 0, start = 0, cstride = 1, estride = numChannels) => vectors.mapStridedBuffer($Color, buf, num, start, cstride, estride);
-    return factory;
-};
-
-const hueRgb = (out, hue, alpha = 1) => {
-    hue = math.fract(hue) * 6;
-    return vectors.setC4(out || [], math.clamp01(Math.abs(hue - 3) - 1), math.clamp01(2 - Math.abs(hue - 2)), math.clamp01(2 - Math.abs(hue - 4)), alpha);
-};
-const namedHueRgb = (out, hue, alpha = 1) => hueRgb(out, hue / 12, alpha);
-
-const luminanceRgb = (rgb, weights = RGB_LUMINANCE_REC709) => vectors.dot3(rgb, weights);
-const luminanceSrgb = (rgb) => vectors.dot3(rgb, RGB_LUMINANCE_REC601);
-const luminanceIntArgb32 = (rgb) => (((rgb >>> 16) & 0xff) * 76 +
-    ((rgb >>> 8) & 0xff) * 150 +
-    (rgb & 0xff) * 29) /
-    0xfe01;
-const luminanceIntAbgr32 = (rgb) => (((rgb >>> 16) & 0xff) * 29 +
-    ((rgb >>> 8) & 0xff) * 150 +
-    (rgb & 0xff) * 76) /
-    0xfe01;
-const luminanceArgb32 = (argb) => luminanceIntArgb32(argb[0]);
-const luminanceAbgr32 = (argb) => luminanceIntAbgr32(argb[0]);
-
-const clamp = (out, src, alpha = 1) => vectors.setC4(out || src, math.clamp01(src[0]), math.clamp01(src[1]), math.clamp01(src[2]), ensureAlpha(src[3], alpha));
-const clampH = (out, src, alpha = 1) => vectors.setC4(out || src, math.fract(src[0]), math.clamp01(src[1]), math.clamp01(src[2]), ensureAlpha(src[3], alpha));
-
-const rgbHcv = (out, src) => {
-    out = clamp(out || src, src);
-    const p = out[1] < out[2]
-        ? [out[2], out[1], -1, 2 / 3]
-        : [out[1], out[2], 0, -1 / 3];
-    const q = out[0] < p[0] ? [p[0], p[1], p[3], out[0]] : [out[0], p[1], p[2], p[0]];
-    const c = q[0] - Math.min(q[1], q[3]);
-    return vectors.setC3(out, math.clamp01(Math.abs((q[3] - q[1]) / (6 * c + math.EPS) + q[2])), math.clamp01(c), math.clamp01(q[0]));
-};
-
-const rgbHcy = (out, src) => {
-    const y = luminanceRgb(src);
-    out = rgbHcv(out, src);
-    const z = luminanceRgb(hueRgb([], out[0]));
-    out[1] *= y < z ? z / (y + math.EPS) : (1 - z) / (1 + math.EPS - y);
-    out[2] = y;
-    return out;
-};
-
-const hcy = defColor({
-    mode: "hcy",
-    order: ["h", "c", "y", "alpha"],
-    from: { rgb: rgbHcy, srgb: rgbHcy },
-});
-
-const SQRT32 = math.SQRT3 / 2;
-const rgbHsi = (out, src) => {
-    out = clamp(out || src, src);
-    const { 0: r, 1: g, 2: b } = out;
-    const i = math.THIRD * (r + g + b);
-    return i < 1e-6 || (r === g && r === b)
-        ? vectors.setC3(out, 0, 0, i)
-        : vectors.setC3(out, math.atan2Abs(SQRT32 * (g - b), 0.5 * (2 * r - g - b)) / math.TAU, 1 - Math.min(r, g, b) / i, i);
-};
-
-const hsi = defColor({
-    mode: "hsi",
-    order: ["h", "s", "i", "alpha"],
-    from: { rgb: rgbHsi, srgb: rgbHsi },
-});
-
-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 rgbHsl = (out, src) => {
-    out = rgbHcv(out, src);
-    out[2] -= out[1] * 0.5;
-    out[1] /= 1 + math.EPS - Math.abs(out[2] * 2 - 1);
-    return out;
-};
-
-const hsl = defColor({
-    mode: "hsl",
-    order: ["h", "s", "l", "alpha"],
-    from: { rgb: rgbHsl, srgb: rgbHsl, hsv: hsvHsl },
-});
-
-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 rgbHsv = (out, src) => {
-    out = rgbHcv(out, src);
-    out[1] /= out[2] + math.EPS;
-    return out;
-};
-
-const hsv = defColor({
-    mode: "hsv",
-    order: ["h", "s", "v", "alpha"],
-    from: { rgb: rgbHsv, srgb: rgbHsv, hsl: hslHsv },
-});
-
-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 vectors.setC3(rgb, math.clamp01((rgb[0] - lum) * c + y), math.clamp01((rgb[1] - lum) * c + y), math.clamp01((rgb[2] - lum) * c + y));
-};
-
-const hsiRgb = (out, src) => {
-    out = clampH(out || src, src);
-    const s = out[1];
-    const i = out[2];
-    if (s < 1e-6) {
-        return vectors.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 vectors.setC3(out, c, x, m);
-        case 1:
-            return vectors.setC3(out, x, c, m);
-        case 2:
-            return vectors.setC3(out, m, c, x);
-        case 3:
-            return vectors.setC3(out, m, x, c);
-        case 4:
-            return vectors.setC3(out, x, m, c);
-        case 5:
-            return vectors.setC3(out, c, m, x);
-        default:
-            return vectors.setC3(out, m, m, m);
-    }
-};
-
-const hslRgb = (out, src) => {
-    const s = math.clamp01(src[1]);
-    const l = math.clamp01(src[2]);
-    out = hueRgb(out || src, src[0], ensureAlpha(src[3]));
-    const c = (1 - Math.abs(2 * l - 1)) * s;
-    return vectors.setC3(out, (out[0] - 0.5) * c + l, (out[1] - 0.5) * c + l, (out[2] - 0.5) * c + l);
-};
-
-const hsvRgb = (out, src) => {
-    out = clampH(out || src, src);
-    const s = out[1];
-    const v = out[2];
-    hueRgb(out, src[0], out[3]);
-    return vectors.setC3(out, ((out[0] - 1) * s + 1) * v, ((out[1] - 1) * s + 1) * v, ((out[2] - 1) * s + 1) * v);
-};
-
-const rgbSrgb = (out, src) => vectors.setC4(out || src, linearSrgb(src[0]), linearSrgb(src[1]), linearSrgb(src[2]), ensureAlpha(src[3]));
-const GAMMA = 1 / 2.2;
-const rgbSrgbApprox = (out, src) => vectors.setC4(out || src, src[0] ** GAMMA, src[1] ** GAMMA, src[2] ** GAMMA, ensureAlpha(src[3]));
-
-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,
-    },
-});
-
-const srgbIntArgb32 = (src) => (((ensureAlpha(src[3]) * 0xff + 0.5) << 24) |
-    ((math.clamp01(src[0]) * 0xff + 0.5) << 16) |
-    ((math.clamp01(src[1]) * 0xff + 0.5) << 8) |
-    (math.clamp01(src[2]) * 0xff + 0.5)) >>>
-    0;
-const srgbIntAbgr32 = (src) => (((ensureAlpha(src[3]) * 0xff + 0.5) << 24) |
-    ((math.clamp01(src[2]) * 0xff + 0.5) << 16) |
-    ((math.clamp01(src[1]) * 0xff + 0.5) << 8) |
-    (math.clamp01(src[0]) * 0xff + 0.5)) >>>
-    0;
-
-class Int32 {
-    constructor(buf, offset = 0, stride = 1) {
-        this.offset = offset;
-        this.stride = stride;
-        this.buf = buf || [0];
-    }
-    get length() {
-        return 1;
-    }
-    get range() {
-        return [[0], [0xffffffff]];
-    }
-    get alpha() {
-        return (this[0] >>> 24) / 255;
-    }
-    set alpha(a) {
-        this[0] = (this[0] & 0xffffff) | ((math.clamp01(a) * 0xff + 0.5) << 24);
-    }
-    *[Symbol.iterator]() {
-        yield this[0];
-    }
-    deref() {
-        return [this[0]];
-    }
-    randomize(rnd = random.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 ARGB extends Int32 {
-    get mode() {
-        return "argb32";
-    }
-    copy() {
-        return new ARGB([this[0]]);
-    }
-    copyView() {
-        return new ARGB(this.buf, this.offset, this.stride);
-    }
-    empty() {
-        return new ARGB();
-    }
-    eqDelta(o, eps = 0) {
-        return vectors.eqDelta4(intArgb32Srgb([], this[0]), intArgb32Srgb([], o[0]), eps);
-    }
-}
-vectors.declareIndex(ARGB.prototype, "value", 0);
-class ABGR extends Int32 {
-    get mode() {
-        return "abgr32";
-    }
-    copy() {
-        return new ABGR([this[0]]);
-    }
-    copyView() {
-        return new ABGR(this.buf, this.offset, this.stride);
-    }
-    empty() {
-        return new ABGR();
-    }
-    eqDelta(o, eps = 0) {
-        return vectors.eqDelta4(intAbgr32Srgb([], this[0]), intAbgr32Srgb([], o[0]), eps);
-    }
-}
-vectors.declareIndex(ABGR.prototype, "value", 0);
-const defInt = (ctor, fromSrgb) => {
-    const factory = (src, ...xs) => src == null
-        ? new ARGB()
-        : checks.isNumber(src)
-            ? xs.length && xs.every(checks.isNumber)
-                ? new ctor([srgbIntArgb32([src, ...xs])])
-                : new ctor([src], ...xs)
-            : checks.isString(src)
-                ? factory(parseCss(src))
-                : checks.isArrayLike(src)
-                    ? checks.isString(src.mode)
-                        ? new ctor([fromSrgb(srgb(src))], ...xs)
-                        : new ctor(src, ...xs)
-                    : checks.implementsFunction(src, "deref")
-                        ? new ctor([fromSrgb(srgb(src))], ...xs)
-                        : errors.illegalArgs(`can't create a ARGB32 color from: ${src}`);
-    factory.class = ctor;
-    factory.range = [[0], [0xffffffff]];
-    factory.random = (rnd = random.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) => vectors.mapStridedBuffer(ARGB, buf, num, start, cstride, estride);
-    return factory;
-};
-const argb32 = defInt(ARGB, srgbIntArgb32);
-const abgr32 = defInt(ABGR, srgbIntAbgr32);
-
-const mulV33 = (out, mat, src, clampOut = false) => {
-    const x = vectors.dotS3(mat, src, 0, 0, 3);
-    const y = vectors.dotS3(mat, src, 1, 0, 3);
-    const z = vectors.dotS3(mat, src, 2, 0, 3);
-    const a = ensureAlpha(src[3]);
-    return clampOut
-        ? vectors.setC4(out || src, math.clamp01(x), math.clamp01(y), math.clamp01(z), a)
-        : vectors.setC4(out || src, x, y, z, a);
-};
-const mulV45 = (out, mat, src, clampOut = true) => {
-    out = vectors.setC4(out || src, src[0], src[1], src[2], ensureAlpha(src[3]));
-    const x = vectors.dotS4(out, mat, 0, 0) + mat[4];
-    const y = vectors.dotS4(out, mat, 0, 5) + mat[9];
-    const z = vectors.dotS4(out, mat, 0, 10) + mat[14];
-    const w = vectors.dotS4(out, mat, 0, 15) + mat[19];
-    return clampOut
-        ? vectors.setC4(out, math.clamp01(x), math.clamp01(y), math.clamp01(z), math.clamp01(w))
-        : vectors.setC4(out, x, y, z, w);
-};
-const mulM45 = (a, b) => [
-    vectors.dotS4(b, a, 0, 0, 1, 5),
-    vectors.dotS4(b, a, 0, 1, 1, 5),
-    vectors.dotS4(b, a, 0, 2, 1, 5),
-    vectors.dotS4(b, a, 0, 3, 1, 5),
-    vectors.dotS4(b, a, 0, 4, 1, 5) + b[4],
-    vectors.dotS4(b, a, 5, 0, 1, 5),
-    vectors.dotS4(b, a, 5, 1, 1, 5),
-    vectors.dotS4(b, a, 5, 2, 1, 5),
-    vectors.dotS4(b, a, 5, 3, 1, 5),
-    vectors.dotS4(b, a, 5, 4, 1, 5) + b[9],
-    vectors.dotS4(b, a, 10, 0, 1, 5),
-    vectors.dotS4(b, a, 10, 1, 1, 5),
-    vectors.dotS4(b, a, 10, 2, 1, 5),
-    vectors.dotS4(b, a, 10, 3, 1, 5),
-    vectors.dotS4(b, a, 10, 4, 1, 5) + b[14],
-    vectors.dotS4(b, a, 15, 0, 1, 5),
-    vectors.dotS4(b, a, 15, 1, 1, 5),
-    vectors.dotS4(b, a, 15, 2, 1, 5),
-    vectors.dotS4(b, a, 15, 3, 1, 5),
-    vectors.dotS4(b, a, 15, 4, 1, 5) + b[19],
-];
-
-const rgbXyz = (out, src, mat = RGB_XYZ_D50) => mulV33(null, mat, clamp(out, src));
-const rgbXyzD65 = (out, src) => rgbXyz(out, src, RGB_XYZ_D65);
-
-const transform$2 = (x) => x > 0.00885645 ? Math.cbrt(x) : 7.787037 * x + 16 / 116;
-const xyzLab = (out, src, white = D50) => {
-    const x = transform$2(src[0] / white[0]);
-    const y = transform$2(src[1] / white[1]);
-    const z = transform$2(src[2] / white[2]);
-    return vectors.setC4(out || src, 1.16 * y - 0.16, 5.0 * (x - y), 2.0 * (y - z), ensureAlpha(src[3]));
-};
-const xyzLabD65 = (out, src) => xyzLab(out, src, D65);
-
-const rgbLab = (out, src) => xyzLab(null, rgbXyz(out, src));
-const rgbLabD65 = (out, src) => xyzLabD65(null, rgbXyzD65(out, src));
-
-const xyzXyzD65_50 = (out, src) => mulV33(out, BRADFORD_D65_D50, src);
-const xyzXyzD50_65 = (out, src) => mulV33(out, BRADFORD_D50_D65, src);
-
-const transform$1 = (x) => {
-    const y = x ** 3;
-    return y > 0.008856 ? y : (x - 16 / 116) / 7.787;
-};
-const labXyz = (out, src, white = D50) => {
-    const y = (src[0] + 0.16) / 1.16;
-    return vectors.setC4(out || src, transform$1(src[1] / 5.0 + y) * white[0], transform$1(y) * white[1], transform$1(y - src[2] / 2.0) * white[2], ensureAlpha(src[3]));
-};
-const labXyzD65 = (out, src) => labXyz(out, src, D65);
-
-const labLabD50_65 = (out, src) => xyzLabD65(out, xyzXyzD50_65(out, labXyz(out, src)));
-const labLabD65_50 = (out, src) => xyzLab(out, xyzXyzD65_50(out, labXyzD65(out, src)));
-
-const labLch = (out, src) => {
-    const { 1: a, 2: b } = src;
-    return vectors.setC4(out || src, src[0], Math.hypot(a, b), a === 0 && b === 0 ? 0 : math.atan2Abs(b, a) * math.INV_TAU, ensureAlpha(src[3]));
-};
-const lchLab = (out, src) => {
-    let { 1: c, 2: h } = src;
-    h *= math.TAU;
-    const a = ensureAlpha(src[3]);
-    return c > 0
-        ? vectors.setC4(out || src, src[0], Math.cos(h) * c, Math.sin(h) * c, a)
-        : vectors.setC4(out || src, src[0], 0, 0, a);
-};
-
-const labD50 = defColor({
-    mode: "lab50",
-    channels: {
-        a: { range: [-0.7929, 0.9355] },
-        b: { range: [-1.1203, 0.9339] },
-    },
-    order: ["l", "a", "b", "alpha"],
-    from: {
-        rgb: rgbLab,
-        lch: lchLab,
-        lab65: labLabD65_50,
-        xyz50: xyzLab,
-        xyz65: [xyzXyzD65_50, xyzLab],
-    },
-});
-
-const labD65 = defColor({
-    mode: "lab65",
-    channels: {
-        a: { range: [-0.8618, 0.9823] },
-        b: { range: [-1.0786, 0.9448] },
-    },
-    order: ["l", "a", "b", "alpha"],
-    from: {
-        rgb: rgbLabD65,
-        lch: [lchLab, labLabD50_65],
-        lab50: labLabD50_65,
-        xyz50: [xyzXyzD50_65, xyzLabD65],
-        xyz65: xyzLabD65,
-    },
-});
-
-const lch = defColor({
-    mode: "lch",
-    channels: {
-        c: { range: [0, 1.312] },
-    },
-    order: ["l", "c", "h", "alpha"],
-    from: {
-        rgb: (out, src) => labLch(null, rgbLab(out, src)),
-        lab50: labLch,
-        lab65: [labLabD65_50, labLch],
-        xyz50: [xyzLab, labLch],
-        xyz65: [xyzXyzD65_50, xyzLab, labLch],
-    },
-});
-
-const CONE_LMS = [
-    0.412165612,
-    0.211859107,
-    0.0883097947,
-    0.536275208,
-    0.6807189584,
-    0.2818474174,
-    0.0514575653,
-    0.107406579,
-    0.6302613616,
-];
-const rgbOklab = (out, src) => mulV33(null, OKLAB_M2, vectors.powN3(null, mulV33(out, CONE_LMS, src), 1 / 3));
-
-const xyzOklab = (out, src) => mulV33(null, OKLAB_M2, vectors.powN3(null, mulV33(out, OKLAB_M1, src), 1 / 3));
-
-const oklab = defColor({
-    mode: "oklab",
-    channels: {
-        a: { range: [-0.2339, 0.2763] },
-        b: { range: [-0.3116, 0.1985] },
-    },
-    order: ["l", "a", "b", "alpha"],
-    from: {
-        lab50: [labXyz, xyzXyzD50_65, xyzOklab],
-        lab65: [labXyzD65, xyzOklab],
-        lch: [lchLab, labXyzD65, xyzOklab],
-        rgb: rgbOklab,
-        xyz50: [xyzXyzD50_65, xyzOklab],
-        xyz65: xyzOklab,
-    },
-});
-
-const xyzRgb = (out, src, mat = XYZ_RGB_D50) => mulV33(out, mat, src);
-const xyzRgbD65 = (out, src) => xyzRgb(out, src, XYZ_RGB_D65);
-
-const labRgb = (out, src) => xyzRgb(null, labXyz(out, src));
-const labRgbD65 = (out, src) => xyzRgbD65(null, labXyzD65(out, src));
-
-const LMS_CONE = [
-    4.0767245293,
-    -1.2681437731,
-    -0.0041119885,
-    -3.3072168827,
-    2.6093323231,
-    -0.7034763098,
-    0.2307590544,
-    -0.341134429,
-    1.7068625689,
-];
-const oklabRgb = (out, { 0: l, 1: a, 2: b, 3: alpha }) => mulV33(out, LMS_CONE, [
-    (l + 0.3963377774 * a + 0.2158037573 * b) ** 3,
-    (l - 0.1055613458 * a - 0.0638541728 * b) ** 3,
-    (l - 0.0894841775 * a - 1.291485548 * b) ** 3,
-    alpha,
-]);
-
-const xyyXyz = (out, src) => {
-    const { 0: x, 1: y, 2: Y } = src;
-    return vectors.setC4(out || src, math.safeDiv(Y * x, y), Y, math.safeDiv(Y * (1 - x - y), y), ensureAlpha(src[3]));
-};
-
-const yccRgb = (out, src, luma = RGB_LUMINANCE_REC709) => {
-    const y = src[0];
-    const bb = (2 - 2 * luma[2]) * src[1];
-    const rr = (2 - 2 * luma[0]) * src[2];
-    return vectors.setC4(out || src, y + rr, y - (luma[2] / luma[1]) * bb - (luma[0] / luma[1]) * rr, y + bb, ensureAlpha(src[3]));
-};
-
-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: vectors.set4,
-        srgb: srgbRgb,
-        xyy: [xyyXyz, xyzRgbD65],
-        xyz50: xyzRgb,
-        xyz65: xyzRgbD65,
-        ycc: yccRgb,
-    },
-});
-
-const xyzXyy = (out, src) => {
-    const { 0: x, 1: Y } = src;
-    const sum = x + Y + src[2];
-    return vectors.setC4(out || src, math.safeDiv(x, sum), math.safeDiv(Y, sum), Y, ensureAlpha(src[3]));
-};
-
-const xyy = defColor({
-    mode: "xyy",
-    channels: {
-        x: { range: [0, 0.6484] },
-        y: { range: [0, 0.5979] },
-    },
-    order: ["x", "y", "Y", "alpha"],
-    from: {
-        rgb: (out, src) => xyzXyy(null, rgbXyzD65(out, src)),
-        xyz50: xyzXyy,
-        xyz65: xyzXyy,
-    },
-});
-
-const M1I = [
-    1.2270138511035211,
-    -0.04058017842328059,
-    -0.0763812845057069,
-    -0.5577999806518222,
-    1.1122568696168302,
-    -0.4214819784180127,
-    0.28125614896646783,
-    -0.07167667866560119,
-    1.586163220440795,
-];
-const M2I = [
-    0.9999999984505198,
-    1.0000000088817607,
-    1.0000000546724108,
-    0.3963377921737678,
-    -0.10556134232365633,
-    -0.08948418209496575,
-    0.21580375806075877,
-    -0.06385417477170588,
-    -1.2914855378640917,
-];
-const oklabXyzD65 = (out, src) => mulV33(null, M1I, vectors.powN3(null, mulV33(out, M2I, src), 3));
-
-const xyzD50 = defColor({
-    mode: "xyz50",
-    channels: {
-        x: { range: [0, D50[0]] },
-        y: { range: [0, D50[1]] },
-        z: { range: [0, D50[2]] },
-    },
-    order: ["x", "y", "z", "alpha"],
-    from: {
-        rgb: rgbXyz,
-        lab50: labXyz,
-        lab65: [labXyzD65, xyzXyzD65_50],
-        lch: [lchLab, labXyz],
-        oklab: [oklabXyzD65, xyzXyzD65_50],
-        xyy: xyyXyz,
-    },
-});
-
-const xyzD65 = defColor({
-    mode: "xyz65",
-    channels: {
-        x: { range: [0, D65[0]] },
-        y: { range: [0, D65[1]] },
-        z: { range: [0, D65[2]] },
-    },
-    order: ["x", "y", "z", "alpha"],
-    from: {
-        rgb: rgbXyzD65,
-        lab50: [labLabD50_65, labXyzD65],
-        lab65: labXyzD65,
-        lch: [lchLab, labLabD50_65, labXyzD65],
-        oklab: oklabXyzD65,
-        xyy: xyyXyz,
-    },
-});
-
-const rgbYcc = (out, src, luma = RGB_LUMINANCE_REC709) => {
-    const y = vectors.dot3(src, luma);
-    return vectors.setC4(out || src, y, (0.5 * (src[2] - y)) / (1 - luma[2]), (0.5 * (src[0] - y)) / (1 - luma[0]), ensureAlpha(src[3]));
-};
-
-const ycc = defColor({
-    mode: "ycc",
-    channels: {
-        cb: { range: [-0.5, 0.5] },
-        cr: { range: [-0.5, 0.5] },
-    },
-    order: ["y", "cb", "cr", "alpha"],
-    from: { rgb: rgbYcc },
-});
-
-const FACTORIES = {
-    argb32,
-    abgr32,
-    hcy,
-    hsi,
-    hsl,
-    hsv,
-    lab50: labD50,
-    lab65: labD65,
-    lch,
-    oklab,
-    rgb,
-    srgb,
-    xyy,
-    xyz50: xyzD50,
-    xyz65: xyzD65,
-    ycc,
-};
-function color(src, buf, idx, stride) {
-    if (checks.isString(src))
-        return FACTORIES[src](buf, idx, stride);
-    if (buf) {
-        const res = FACTORIES[src.mode](buf, idx, stride);
-        res.set(src.deref());
-        return res;
-    }
-    return FACTORIES[src.mode](src.deref());
-}
-
-const hslCss = (src) => {
-    const h = exports.FF(math.fract(src[0]) * 360);
-    const s = exports.PC(math.clamp01(src[1]));
-    const l = exports.PC(math.clamp01(src[2]));
-    const a = ensureAlpha(src[3]);
-    return a < 1 ? `hsla(${h},${s},${l},${exports.FF(a)})` : `hsl(${h},${s},${l})`;
-};
-
-const hsvCss = (src) => hslCss(hsvHsl([], src));
-
-const intArgb32Css = (src) => {
-    const a = src >>> 24;
-    return a < 255
-        ? `rgba(${(src >> 16) & 0xff},${(src >> 8) & 0xff},${src & 0xff},${exports.FF(a * INV8BIT)})`
-        : `#${strings.U24(src & 0xffffff)}`;
-};
-const intRgb24Css = (src) => `#${strings.U24(src & 0xffffff)}`;
-
-const intArgb32Abgr32 = binary.swapLane13;
-const intAbgr32Argb32 = binary.swapLane13;
-
-const srgbCss = (src) => {
-    const r = (math.clamp01(src[0]) * 0xff + 0.5) | 0;
-    const g = (math.clamp01(src[1]) * 0xff + 0.5) | 0;
-    const b = (math.clamp01(src[2]) * 0xff + 0.5) | 0;
-    const a = ensureAlpha(src[3]);
-    return a < 1
-        ? `rgba(${r},${g},${b},${exports.FF(a)})`
-        : `#${strings.U24((r << 16) | (g << 8) | b)}`;
-};
-
-const rgbCss = (src) => srgbCss(rgbSrgb([], src));
-
-const CSS_CONVERSIONS = {
-    abgr32: (x) => intArgb32Css(intAbgr32Argb32(x[0])),
-    argb32: (x) => intArgb32Css(x[0]),
-    hsl: hslCss,
-    hsv: hsvCss,
-    lab50: (src) => srgbCss(rgbSrgb(null, labRgb([], src))),
-    lab65: (src) => srgbCss(rgbSrgb(null, labRgbD65([], src))),
-    lch: (src) => srgbCss(rgbSrgb(null, labRgb(null, lchLab([], src)))),
-    rgb: rgbCss,
-    srgb: srgbCss,
-};
-const css = (src) => {
-    let asCss;
-    return checks.isString(src)
-        ? src
-        : checks.isNumber(src)
-            ? intArgb32Css(src)
-            : src.mode
-                ? (asCss = CSS_CONVERSIONS[src.mode])
-                    ? asCss(src)
-                    : CSS_CONVERSIONS.rgb(convert([], src, "rgb", src.mode))
-                : srgbCss(src);
-};
-
-const labCss = (src) => {
-    const l = exports.PC(math.clamp0(src[0]));
-    const a = exports.FF(src[1] * 100);
-    const b = exports.FF(src[2] * 100);
-    const alpha = ensureAlpha(src[3]);
-    return `lab(${l} ${a} ${b}` + (alpha < 1 ? `/${exports.FF(alpha)})` : ")");
-};
-
-const lchCss = (src) => {
-    const l = exports.PC(math.clamp0(src[0]));
-    const c = exports.FF(math.clamp0(src[1]) * 100);
-    const h = exports.FF(math.fract(src[2]) * 360);
-    const a = ensureAlpha(src[3]);
-    return `lch(${l} ${c} ${h}` + (a < 1 ? `/${exports.FF(a)})` : ")");
-};
-
-const alpha = (src) => src[3] !== undefined ? src[3] : 1;
-const setAlpha = (out, src, alpha) => vectors.setC4(out || src, src[0], src[1], src[2], alpha);
-
-const analogU = (x, delta, rnd) => delta !== 0 ? x + rnd.norm(delta) : x;
-const analogN = (x, delta, rnd, post = math.clamp01) => delta !== 0 ? post(x + rnd.norm(delta)) : x;
-const analogH = (x, delta, rnd) => analogN(x, delta, rnd, math.fract);
-const analogA = (a, delta, rnd) => delta !== 0
-    ? math.clamp01((a !== undefined ? a : 1) + rnd.norm(delta))
-    : ensureAlpha(a);
-const defAnalog = (x, y, z) => (out, src, delta, rnd = random.SYSTEM) => vectors.setC4(out || src, x(src[0], delta, rnd), y(src[1], delta, rnd), z(src[2], delta, rnd), ensureAlpha(src[3]));
-const analogHNN = defAnalog(analogH, analogN, analogN);
-const analogNNN = defAnalog(analogN, analogN, analogN);
-const analogNUU = defAnalog(analogN, analogU, analogU);
-const analog = defmulti.defmulti((_, src) => src.mode);
-analog.add(defmulti.DEFAULT, analogNNN);
-analog.addAll({
-    hcy: analogHNN,
-    hsi: analogHNN,
-    hsl: analogHNN,
-    hsv: analogHNN,
-    lab50: analogNUU,
-    lab65: analogNUU,
-    lch: defAnalog(analogN, analogN, analogH),
-    ycc: analogNUU,
-});
-const analogHsv = (out, src, deltaH, deltaS = 0, deltaV = 0, deltaA = 0, rnd = random.SYSTEM) => vectors.setC4(out || src, analogN(src[0], deltaH, rnd, math.fract), analogN(src[1], deltaS, rnd), analogN(src[2], deltaV, rnd), analogA(src[3], deltaA, rnd));
-const analogRgb = (out, src, deltaR, deltaG = deltaR, deltaB = deltaR, deltaA = 0, rnd = random.SYSTEM) => vectors.setC4(out || src, analogN(src[0], deltaR, rnd), analogN(src[1], deltaG, rnd), analogN(src[2], deltaB, rnd), analogA(src[3], deltaA, rnd));
-
-const closestHue = (h) => Math.round(math.fract(h) * 12) % 12;
-const closestPrimaryHue = (h) => closestHue(h) & 0xe;
-
-const isBlackHsv = (x, eps = EPS) => x[2] <= eps;
-const isBlackRgb = (x, eps = EPS) => x[0] <= eps && x[1] <= eps && x[2] <= eps;
-const isBlackLch = (x, eps = EPS) => x[0] <= eps;
-const isBlack = defmulti.defmulti((x) => x.mode);
-isBlack.addAll({
-    hcy: isBlackHsv,
-    hsi: isBlackHsv,
-    hsl: isBlackHsv,
-    hsv: isBlackHsv,
-    labD50: isBlackLch,
-    labD65: isBlackLch,
-    lch: isBlackLch,
-    rgb: isBlackRgb,
-    ycc: isBlackRgb,
-});
-isBlack.add(defmulti.DEFAULT, (x) => isBlackRgb(rgb(x)));
-
-const isGrayHsv = (x, eps = EPS) => x[1] <= eps;
-const isGrayRgb = (x, eps = EPS) => math.eqDelta(x[0], x[1], eps) && math.eqDelta(x[0], x[2], eps);
-const isGrayLab = (x, eps = EPS) => math.eqDelta(x[1], 0, eps) && math.eqDelta(x[2], 0, eps);
-const isGray = defmulti.defmulti((x) => x.mode);
-isGray.addAll({
-    hcy: isGrayHsv,
-    hsi: isGrayHsv,
-    hsl: isGrayHsv,
-    hsv: isGrayHsv,
-    labD50: isGrayLab,
-    labD65: isGrayLab,
-    lch: isGrayHsv,
-    rgb: isGrayRgb,
-    srgb: isGrayRgb,
-    ycc: isGrayLab,
-});
-isGray.add(defmulti.DEFAULT, (x) => isGrayRgb(rgb(x)));
-
-const isWhiteHsv = (x, eps = EPS) => x[1] <= eps && x[2] >= 1 - eps;
-const isWhiteRgb = (x, eps = EPS) => {
-    eps = 1 - eps;
-    return x[0] >= eps && x[1] >= eps && x[2] >= eps;
-};
-const isWhiteLch = (x, eps = EPS) => x[1] <= eps && x[0] >= 1 - eps;
-const isWhite = defmulti.defmulti((x) => x.mode);
-isWhite.addAll({
-    hcy: (x, eps = EPS) => x[1] <= eps && x[2] >= 1 - eps,
-    hsi: isWhiteHsv,
-    hsl: isWhiteHsv,
-    hsv: isWhiteHsv,
-    labD50: isWhiteLch,
-    labD65: isWhiteLch,
-    lch: isWhiteLch,
-    rgb: isWhiteRgb,
-    ycc: isWhiteLch,
-});
-isWhite.add(defmulti.DEFAULT, (x) => isWhiteRgb(rgb(x)));
-
-const COLOR_RANGES = {
-    light: {
-        c: [[0.3, 0.7]],
-        l: [[0.9, 1]],
-        b: [[0.35, 0.5]],
-        w: [[0.6, 1]],
-    },
-    dark: {
-        c: [[0.7, 1]],
-        l: [[0.15, 0.4]],
-        b: [[0, 0.4]],
-        w: [[0.4, 0.6]],
-    },
-    bright: {
-        c: [[0.75, 0.95]],
-        l: [[0.8, 1]],
-    },
-    weak: {
-        c: [[0.15, 0.3]],
-        l: [[0.7, 1]],
-        b: [[0.4, 0.6]],
-        w: [[0.8, 1]],
-    },
-    neutral: {
-        c: [[0.25, 0.35]],
-        l: [[0.3, 0.7]],
-        b: [[0.25, 0.4]],
-        w: [[0.9, 1]],
-    },
-    fresh: {
-        c: [[0.4, 0.8]],
-        l: [[0.8, 1]],
-        b: [[0.05, 0.3]],
-        w: [[0.8, 1]],
-    },
-    soft: {
-        c: [[0.2, 0.3]],
-        l: [[0.6, 0.9]],
-        b: [[0.05, 0.15]],
-        w: [[0.6, 0.9]],
-    },
-    hard: {
-        c: [[0.85, 0.95]],
-        l: [[0.4, 1]],
-    },
-    warm: {
-        c: [[0.6, 0.9]],
-        l: [[0.4, 0.9]],
-        b: [[0.2, 0.3]],
-        w: [[0.8, 1]],
-    },
-    cool: {
-        c: [[0.05, 0.2]],
-        l: [[0.9, 1]],
-        b: [[0, 0.95]],
-        w: [[0.95, 1]],
-    },
-    intense: {
-        c: [[0.9, 1]],
-        l: [
-            [0.2, 0.35],
-            [0.8, 1],
-        ],
-    },
-};
-const FULL = [[0, 1]];
-const DEFAULT_RANGE = {
-    h: FULL,
-    c: FULL,
-    l: FULL,
-    b: FULL,
-    w: FULL,
-    a: [[1, 1]],
-};
-const DEFAULT_OPTS = {
-    num: Infinity,
-    variance: 0.025,
-    eps: 1e-3,
-    rnd: random.SYSTEM,
-};
-const $rnd = (ranges, rnd) => rnd.minmax(...ranges[rnd.int() % ranges.length]);
-const colorFromRange = (range, opts) => {
-    range = Object.assign(Object.assign({}, DEFAULT_RANGE), (checks.isString(range) ? COLOR_RANGES[range] : range));
-    const { base, variance, rnd, eps } = Object.assign(Object.assign({}, DEFAULT_OPTS), opts);
-    let h;
-    let c;
-    let l;
-    let a;
-    if (base) {
-        const col = lch(base);
-        h = col[2];
-        a = ensureAlpha(col[3]);
-        if (isBlack(col, eps)) {
-            c = 0;
-            l = $rnd(range.b, rnd);
-        }
-        else if (isWhite(col, eps)) {
-            c = 0;
-            l = $rnd(range.w, rnd);
-        }
-        else if (isGray(col, eps)) {
-            c = 0;
-            l = $rnd(random.coin(rnd) ? range.b : range.w, rnd);
-        }
-        else {
-            h = math.fract(h + rnd.norm(variance));
-        }
-    }
-    else {
-        h = $rnd(range.h, rnd);
-        a = $rnd(range.a, rnd);
-    }
-    return lch([
-        l != undefined ? l : $rnd(range.l, rnd),
-        c !== undefined ? c : $rnd(range.c, rnd),
-        h,
-        a,
-    ]);
-};
-function* colorsFromRange(range, opts = {}) {
-    let num = opts.num != undefined ? opts.num : Infinity;
-    while (--num >= 0)
-        yield colorFromRange(range, opts);
-}
-const compileThemePart = (part, opts) => {
-    let spec;
-    if (checks.isArray(part)) {
-        spec = themePartFromTuple(part);
-    }
-    else if (checks.isString(part)) {
-        spec = themePartFromString(part);
-    }
-    else {
-        spec = Object.assign({}, part);
-        spec.weight == null && (spec.weight = 1);
-    }
-    checks.isString(spec.range) && (spec.range = COLOR_RANGES[spec.range]);
-    checks.isString(spec.base) && (spec.base = lch(parseCss(spec.base)));
-    if (spec.base !== undefined) {
-        opts = Object.assign(Object.assign({}, opts), { base: spec.base });
-    }
-    return { spec, opts };
-};
-const themePartFromTuple = (part) => {
-    let weight;
-    const [range, ...xs] = part;
-    if (checks.isNumber(arrays.peek(xs))) {
-        weight = arrays.peek(xs);
-        xs.pop();
-    }
-    else {
-        weight = 1;
-    }
-    return ((xs.length === 1
-        ? { range, base: xs[0], weight }
-        : xs.length === 0
-            ? COLOR_RANGES[range]
-                ? { range, weight }
-                : { base: range, weight }
-            : errors.illegalArgs(`invalid theme part: "${part}"`)));
-};
-const themePartFromString = (part) => ((COLOR_RANGES[part]
-    ? { range: part, weight: 1 }
-    : { base: part, weight: 1 }));
-function* colorsFromTheme(parts, opts = {}) {
-    let { num, variance, rnd } = Object.assign(Object.assign({}, DEFAULT_OPTS), opts);
-    const theme = parts.map((p) => compileThemePart(p, opts));
-    const choice = random.weightedRandom(theme, theme.map((x) => x.spec.weight), rnd);
-    while (--num >= 0) {
-        const { spec, opts } = choice();
-        if (spec.range) {
-            yield colorFromRange(spec.range, opts);
-        }
-        else if (spec.base) {
-            yield analog(lch(), lch(spec.base), variance, rnd);
-        }
-    }
-}
-
-const COSINE_GRADIENTS = {
-    "blue-cyan": [
-        [0, 0.5, 0.5, 1],
-        [0, 0.5, 0.5, 0],
-        [0, 0.5, 0.3333, 0],
-        [0, 0.5, 0.6666, 0],
-    ],
-    "blue-magenta-orange": [
-        [0.938, 0.328, 0.718, 1],
-        [0.659, 0.438, 0.328, 0],
-        [0.388, 0.388, 0.296, 0],
-        [2.538, 2.478, 0.168, 0],
-    ],
-    "blue-white-red": [
-        [0.66, 0.56, 0.68, 1],
-        [0.718, 0.438, 0.72, 0],
-        [0.52, 0.8, 0.52, 0],
-        [-0.43, -0.397, -0.083, 0],
-    ],
-    "cyan-magenta": [
-        [0.61, 0.498, 0.65, 1],
-        [0.388, 0.498, 0.35, 0],
-        [0.53, 0.498, 0.62, 0],
-        [3.438, 3.012, 4.025, 0],
-    ],
-    "green-blue-orange": [
-        [0.892, 0.725, 0, 1],
-        [0.878, 0.278, 0.725, 0],
-        [0.332, 0.518, 0.545, 0],
-        [2.44, 5.043, 0.732, 0],
-    ],
-    "green-cyan": [
-        [0, 0.5, 0.5, 1],
-        [0, 0.5, 0.5, 0],
-        [0, 0.3333, 0.5, 0],
-        [0, 0.6666, 0.5, 0],
-    ],
-    "green-magenta": [
-        [0.6666, 0.5, 0.5, 1],
-        [0.5, 0.6666, 0.5, 0],
-        [0.6666, 0.666, 0.5, 0],
-        [0.2, 0, 0.5, 0],
-    ],
-    "green-red": [
-        [0.5, 0.5, 0, 1],
-        [0.5, 0.5, 0, 0],
-        [0.5, 0.5, 0, 0],
-        [0.5, 0, 0, 0],
-    ],
-    heat1: [
-        [0.5, 0.4, 0.25, 1],
-        [0.5, 0.5, 0.666, 0],
-        [0.5, 0.666, 0.8, 0],
-        [0.5, 0.666, 0.8, 0],
-    ],
-    "magenta-green": [
-        [0.59, 0.811, 0.12, 1],
-        [0.41, 0.392, 0.59, 0],
-        [0.94, 0.548, 0.278, 0],
-        [-4.242, -6.611, -4.045, 0],
-    ],
-    "orange-blue": [
-        [0.5, 0.5, 0.5, 1],
-        [0.5, 0.5, 0.5, 0],
-        [0.8, 0.8, 0.5, 0],
-        [0, 0.2, 0.5, 0],
-    ],
-    "orange-magenta-blue": [
-        [0.821, 0.328, 0.242, 1],
-        [0.659, 0.481, 0.896, 0],
-        [0.612, 0.34, 0.296, 0],
-        [2.82, 3.026, -0.273, 0],
-    ],
-    "purple-orange-cyan": [
-        [0.5, 0.5, 0.5, 1],
-        [0.5, 0.5, 0.5, 0],
-        [0.5, 0.5, 1, 0],
-        [-0.25, 0.5, 1, 0],
-    ],
-    rainbow1: [
-        [0.5, 0.5, 0.5, 1],
-        [0.5, 0.5, 0.5, 0],
-        [1.0, 1.0, 1.0, 0],
-        [0, 0.3333, 0.6666, 0],
-    ],
-    rainbow2: [
-        [0.5, 0.5, 0.5, 1],
-        [0.666, 0.666, 0.666, 0],
-        [1.0, 1.0, 1.0, 0],
-        [0, 0.3333, 0.6666, 0],
-    ],
-    rainbow3: [
-        [0.5, 0.5, 0.5, 1],
-        [0.75, 0.75, 0.75, 0],
-        [1.0, 1.0, 1.0, 0],
-        [0, 0.3333, 0.6666, 0],
-    ],
-    rainbow4: [
-        [0.5, 0.5, 0.5, 1],
-        [1, 1, 1, 0],
-        [1.0, 1.0, 1.0, 0],
-        [0, 0.3333, 0.6666, 0],
-    ],
-    "red-blue": [
-        [0.5, 0, 0.5, 1],
-        [0.5, 0, 0.5, 0],
-        [0.5, 0, 0.5, 0],
-        [0, 0, 0.5, 0],
-    ],
-    "yellow-green-blue": [
-        [0.65, 0.5, 0.31, 1],
-        [-0.65, 0.5, 0.6, 0],
-        [0.333, 0.278, 0.278, 0],
-        [0.66, 0, 0.667, 0],
-    ],
-    "yellow-magenta-cyan": [
-        [1, 0.5, 0.5, 1],
-        [0.5, 0.5, 0.5, 0],
-        [0.75, 1.0, 0.6666, 0],
-        [0.8, 1.0, 0.3333, 0],
-    ],
-    "yellow-purple-magenta": [
-        [0.731, 1.098, 0.192, 1],
-        [0.358, 1.09, 0.657, 0],
-        [1.077, 0.36, 0.328, 0],
-        [0.965, 2.265, 0.837, 0],
-    ],
-    "yellow-red": [
-        [0.5, 0.5, 0, 1],
-        [0.5, 0.5, 0, 0],
-        [0.1, 0.5, 0, 0],
-        [0, 0, 0, 0],
-    ],
-};
-const cosineColor = (spec, t) => transducers.transduce(transducers.map(([a, b, c, d]) => math.clamp01(a + b * Math.cos(math.TAU * (c * t + d)))), transducers.push(),
-transducers.zip(...spec));
-const cosineGradient = (n, spec, tx) => transducers.transduce(transducers.comp(transducers.map(compose.partial(cosineColor, spec)), tx ? transducers.map(tx) : transducers.noop()), transducers.push(), transducers.normRange(n - 1));
-const cosineGradientBuffer = (n, spec, buffer = [], offset = 0, cstride = 1, estride = 4) => {
-    for (let t of transducers.normRange(n - 1)) {
-        vectors.setS4(buffer, cosineColor(spec, t), offset, 0, cstride);
-        offset += estride;
-    }
-    return buffer;
-};
-const cosineCoeffs = (from, to) => {
-    from = clamp([], from);
-    to = clamp([], to);
-    const amp = [...transducers.map(([a, b]) => 0.5 * (a - b), transducers.zip(from, to))];
-    return [
-        [...transducers.map(([s, a]) => s - a, transducers.zip(from, amp))],
-        amp,
-        [-0.5, -0.5, -0.5, -0.5],
-        [0, 0, 0, 0],
-    ];
-};
-const multiCosineGradient = (opts) => transducers.transduce(opts.tx ? transducers.map(opts.tx) : transducers.noop(), transducers.push(), transducers.tween({
-    num: opts.num,
-    stops: opts.stops,
-    easing: opts.easing,
-    min: 0,
-    max: 1,
-    init: cosineCoeffs,
-    mix: cosineColor,
-}));
-
-const { abs, cos, hypot, sin, sqrt } = Math;
-const distChannel = (id) => (a, b) => abs(a[id] - b[id]);
-const distHsv = (a, b) => {
-    const aa = math.cossin(a[0] * math.TAU, a[1]);
-    const bb = math.cossin(b[0] * math.TAU, b[1]);
-    return hypot(aa[0] - bb[0], aa[1] - bb[1], a[2] - b[2]);
-};
-const distHsvSat = distChannel(1);
-const distHsvLuma = distChannel(2);
-const distEucledian3 = vectors.dist3;
-const distEucledian4 = vectors.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 * math.DEG2RAD;
-const H25 = 25 * math.DEG2RAD;
-const H63 = 63 * math.DEG2RAD;
-const H275 = 275 * math.DEG2RAD;
-const distCIEDE2000 = (weights = vectors.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 - math.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(math.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));
-};
-const computeDeltaH = (a1, b1, a2, b2, c1, c2, eps = 1e-3) => {
-    const h1 = math.atan2Abs(b1, a1);
-    const h2 = math.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 <= math.PI ? dh : h2 <= h1 ? dh + math.TAU : dh - math.TAU;
-    const deltaH = 2 * sqrt(c1 * c2) * sin(dh / 2);
-    const H = 0.5 * (absH <= math.PI ? sumH : sumH < math.TAU ? sumH + math.TAU : sumH - math.TAU);
-    return { deltaH, H };
-};
-const H35 = 35 * math.DEG2RAD;
-const H164 = 164 * math.DEG2RAD;
-const H168 = 168 * math.DEG2RAD;
-const H345 = 345 * math.DEG2RAD;
-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 = math.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 defMix = (x, y, z, alpha) => (out, a, b, t) => vectors.setC4(out || a, x(a[0], b[0], t), y(a[1], b[1], t), z(a[2], b[2], t), alpha(a[3], b[3], t));
-const mixH = (a, b, t) => {
-    a = math.fract(a);
-    b = math.fract(b);
-    const delta = b - a;
-    return math.fract(a +
-        (Math.abs(delta) > 0.5
-            ? delta < 0
-                ? delta + 1
-                : -(1 - delta)
-            : delta) *
-            t);
-};
-const mixN = math.mix;
-const mixHNNN = defMix(mixH, mixN, mixN, mixN);
-const mixNNHN = defMix(mixN, mixN, mixH, mixN);
-const mixNNNN = vectors.mixN4;
-const mix = defmulti.defmulti((_, a) => a.mode);
-mix.add(defmulti.DEFAULT, vectors.mixN4);
-mix.addAll({
-    hcy: mixHNNN,
-    hsi: mixHNNN,
-    hsl: mixHNNN,
-    hsv: mixHNNN,
-    lch: mixNNHN,
-});
-
-const multiColorGradient = (opts) => [...gradient(opts)];
-const multiColorGradientBuffer = (opts, buffer = [], offset = 0, cstride = 1, estride = 4) => {
-    for (let col of gradient(opts)) {
-        vectors.setS4(buffer, col, offset, 0, cstride);
-        offset += estride;
-    }
-    return buffer;
-};
-const gradient = ({ num, stops, easing, mix: mix$1, }) => transducers.tween({
-    num: num - 1,
-    stops,
-    easing,
-    min: 0,
-    max: 1,
-    init: (a, b) => [a, b],
-    mix: mix$1
-        ? ([a, b], t) => mix$1(a.empty(), a, b, t)
-        : ([a, b], t) => mix(a.empty(), a, b, t),
-});
-
-const invertRgb = (out, src) => ((out = clamp(out || src, src)), vectors.sub3(out, vectors.ONE3, out));
-const invertInt = (src) => src ^ 0xffffff;
-
-const luminance = defmulti.defmulti((col) => col.mode);
-luminance.addAll({
-    argb32: luminanceArgb32,
-    abgr32: luminanceAbgr32,
-    hcy: (x) => x[2],
-    lab: (x) => x[0],
-    rgb: luminanceRgb,
-    srgb: luminanceSrgb,
-    xyz: (x) => x[1],
-});
-luminance.isa("lch", "lab");
-luminance.isa("oklab", "lab");
-luminance.isa("ycc", "lab");
-luminance.isa("xyy", "hcy");
-luminance.add(defmulti.DEFAULT, (x) => luminanceRgb(rgb(x)));
-
-const selectChannel = (id) => (col) => col[id];
-const proximity = (target, dist = distEucledian3) => (col) => dist(target, col);
-const sort = (colors, key, isReverse = false) => arrays.sortByCachedKey(colors, key, isReverse ? compare.compareNumDesc : compare.compareNumAsc);
-const sortMapped = (colors, key, isReverse = false) => {
-    if (!colors.length)
-        return colors;
-    const keys = colors.map(key);
-    const tmp = api.typedArray(api.typedArrayType(colors[0].buf), colors[0].length);
-    arrays.quickSort(keys, isReverse ? compare.compareNumDesc : compare.compareNumAsc, (_, x, y) => {
-        arrays.swap(keys, x, y);
-        tmp.set(colors[x]);
-        colors[x].set(colors[y]);
-        colors[y].set(tmp);
-    });
-    return colors;
-};
-
-const swatches = (cols, shapeFn, attribs = {}) => ["g", attribs, ...cols.map(shapeFn)];
-const swatchesH = (cols, w = 5, h = 50, gap = 0, attribs) => swatches(cols, (fill, i) => ["rect", { fill }, [i * (w + gap), 0], w, h], attribs);
-const dotsH = (cols, r = 25, gap = 0, attribs) => swatches(cols, (fill, i) => ["circle", { fill }, [i * (r * 2 + gap), 0], r], attribs);
-const swatchesV = (cols, w = 50, h = 5, gap = 0, attribs = {}) => swatches(cols, (fill, i) => ["rect", { fill }, [0, i * (h + gap)], w, h], attribs);
-const dotsV = (cols, r = 25, gap = 0, attribs) => swatches(cols, (fill, i) => ["circle", { fill }, [0, i * (r * 2 + gap)], r], attribs);
-
-const S0 = 0.072;
-const S1 = 0.213;
-const S2 = 0.285;
-const S3 = 0.715;
-const S4 = 0.787;
-const S5 = 0.928;
-const S6 = 0.14;
-const S7 = 0.143;
-const S8 = 0.283;
-const transform = mulV45;
-const concat = (mat, ...xs) => xs.reduce(mulM45, mat);
-const IDENTITY = [
-    1, 0, 0, 0, 0,
-    0, 1, 0, 0, 0,
-    0, 0, 1, 0, 0,
-    0, 0, 0, 1, 0
-];
-const subtract = (src = WHITE) => [
-    -1, 0, 0, 0, src[0],
-    0, -1, 0, 0, src[1],
-    0, 0, -1, 0, src[2],
-    0, 0, 0, 1, 0
-];
-const brightness = (x) => [
-    1, 0, 0, 0, x,
-    0, 1, 0, 0, x,
-    0, 0, 1, 0, x,
-    0, 0, 0, 1, 0
-];
-const contrast = (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
-];
-const exposure = (x) => [
-    x, 0, 0, 0, 0,
-    0, x, 0, 0, 0,
-    0, 0, x, 0, 0,
-    0, 0, 0, 1, 0
-];
-const saturation = (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
-];
-const hueRotate = (theta) => {
-    const s = Math.sin(theta);
-    const c = Math.cos(theta);
-    return [
-        S1 + c * S4 - s * S1, S3 - c * S3 - s * S3, S0 - c * S0 + s * S5, 0, 0,
-        S1 - c * S1 + s * S7, S3 + c * S2 + s * S6, S0 - c * S0 - s * S8, 0, 0,
-        S1 - c * S1 - s * S4, S3 - c * S3 + s * S3, S0 + c * S5 + s * S0, 0, 0,
-        0, 0, 0, 1, 0
-    ];
-};
-const temperature = (x) => [
-    1 + x, 0, 0, 0, 0,
-    0, 1, 0, 0, 0,
-    0, 0, 1 - x, 0, 0,
-    0, 0, 0, 1, 0
-];
-const sepia = (x = 1) => [
-    math.mix(1, 0.393, x), 0.769 * x, 0.189 * x, 0, 0,
-    0.349 * x, math.mix(1, 0.686, x), 0.168 * x, 0, 0,
-    0.272 * x, 0.534 * x, math.mix(1, 0.131, x), 0, 0,
-    0, 0, 0, 1, 0
-];
-const tint = (x) => [
-    1 + x, 0, 0, 0, 0,
-    0, 1, 0, 0, 0,
-    0, 0, 1 + x, 0, 0,
-    0, 0, 0, 1, 0
-];
-const grayscale = ([r, g, b] = RGB_LUMINANCE_REC709, offset = 0) => [
-    r, g, b, 0, offset,
-    r, g, b, 0, offset,
-    r, g, b, 0, offset,
-    0, 0, 0, 1, 0
-];
-const luminanceAlpha = ([r, g, b] = RGB_LUMINANCE_REC709) => [
-    0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0,
-    r, g, b, 0, 0
-];
-
-const G1 = -0.6088425710866344;
-const G2 = -0.001748900018414868;
-const G3 = 0.4097731842899564;
-const G4 = 1.2762722061615583;
-const G5 = 0.0003115080994769546;
-const G6 = 0.11013841706194392;
-const R1 = 1.3803015908551253;
-const R2 = 0.0004478684462124118;
-const R3 = -0.15785750232675008;
-const B1 = -0.9990954974165059;
-const B2 = 0.0032447435545127036;
-const B3 = 0.453646839257496;
-const kelvinRgb = (out, kelvin, alpha = 1) => {
-    kelvin *= 0.01;
-    let t;
-    return kelvin < 66
-        ? (vectors.setC4(out || srgb(), 1, math.clamp01(G1 + G2 * (t = kelvin - 2) + G3 * Math.log(t)), kelvin < 20
-            ? 0
-            : math.clamp01(B1 + B2 * (t = kelvin - 10) + B3 * Math.log(t)), alpha))
-        : (vectors.setC4(out || srgb(), math.clamp01(R1 + R2 * (t = kelvin - 55) + R3 * Math.log(t)), math.clamp01(G4 + G5 * (t = kelvin - 50) - G6 * Math.log(t)), 1, alpha));
-};
-
-const wavelengthXyz = (out, lambda, alpha = 1) => {
-    lambda *= 10;
-    return (vectors.setC4(out || xyzD65(), gaussian(lambda, 1.056, 5998, 379, 310) +
-        gaussian(lambda, 0.362, 4420, 160, 267) +
-        gaussian(lambda, -0.065, 5011, 204, 262), gaussian(lambda, 0.821, 5688, 469, 405) +
-        gaussian(lambda, 0.286, 5309, 163, 311), gaussian(lambda, 1.217, 4370, 118, 360) +
-        gaussian(lambda, 0.681, 4590, 260, 138), alpha));
-};
-const gaussian = (x, alpha, m, s1, s2) => {
-    const t = (x - m) / (x < m ? s1 : s2);
-    return alpha * Math.exp(-(t * t) / 2);
-};
-
-exports.ABGR = ABGR;
-exports.ARGB = ARGB;
-exports.BLACK = BLACK;
-exports.BLUE = BLUE;
-exports.BRADFORD_D50_D65 = BRADFORD_D50_D65;
-exports.BRADFORD_D65_D50 = BRADFORD_D65_D50;
-exports.COLOR_RANGES = COLOR_RANGES;
-exports.CONVERSIONS = CONVERSIONS;
-exports.COSINE_GRADIENTS = COSINE_GRADIENTS;
-exports.CSS_NAMES = CSS_NAMES;
-exports.CSS_SYSTEM_COLORS = CSS_SYSTEM_COLORS;
-exports.CYAN = CYAN;
-exports.D50 = D50;
-exports.D65 = D65;
-exports.EPS = EPS;
-exports.GREEN = GREEN;
-exports.IDENTITY = IDENTITY;
-exports.INV8BIT = INV8BIT;
-exports.Int32 = Int32;
-exports.MAGENTA = MAGENTA;
-exports.OKLAB_M1 = OKLAB_M1;
-exports.OKLAB_M2 = OKLAB_M2;
-exports.ParsedColor = ParsedColor;
-exports.RED = RED;
-exports.RGB_LUMINANCE_REC2020 = RGB_LUMINANCE_REC2020;
-exports.RGB_LUMINANCE_REC601 = RGB_LUMINANCE_REC601;
-exports.RGB_LUMINANCE_REC709 = RGB_LUMINANCE_REC709;
-exports.RGB_XYZ_D50 = RGB_XYZ_D50;
-exports.RGB_XYZ_D65 = RGB_XYZ_D65;
-exports.WHITE = WHITE;
-exports.XYZ_RGB_D50 = XYZ_RGB_D50;
-exports.XYZ_RGB_D65 = XYZ_RGB_D65;
-exports.YELLOW = YELLOW;
-exports.abgr32 = abgr32;
-exports.alpha = alpha;
-exports.analog = analog;
-exports.analogHsv = analogHsv;
-exports.analogRgb = analogRgb;
-exports.argb32 = argb32;
-exports.brightness = brightness;
-exports.clamp = clamp;
-exports.clampH = clampH;
-exports.closestHue = closestHue;
-exports.closestPrimaryHue = closestPrimaryHue;
-exports.color = color;
-exports.colorFromRange = colorFromRange;
-exports.colorsFromRange = colorsFromRange;
-exports.colorsFromTheme = colorsFromTheme;
-exports.concat = concat;
-exports.contrast = contrast;
-exports.convert = convert;
-exports.cosineCoeffs = cosineCoeffs;
-exports.cosineColor = cosineColor;
-exports.cosineGradient = cosineGradient;
-exports.cosineGradientBuffer = cosineGradientBuffer;
-exports.css = css;
-exports.defAnalog = defAnalog;
-exports.defColor = defColor;
-exports.defConversions = defConversions;
-exports.defMix = defMix;
-exports.distCIEDE2000 = distCIEDE2000;
-exports.distCMC = distCMC;
-exports.distChannel = distChannel;
-exports.distEucledian3 = distEucledian3;
-exports.distEucledian4 = distEucledian4;
-exports.distHsv = distHsv;
-exports.distHsvLuma = distHsvLuma;
-exports.distHsvSat = distHsvSat;
-exports.distRgbBlue = distRgbBlue;
-exports.distRgbGreen = distRgbGreen;
-exports.distRgbLuma = distRgbLuma;
-exports.distRgbRed = distRgbRed;
-exports.distSrgbLuma = distSrgbLuma;
-exports.dotsH = dotsH;
-exports.dotsV = dotsV;
-exports.exposure = exposure;
-exports.grayscale = grayscale;
-exports.hcy = hcy;
-exports.hcyRgb = hcyRgb;
-exports.hsi = hsi;
-exports.hsiRgb = hsiRgb;
-exports.hsl = hsl;
-exports.hslCss = hslCss;
-exports.hslHsv = hslHsv;
-exports.hslRgb = hslRgb;
-exports.hsv = hsv;
-exports.hsvCss = hsvCss;
-exports.hsvHsl = hsvHsl;
-exports.hsvRgb = hsvRgb;
-exports.hueRgb = hueRgb;
-exports.hueRotate = hueRotate;
-exports.intAbgr32Argb32 = intAbgr32Argb32;
-exports.intAbgr32Rgb = intAbgr32Rgb;
-exports.intAbgr32Srgb = intAbgr32Srgb;
-exports.intArgb32Abgr32 = intArgb32Abgr32;
-exports.intArgb32Css = intArgb32Css;
-exports.intArgb32Rgb = intArgb32Rgb;
-exports.intArgb32Srgb = intArgb32Srgb;
-exports.intBgr24Rgb = intBgr24Rgb;
-exports.intBgr24Srgb = intBgr24Srgb;
-exports.intRgb24Css = intRgb24Css;
-exports.intRgb24Rgb = intRgb24Rgb;
-exports.intRgb24Srgb = intRgb24Srgb;
-exports.invertInt = invertInt;
-exports.invertRgb = invertRgb;
-exports.isGray = isGray;
-exports.kelvinRgb = kelvinRgb;
-exports.labCss = labCss;
-exports.labD50 = labD50;
-exports.labD65 = labD65;
-exports.labLabD50_65 = labLabD50_65;
-exports.labLabD65_50 = labLabD65_50;
-exports.labLch = labLch;
-exports.labRgb = labRgb;
-exports.labRgbD65 = labRgbD65;
-exports.labXyz = labXyz;
-exports.labXyzD65 = labXyzD65;
-exports.lch = lch;
-exports.lchCss = lchCss;
-exports.lchLab = lchLab;
-exports.linearSrgb = linearSrgb;
-exports.luminance = luminance;
-exports.luminanceAbgr32 = luminanceAbgr32;
-exports.luminanceAlpha = luminanceAlpha;
-exports.luminanceArgb32 = luminanceArgb32;
-exports.luminanceIntAbgr32 = luminanceIntAbgr32;
-exports.luminanceIntArgb32 = luminanceIntArgb32;
-exports.luminanceRgb = luminanceRgb;
-exports.luminanceSrgb = luminanceSrgb;
-exports.mix = mix;
-exports.mixH = mixH;
-exports.mixHNNN = mixHNNN;
-exports.mixN = mixN;
-exports.mixNNHN = mixNNHN;
-exports.mixNNNN = mixNNNN;
-exports.multiColorGradient = multiColorGradient;
-exports.multiColorGradientBuffer = multiColorGradientBuffer;
-exports.multiCosineGradient = multiCosineGradient;
-exports.namedHueRgb = namedHueRgb;
-exports.oklab = oklab;
-exports.oklabRgb = oklabRgb;
-exports.oklabXyzD65 = oklabXyzD65;
-exports.parseCss = parseCss;
-exports.parseHex = parseHex;
-exports.proximity = proximity;
-exports.rgb = rgb;
-exports.rgbCss = rgbCss;
-exports.rgbHcv = rgbHcv;
-exports.rgbHcy = rgbHcy;
-exports.rgbHsi = rgbHsi;
-exports.rgbHsl = rgbHsl;
-exports.rgbHsv = rgbHsv;
-exports.rgbLab = rgbLab;
-exports.rgbLabD65 = rgbLabD65;
-exports.rgbOklab = rgbOklab;
-exports.rgbSrgb = rgbSrgb;
-exports.rgbSrgbApprox = rgbSrgbApprox;
-exports.rgbXyz = rgbXyz;
-exports.rgbXyzD65 = rgbXyzD65;
-exports.rgbYcc = rgbYcc;
-exports.saturation = saturation;
-exports.selectChannel = selectChannel;
-exports.sepia = sepia;
-exports.setAlpha = setAlpha;
-exports.setPrecision = setPrecision;
-exports.setSystemColors = setSystemColors;
-exports.sort = sort;
-exports.sortMapped = sortMapped;
-exports.srgb = srgb;
-exports.srgbCss = srgbCss;
-exports.srgbIntAbgr32 = srgbIntAbgr32;
-exports.srgbIntArgb32 = srgbIntArgb32;
-exports.srgbLinear = srgbLinear;
-exports.srgbRgb = srgbRgb;
-exports.srgbRgbApprox = srgbRgbApprox;
-exports.subtract = subtract;
-exports.swatches = swatches;
-exports.swatchesH = swatchesH;
-exports.swatchesV = swatchesV;
-exports.temperature = temperature;
-exports.tint = tint;
-exports.transform = transform;
-exports.wavelengthXyz = wavelengthXyz;
-exports.xyy = xyy;
-exports.xyyXyz = xyyXyz;
-exports.xyzD50 = xyzD50;
-exports.xyzD65 = xyzD65;
-exports.xyzLab = xyzLab;
-exports.xyzLabD65 = xyzLabD65;
-exports.xyzOklab = xyzOklab;
-exports.xyzRgb = xyzRgb;
-exports.xyzRgbD65 = xyzRgbD65;
-exports.xyzXyy = xyzXyy;
-exports.xyzXyzD50_65 = xyzXyzD50_65;
-exports.xyzXyzD65_50 = xyzXyzD65_50;
-exports.ycc = ycc;
-exports.yccRgb = yccRgb;