simview 3.2__py3-none-any.whl

simview/static/lib/chroma-js-3.1.2/src/io/css/css2rgb.js

@@ -0,0 +1,238 @@
+import hsl2rgb from '../hsl/hsl2rgb.js';
+import lab2rgb from '../lab/lab2rgb.js';
+import lch2rgb from '../lch/lch2rgb.js';
+import oklab2rgb from '../oklab/oklab2rgb.js';
+import oklch2rgb from '../oklch/oklch2rgb.js';
+import input from '../input.js';
+import limit from '../../utils/limit.js';
+import { getLabWhitePoint, setLabWhitePoint } from '../lab/lab-constants.js';
+
+const INT_OR_PCT = /((?:-?\d+)|(?:-?\d+(?:\.\d+)?)%|none)/.source;
+const FLOAT_OR_PCT = /((?:-?(?:\d+(?:\.\d*)?|\.\d+)%?)|none)/.source;
+const PCT = /((?:-?(?:\d+(?:\.\d*)?|\.\d+)%)|none)/.source;
+const RE_S = /\s*/.source;
+const SEP = /\s+/.source;
+const COMMA = /\s*,\s*/.source;
+const ANLGE = /((?:-?(?:\d+(?:\.\d*)?|\.\d+)(?:deg)?)|none)/.source;
+const ALPHA = /\s*(?:\/\s*((?:[01]|[01]?\.\d+)|\d+(?:\.\d+)?%))?/.source;
+
+// e.g. rgb(250 20 0), rgb(100% 50% 20%), rgb(100% 50% 20% / 0.5)
+const RE_RGB = new RegExp(
+    '^rgba?\\(' +
+        RE_S +
+        [INT_OR_PCT, INT_OR_PCT, INT_OR_PCT].join(SEP) +
+        ALPHA +
+        '\\)$'
+);
+const RE_RGB_LEGACY = new RegExp(
+    '^rgb\\(' +
+        RE_S +
+        [INT_OR_PCT, INT_OR_PCT, INT_OR_PCT].join(COMMA) +
+        RE_S +
+        '\\)$'
+);
+const RE_RGBA_LEGACY = new RegExp(
+    '^rgba\\(' +
+        RE_S +
+        [INT_OR_PCT, INT_OR_PCT, INT_OR_PCT, FLOAT_OR_PCT].join(COMMA) +
+        RE_S +
+        '\\)$'
+);
+
+const RE_HSL = new RegExp(
+    '^hsla?\\(' + RE_S + [ANLGE, PCT, PCT].join(SEP) + ALPHA + '\\)$'
+);
+const RE_HSL_LEGACY = new RegExp(
+    '^hsl?\\(' + RE_S + [ANLGE, PCT, PCT].join(COMMA) + RE_S + '\\)$'
+);
+const RE_HSLA_LEGACY =
+    /^hsla\(\s*(-?\d+(?:\.\d+)?),\s*(-?\d+(?:\.\d+)?)%\s*,\s*(-?\d+(?:\.\d+)?)%\s*,\s*([01]|[01]?\.\d+)\)$/;
+
+const RE_LAB = new RegExp(
+    '^lab\\(' +
+        RE_S +
+        [FLOAT_OR_PCT, FLOAT_OR_PCT, FLOAT_OR_PCT].join(SEP) +
+        ALPHA +
+        '\\)$'
+);
+const RE_LCH = new RegExp(
+    '^lch\\(' +
+        RE_S +
+        [FLOAT_OR_PCT, FLOAT_OR_PCT, ANLGE].join(SEP) +
+        ALPHA +
+        '\\)$'
+);
+const RE_OKLAB = new RegExp(
+    '^oklab\\(' +
+        RE_S +
+        [FLOAT_OR_PCT, FLOAT_OR_PCT, FLOAT_OR_PCT].join(SEP) +
+        ALPHA +
+        '\\)$'
+);
+const RE_OKLCH = new RegExp(
+    '^oklch\\(' +
+        RE_S +
+        [FLOAT_OR_PCT, FLOAT_OR_PCT, ANLGE].join(SEP) +
+        ALPHA +
+        '\\)$'
+);
+
+const { round } = Math;
+
+const roundRGB = (rgb) => {
+    return rgb.map((v, i) => (i <= 2 ? limit(round(v), 0, 255) : v));
+};
+
+const percentToAbsolute = (pct, min = 0, max = 100, signed = false) => {
+    if (typeof pct === 'string' && pct.endsWith('%')) {
+        pct = parseFloat(pct.substring(0, pct.length - 1)) / 100;
+        if (signed) {
+            // signed percentages are in the range -100% to 100%
+            pct = min + (pct + 1) * 0.5 * (max - min);
+        } else {
+            pct = min + pct * (max - min);
+        }
+    }
+    return +pct;
+};
+
+const noneToValue = (v, noneValue) => {
+    return v === 'none' ? noneValue : v;
+};
+
+const css2rgb = (css) => {
+    css = css.toLowerCase().trim();
+
+    if (css === 'transparent') {
+        return [0, 0, 0, 0];
+    }
+
+    let m;
+
+    if (input.format.named) {
+        try {
+            return input.format.named(css);
+            // eslint-disable-next-line
+        } catch (e) {}
+    }
+
+    // rgb(250 20 0) or rgb(250,20,0)
+    if ((m = css.match(RE_RGB)) || (m = css.match(RE_RGB_LEGACY))) {
+        let rgb = m.slice(1, 4);
+        for (let i = 0; i < 3; i++) {
+            rgb[i] = +percentToAbsolute(noneToValue(rgb[i], 0), 0, 255);
+        }
+        rgb = roundRGB(rgb);
+        const alpha = m[4] !== undefined ? +percentToAbsolute(m[4], 0, 1) : 1;
+        rgb[3] = alpha; // default alpha
+        return rgb;
+    }
+
+    // rgba(250,20,0,0.4)
+    if ((m = css.match(RE_RGBA_LEGACY))) {
+        const rgb = m.slice(1, 5);
+        for (let i = 0; i < 4; i++) {
+            rgb[i] = +percentToAbsolute(rgb[i], 0, 255);
+        }
+        return rgb;
+    }
+
+    // hsl(0,100%,50%)
+    if ((m = css.match(RE_HSL)) || (m = css.match(RE_HSL_LEGACY))) {
+        const hsl = m.slice(1, 4);
+        hsl[0] = +noneToValue(hsl[0].replace('deg', ''), 0);
+        hsl[1] = +percentToAbsolute(noneToValue(hsl[1], 0), 0, 100) * 0.01;
+        hsl[2] = +percentToAbsolute(noneToValue(hsl[2], 0), 0, 100) * 0.01;
+        const rgb = roundRGB(hsl2rgb(hsl));
+        const alpha = m[4] !== undefined ? +percentToAbsolute(m[4], 0, 1) : 1;
+        rgb[3] = alpha;
+        return rgb;
+    }
+
+    // hsla(0,100%,50%,0.5)
+    if ((m = css.match(RE_HSLA_LEGACY))) {
+        const hsl = m.slice(1, 4);
+        hsl[1] *= 0.01;
+        hsl[2] *= 0.01;
+        const rgb = hsl2rgb(hsl);
+        for (let i = 0; i < 3; i++) {
+            rgb[i] = round(rgb[i]);
+        }
+        rgb[3] = +m[4]; // default alpha = 1
+        return rgb;
+    }
+
+    if ((m = css.match(RE_LAB))) {
+        const lab = m.slice(1, 4);
+        lab[0] = percentToAbsolute(noneToValue(lab[0], 0), 0, 100);
+        lab[1] = percentToAbsolute(noneToValue(lab[1], 0), -125, 125, true);
+        lab[2] = percentToAbsolute(noneToValue(lab[2], 0), -125, 125, true);
+        // convert to D50 Lab whitepoint
+        const wp = getLabWhitePoint();
+        setLabWhitePoint('d50');
+        const rgb = roundRGB(lab2rgb(lab));
+        // convert back to original Lab whitepoint
+        setLabWhitePoint(wp);
+        const alpha = m[4] !== undefined ? +percentToAbsolute(m[4], 0, 1) : 1;
+        rgb[3] = alpha;
+        return rgb;
+    }
+
+    if ((m = css.match(RE_LCH))) {
+        const lch = m.slice(1, 4);
+        lch[0] = percentToAbsolute(lch[0], 0, 100);
+        lch[1] = percentToAbsolute(noneToValue(lch[1], 0), 0, 150, false);
+        lch[2] = +noneToValue(lch[2].replace('deg', ''), 0);
+        // convert to D50 Lab whitepoint
+        const wp = getLabWhitePoint();
+        setLabWhitePoint('d50');
+        const rgb = roundRGB(lch2rgb(lch));
+        // convert back to original Lab whitepoint
+        setLabWhitePoint(wp);
+        const alpha = m[4] !== undefined ? +percentToAbsolute(m[4], 0, 1) : 1;
+        rgb[3] = alpha;
+        return rgb;
+    }
+
+    if ((m = css.match(RE_OKLAB))) {
+        const oklab = m.slice(1, 4);
+        oklab[0] = percentToAbsolute(noneToValue(oklab[0], 0), 0, 1);
+        oklab[1] = percentToAbsolute(noneToValue(oklab[1], 0), -0.4, 0.4, true);
+        oklab[2] = percentToAbsolute(noneToValue(oklab[2], 0), -0.4, 0.4, true);
+        const rgb = roundRGB(oklab2rgb(oklab));
+        const alpha = m[4] !== undefined ? +percentToAbsolute(m[4], 0, 1) : 1;
+        rgb[3] = alpha;
+        return rgb;
+    }
+
+    if ((m = css.match(RE_OKLCH))) {
+        const oklch = m.slice(1, 4);
+        oklch[0] = percentToAbsolute(noneToValue(oklch[0], 0), 0, 1);
+        oklch[1] = percentToAbsolute(noneToValue(oklch[1], 0), 0, 0.4, false);
+        oklch[2] = +noneToValue(oklch[2].replace('deg', ''), 0);
+        const rgb = roundRGB(oklch2rgb(oklch));
+        const alpha = m[4] !== undefined ? +percentToAbsolute(m[4], 0, 1) : 1;
+        rgb[3] = alpha;
+        return rgb;
+    }
+};
+
+css2rgb.test = (s) => {
+    return (
+        // modern
+        RE_RGB.test(s) ||
+        RE_HSL.test(s) ||
+        RE_LAB.test(s) ||
+        RE_LCH.test(s) ||
+        RE_OKLAB.test(s) ||
+        RE_OKLCH.test(s) ||
+        // legacy
+        RE_RGB_LEGACY.test(s) ||
+        RE_RGBA_LEGACY.test(s) ||
+        RE_HSL_LEGACY.test(s) ||
+        RE_HSLA_LEGACY.test(s) ||
+        s === 'transparent'
+    );
+};
+
+export default css2rgb;

simview/static/lib/chroma-js-3.1.2/src/io/css/hsl2css.js

@@ -0,0 +1,26 @@
+import { unpack, last, rnd2 } from '../../utils/index.js';
+
+/*
+ * supported arguments:
+ * - hsl2css(h,s,l)
+ * - hsl2css(h,s,l,a)
+ * - hsl2css([h,s,l], mode)
+ * - hsl2css([h,s,l,a], mode)
+ * - hsl2css({h,s,l,a}, mode)
+ */
+const hsl2css = (...args) => {
+    const hsla = unpack(args, 'hsla');
+    let mode = last(args) || 'lsa';
+    hsla[0] = rnd2(hsla[0] || 0) + 'deg';
+    hsla[1] = rnd2(hsla[1] * 100) + '%';
+    hsla[2] = rnd2(hsla[2] * 100) + '%';
+    if (mode === 'hsla' || (hsla.length > 3 && hsla[3] < 1)) {
+        hsla[3] = '/ ' + (hsla.length > 3 ? hsla[3] : 1);
+        mode = 'hsla';
+    } else {
+        hsla.length = 3;
+    }
+    return `${mode.substr(0, 3)}(${hsla.join(' ')})`;
+};
+
+export default hsl2css;

simview/static/lib/chroma-js-3.1.2/src/io/css/index.js

@@ -0,0 +1,27 @@
+import chroma from '../../chroma.js';
+import Color from '../../Color.js';
+import input from '../input.js';
+import { type } from '../../utils/index.js';
+
+import rgb2css from './rgb2css.js';
+import css2rgb from './css2rgb.js';
+
+Color.prototype.css = function (mode) {
+    return rgb2css(this._rgb, mode);
+};
+
+const css = (...args) => new Color(...args, 'css');
+chroma.css = css;
+
+input.format.css = css2rgb;
+
+input.autodetect.push({
+    p: 5,
+    test: (h, ...rest) => {
+        if (!rest.length && type(h) === 'string' && css2rgb.test(h)) {
+            return 'css';
+        }
+    }
+});
+
+export { css };

simview/static/lib/chroma-js-3.1.2/src/io/css/lab2css.js

@@ -0,0 +1,24 @@
+import { unpack, last, rnd2 } from '../../utils/index.js';
+
+/*
+ * supported arguments:
+ * - lab2css(l,a,b)
+ * - lab2css(l,a,b,alpha)
+ * - lab2css([l,a,b], mode)
+ * - lab2css([l,a,b,alpha], mode)
+ */
+const lab2css = (...args) => {
+    const laba = unpack(args, 'lab');
+    let mode = last(args) || 'lab';
+    laba[0] = rnd2(laba[0]) + '%';
+    laba[1] = rnd2(laba[1]);
+    laba[2] = rnd2(laba[2]);
+    if (mode === 'laba' || (laba.length > 3 && laba[3] < 1)) {
+        laba[3] = '/ ' + (laba.length > 3 ? laba[3] : 1);
+    } else {
+        laba.length = 3;
+    }
+    return `lab(${laba.join(' ')})`;
+};
+
+export default lab2css;

simview/static/lib/chroma-js-3.1.2/src/io/css/lch2css.js

@@ -0,0 +1,24 @@
+import { unpack, last, rnd2 } from '../../utils/index.js';
+
+/*
+ * supported arguments:
+ * - lab2css(l,a,b)
+ * - lab2css(l,a,b,alpha)
+ * - lab2css([l,a,b], mode)
+ * - lab2css([l,a,b,alpha], mode)
+ */
+const lch2css = (...args) => {
+    const lcha = unpack(args, 'lch');
+    let mode = last(args) || 'lab';
+    lcha[0] = rnd2(lcha[0]) + '%';
+    lcha[1] = rnd2(lcha[1]);
+    lcha[2] = isNaN(lcha[2]) ? 'none' : rnd2(lcha[2]) + 'deg'; // add deg unit to hue
+    if (mode === 'lcha' || (lcha.length > 3 && lcha[3] < 1)) {
+        lcha[3] = '/ ' + (lcha.length > 3 ? lcha[3] : 1);
+    } else {
+        lcha.length = 3;
+    }
+    return `lch(${lcha.join(' ')})`;
+};
+
+export default lch2css;

simview/static/lib/chroma-js-3.1.2/src/io/css/oklab2css.js

@@ -0,0 +1,16 @@
+import { unpack, rnd2, rnd3 } from '../../utils/index.js';
+
+const oklab2css = (...args) => {
+    const laba = unpack(args, 'lab');
+    laba[0] = rnd2(laba[0] * 100) + '%';
+    laba[1] = rnd3(laba[1]);
+    laba[2] = rnd3(laba[2]);
+    if (laba.length > 3 && laba[3] < 1) {
+        laba[3] = '/ ' + (laba.length > 3 ? laba[3] : 1);
+    } else {
+        laba.length = 3;
+    }
+    return `oklab(${laba.join(' ')})`;
+};
+
+export default oklab2css;

simview/static/lib/chroma-js-3.1.2/src/io/css/oklch2css.js

@@ -0,0 +1,16 @@
+import { unpack, rnd2, rnd3 } from '../../utils/index.js';
+
+const oklch2css = (...args) => {
+    const lcha = unpack(args, 'lch');
+    lcha[0] = rnd2(lcha[0] * 100) + '%';
+    lcha[1] = rnd3(lcha[1]);
+    lcha[2] = isNaN(lcha[2]) ? 'none' : rnd2(lcha[2]) + 'deg'; // add deg unit to hue
+    if (lcha.length > 3 && lcha[3] < 1) {
+        lcha[3] = '/ ' + (lcha.length > 3 ? lcha[3] : 1);
+    } else {
+        lcha.length = 3;
+    }
+    return `oklch(${lcha.join(' ')})`;
+};
+
+export default oklch2css;

simview/static/lib/chroma-js-3.1.2/src/io/css/rgb2css.js

@@ -0,0 +1,61 @@
+import { unpack, last } from '../../utils/index.js';
+import hsl2css from './hsl2css.js';
+import rgb2hsl from '../hsl/rgb2hsl.js';
+import lab2css from './lab2css.js';
+import rgb2lab from '../lab/rgb2lab.js';
+import lch2css from './lch2css.js';
+import rgb2lch from '../lch/rgb2lch.js';
+import rgb2oklab from '../oklab/rgb2oklab.js';
+import oklab2css from './oklab2css.js';
+import rgb2oklch from '../oklch/rgb2oklch.js';
+import oklch2css from './oklch2css.js';
+import { getLabWhitePoint, setLabWhitePoint } from '../lab/lab-constants.js';
+const { round } = Math;
+
+/*
+ * supported arguments:
+ * - rgb2css(r,g,b)
+ * - rgb2css(r,g,b,a)
+ * - rgb2css([r,g,b], mode)
+ * - rgb2css([r,g,b,a], mode)
+ * - rgb2css({r,g,b,a}, mode)
+ */
+const rgb2css = (...args) => {
+    const rgba = unpack(args, 'rgba');
+    let mode = last(args) || 'rgb';
+    if (mode.substr(0, 3) === 'hsl') {
+        return hsl2css(rgb2hsl(rgba), mode);
+    }
+    if (mode.substr(0, 3) === 'lab') {
+        // change to D50 lab whitepoint since this is what W3C is using for CSS Lab colors
+        const prevWhitePoint = getLabWhitePoint();
+        setLabWhitePoint('d50');
+        const cssColor = lab2css(rgb2lab(rgba), mode);
+        setLabWhitePoint(prevWhitePoint);
+        return cssColor;
+    }
+    if (mode.substr(0, 3) === 'lch') {
+        // change to D50 lab whitepoint since this is what W3C is using for CSS Lab colors
+        const prevWhitePoint = getLabWhitePoint();
+        setLabWhitePoint('d50');
+        const cssColor = lch2css(rgb2lch(rgba), mode);
+        setLabWhitePoint(prevWhitePoint);
+        return cssColor;
+    }
+    if (mode.substr(0, 5) === 'oklab') {
+        return oklab2css(rgb2oklab(rgba));
+    }
+    if (mode.substr(0, 5) === 'oklch') {
+        return oklch2css(rgb2oklch(rgba));
+    }
+    rgba[0] = round(rgba[0]);
+    rgba[1] = round(rgba[1]);
+    rgba[2] = round(rgba[2]);
+    if (mode === 'rgba' || (rgba.length > 3 && rgba[3] < 1)) {
+        rgba[3] = '/ ' + (rgba.length > 3 ? rgba[3] : 1);
+        mode = 'rgba';
+    }
+    return `${mode.substr(0, 3)}(${rgba.slice(0, mode === 'rgb' ? 3 : 4).join(' ')})`;
+};
+
+export default rgb2css;

simview/static/lib/chroma-js-3.1.2/src/io/gl/index.js

@@ -0,0 +1,22 @@
+import Color from '../../Color.js';
+import chroma from '../../chroma.js';
+import input from '../input.js';
+import { unpack } from '../../utils/index.js';
+
+input.format.gl = (...args) => {
+    const rgb = unpack(args, 'rgba');
+    rgb[0] *= 255;
+    rgb[1] *= 255;
+    rgb[2] *= 255;
+    return rgb;
+};
+
+const gl = (...args) => new Color(...args, 'gl');
+chroma.gl = gl;
+
+Color.prototype.gl = function () {
+    const rgb = this._rgb;
+    return [rgb[0] / 255, rgb[1] / 255, rgb[2] / 255, rgb[3]];
+};
+
+export { gl };

simview/static/lib/chroma-js-3.1.2/src/io/hcg/hcg2rgb.js

@@ -0,0 +1,55 @@
+import { unpack } from '../../utils/index.js';
+const { floor } = Math;
+
+/*
+ * this is basically just HSV with some minor tweaks
+ *
+ * hue.. [0..360]
+ * chroma .. [0..1]
+ * grayness .. [0..1]
+ */
+
+const hcg2rgb = (...args) => {
+    args = unpack(args, 'hcg');
+    let [h, c, _g] = args;
+    let r, g, b;
+    _g = _g * 255;
+    const _c = c * 255;
+    if (c === 0) {
+        r = g = b = _g;
+    } else {
+        if (h === 360) h = 0;
+        if (h > 360) h -= 360;
+        if (h < 0) h += 360;
+        h /= 60;
+        const i = floor(h);
+        const f = h - i;
+        const p = _g * (1 - c);
+        const q = p + _c * (1 - f);
+        const t = p + _c * f;
+        const v = p + _c;
+        switch (i) {
+            case 0:
+                [r, g, b] = [v, t, p];
+                break;
+            case 1:
+                [r, g, b] = [q, v, p];
+                break;
+            case 2:
+                [r, g, b] = [p, v, t];
+                break;
+            case 3:
+                [r, g, b] = [p, q, v];
+                break;
+            case 4:
+                [r, g, b] = [t, p, v];
+                break;
+            case 5:
+                [r, g, b] = [v, p, q];
+                break;
+        }
+    }
+    return [r, g, b, args.length > 3 ? args[3] : 1];
+};
+
+export default hcg2rgb;

simview/static/lib/chroma-js-3.1.2/src/io/hcg/index.js

@@ -0,0 +1,27 @@
+import { unpack, type } from '../../utils/index.js';
+import chroma from '../../chroma.js';
+import Color from '../../Color.js';
+import input from '../input.js';
+import hcg2rgb from './hcg2rgb.js';
+import rgb2hcg from './rgb2hcg.js';
+
+Color.prototype.hcg = function () {
+    return rgb2hcg(this._rgb);
+};
+
+const hcg = (...args) => new Color(...args, 'hcg');
+chroma.hcg = hcg;
+
+input.format.hcg = hcg2rgb;
+
+input.autodetect.push({
+    p: 1,
+    test: (...args) => {
+        args = unpack(args, 'hcg');
+        if (type(args) === 'array' && args.length === 3) {
+            return 'hcg';
+        }
+    }
+});
+
+export { hcg };

simview/static/lib/chroma-js-3.1.2/src/io/hcg/rgb2hcg.js

@@ -0,0 +1,23 @@
+import { unpack, max, min } from '../../utils/index.js';
+
+const rgb2hcg = (...args) => {
+    const [r, g, b] = unpack(args, 'rgb');
+    const minRgb = min(r, g, b);
+    const maxRgb = max(r, g, b);
+    const delta = maxRgb - minRgb;
+    const c = (delta * 100) / 255;
+    const _g = (minRgb / (255 - delta)) * 100;
+    let h;
+    if (delta === 0) {
+        h = Number.NaN;
+    } else {
+        if (r === maxRgb) h = (g - b) / delta;
+        if (g === maxRgb) h = 2 + (b - r) / delta;
+        if (b === maxRgb) h = 4 + (r - g) / delta;
+        h *= 60;
+        if (h < 0) h += 360;
+    }
+    return [h, c, _g];
+};
+
+export default rgb2hcg;

simview/static/lib/chroma-js-3.1.2/src/io/hex/hex2rgb.js

@@ -0,0 +1,56 @@
+const RE_HEX = /^#?([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/;
+const RE_HEXA = /^#?([A-Fa-f0-9]{8}|[A-Fa-f0-9]{4})$/;
+
+const hex2rgb = (hex) => {
+    if (hex.match(RE_HEX)) {
+        // remove optional leading #
+        if (hex.length === 4 || hex.length === 7) {
+            hex = hex.substr(1);
+        }
+        // expand short-notation to full six-digit
+        if (hex.length === 3) {
+            hex = hex.split('');
+            hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+        }
+        const u = parseInt(hex, 16);
+        const r = u >> 16;
+        const g = (u >> 8) & 0xff;
+        const b = u & 0xff;
+        return [r, g, b, 1];
+    }
+
+    // match rgba hex format, eg #FF000077
+    if (hex.match(RE_HEXA)) {
+        if (hex.length === 5 || hex.length === 9) {
+            // remove optional leading #
+            hex = hex.substr(1);
+        }
+        // expand short-notation to full eight-digit
+        if (hex.length === 4) {
+            hex = hex.split('');
+            hex =
+                hex[0] +
+                hex[0] +
+                hex[1] +
+                hex[1] +
+                hex[2] +
+                hex[2] +
+                hex[3] +
+                hex[3];
+        }
+        const u = parseInt(hex, 16);
+        const r = (u >> 24) & 0xff;
+        const g = (u >> 16) & 0xff;
+        const b = (u >> 8) & 0xff;
+        const a = Math.round(((u & 0xff) / 0xff) * 100) / 100;
+        return [r, g, b, a];
+    }
+
+    // we used to check for css colors here
+    // if _input.css? and rgb = _input.css hex
+    //     return rgb
+
+    throw new Error(`unknown hex color: ${hex}`);
+};
+
+export default hex2rgb;

simview/static/lib/chroma-js-3.1.2/src/io/hex/index.js

@@ -0,0 +1,29 @@
+import Color from '../../Color.js';
+import chroma from '../../chroma.js';
+import { type } from '../../utils/index.js';
+import input from '../input.js';
+import hex2rgb from './hex2rgb.js';
+import rgb2hex from './rgb2hex.js';
+
+Color.prototype.hex = function (mode) {
+    return rgb2hex(this._rgb, mode);
+};
+
+const hex = (...args) => new Color(...args, 'hex');
+chroma.hex = hex;
+
+input.format.hex = hex2rgb;
+input.autodetect.push({
+    p: 4,
+    test: (h, ...rest) => {
+        if (
+            !rest.length &&
+            type(h) === 'string' &&
+            [3, 4, 5, 6, 7, 8, 9].indexOf(h.length) >= 0
+        ) {
+            return 'hex';
+        }
+    }
+});
+
+export { hex };

simview/static/lib/chroma-js-3.1.2/src/io/hex/rgb2hex.js

@@ -0,0 +1,29 @@
+import { unpack, last } from '../../utils/index.js';
+const { round } = Math;
+
+const rgb2hex = (...args) => {
+    let [r, g, b, a] = unpack(args, 'rgba');
+    let mode = last(args) || 'auto';
+    if (a === undefined) a = 1;
+    if (mode === 'auto') {
+        mode = a < 1 ? 'rgba' : 'rgb';
+    }
+    r = round(r);
+    g = round(g);
+    b = round(b);
+    const u = (r << 16) | (g << 8) | b;
+    let str = '000000' + u.toString(16); //#.toUpperCase();
+    str = str.substr(str.length - 6);
+    let hxa = '0' + round(a * 255).toString(16);
+    hxa = hxa.substr(hxa.length - 2);
+    switch (mode.toLowerCase()) {
+        case 'rgba':
+            return `#${str}${hxa}`;
+        case 'argb':
+            return `#${hxa}${str}`;
+        default:
+            return `#${str}`;
+    }
+};
+
+export default rgb2hex;