simview 3.2__py3-none-any.whl

simview/static/lib/chroma-js-3.1.2/src/io/lch/lab2lch.js

@@ -0,0 +1,12 @@
+import { unpack, RAD2DEG } from '../../utils/index.js';
+const { sqrt, atan2, round } = Math;
+
+const lab2lch = (...args) => {
+    const [l, a, b] = unpack(args, 'lab');
+    const c = sqrt(a * a + b * b);
+    let h = (atan2(b, a) * RAD2DEG + 360) % 360;
+    if (round(c * 10000) === 0) h = Number.NaN;
+    return [l, c, h];
+};
+
+export default lab2lch;

simview/static/lib/chroma-js-3.1.2/src/io/lch/lch2lab.js

@@ -0,0 +1,18 @@
+import { unpack, DEG2RAD } from '../../utils/index.js';
+const { sin, cos } = Math;
+
+const lch2lab = (...args) => {
+    /*
+    Convert from a qualitative parameter h and a quantitative parameter l to a 24-bit pixel.
+    These formulas were invented by David Dalrymple to obtain maximum contrast without going
+    out of gamut if the parameters are in the range 0-1.
+
+    A saturation multiplier was added by Gregor Aisch
+    */
+    let [l, c, h] = unpack(args, 'lch');
+    if (isNaN(h)) h = 0;
+    h = h * DEG2RAD;
+    return [l, cos(h) * c, sin(h) * c];
+};
+
+export default lch2lab;

simview/static/lib/chroma-js-3.1.2/src/io/lch/lch2rgb.js

@@ -0,0 +1,13 @@
+import { unpack } from '../../utils/index.js';
+import lch2lab from './lch2lab.js';
+import lab2rgb from '../lab/lab2rgb.js';
+
+const lch2rgb = (...args) => {
+    args = unpack(args, 'lch');
+    const [l, c, h] = args;
+    const [L, a, b_] = lch2lab(l, c, h);
+    const [r, g, b] = lab2rgb(L, a, b_);
+    return [r, g, b, args.length > 3 ? args[3] : 1];
+};
+
+export default lch2rgb;

simview/static/lib/chroma-js-3.1.2/src/io/lch/rgb2lch.js

@@ -0,0 +1,12 @@
+import { unpack } from '../../utils/index.js';
+import rgb2lab from '../lab/rgb2lab.js';
+import lab2lch from './lab2lch.js';
+
+const rgb2lch = (...args) => {
+    const [r, g, b, ...rest] = unpack(args, 'rgb');
+    const [l, a, b_] = rgb2lab(r, g, b);
+    const [L, c, h] = lab2lch(l, a, b_);
+    return [L, c, h, ...(rest.length > 0 && rest[0] < 1 ? [rest[0]] : [])];
+};
+
+export default rgb2lch;

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

@@ -0,0 +1,30 @@
+import Color from '../../Color.js';
+import input from '../input.js';
+import { type } from '../../utils/index.js';
+
+import w3cx11 from '../../colors/w3cx11.js';
+import hex2rgb from '../hex/hex2rgb.js';
+import rgb2hex from '../hex/rgb2hex.js';
+
+Color.prototype.name = function () {
+    const hex = rgb2hex(this._rgb, 'rgb');
+    for (let n of Object.keys(w3cx11)) {
+        if (w3cx11[n] === hex) return n.toLowerCase();
+    }
+    return hex;
+};
+
+input.format.named = (name) => {
+    name = name.toLowerCase();
+    if (w3cx11[name]) return hex2rgb(w3cx11[name]);
+    throw new Error('unknown color name: ' + name);
+};
+
+input.autodetect.push({
+    p: 5,
+    test: (h, ...rest) => {
+        if (!rest.length && type(h) === 'string' && w3cx11[h.toLowerCase()]) {
+            return 'named';
+        }
+    }
+});

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

@@ -0,0 +1,32 @@
+import chroma from '../../chroma.js';
+import Color from '../../Color.js';
+import input from '../input.js';
+import { type } from '../../utils/index.js';
+import num2rgb from './num2rgb.js';
+import rgb2num from './rgb2num.js';
+
+Color.prototype.num = function () {
+    return rgb2num(this._rgb);
+};
+
+const num = (...args) => new Color(...args, 'num');
+
+Object.assign(chroma, { num });
+
+input.format.num = num2rgb;
+
+input.autodetect.push({
+    p: 5,
+    test: (...args) => {
+        if (
+            args.length === 1 &&
+            type(args[0]) === 'number' &&
+            args[0] >= 0 &&
+            args[0] <= 0xffffff
+        ) {
+            return 'num';
+        }
+    }
+});
+
+export { num };

simview/static/lib/chroma-js-3.1.2/src/io/num/num2rgb.js

@@ -0,0 +1,13 @@
+import { type } from '../../utils/index.js';
+
+const num2rgb = (num) => {
+    if (type(num) == 'number' && num >= 0 && num <= 0xffffff) {
+        const r = num >> 16;
+        const g = (num >> 8) & 0xff;
+        const b = num & 0xff;
+        return [r, g, b, 1];
+    }
+    throw new Error('unknown num color: ' + num);
+};
+
+export default num2rgb;

simview/static/lib/chroma-js-3.1.2/src/io/num/rgb2num.js

@@ -0,0 +1,8 @@
+import { unpack } from '../../utils/index.js';
+
+const rgb2num = (...args) => {
+    const [r, g, b] = unpack(args, 'rgb');
+    return (r << 16) + (g << 8) + b;
+};
+
+export default rgb2num;

simview/static/lib/chroma-js-3.1.2/src/io/oklab/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 oklab2rgb from './oklab2rgb.js';
+import rgb2oklab from './rgb2oklab.js';
+
+Color.prototype.oklab = function () {
+    return rgb2oklab(this._rgb);
+};
+
+const oklab = (...args) => new Color(...args, 'oklab');
+Object.assign(chroma, { oklab });
+
+input.format.oklab = oklab2rgb;
+
+input.autodetect.push({
+    p: 2,
+    test: (...args) => {
+        args = unpack(args, 'oklab');
+        if (type(args) === 'array' && args.length === 3) {
+            return 'oklab';
+        }
+    }
+});
+
+export { oklab };

simview/static/lib/chroma-js-3.1.2/src/io/oklab/oklab2rgb.js

@@ -0,0 +1,34 @@
+import { unpack } from '../../utils/index.js';
+import multiplyMatrices from '../../utils/multiply-matrices.js';
+import { xyz2rgb } from '../lab/lab2rgb.js';
+
+const oklab2rgb = (...args) => {
+    args = unpack(args, 'lab');
+    const [L, a, b, ...rest] = args;
+    const [X, Y, Z] = OKLab_to_XYZ([L, a, b]);
+    const [r, g, b_] = xyz2rgb(X, Y, Z);
+    return [r, g, b_, ...(rest.length > 0 && rest[0] < 1 ? [rest[0]] : [])];
+};
+
+// from https://www.w3.org/TR/css-color-4/#color-conversion-code
+function OKLab_to_XYZ(OKLab) {
+    // Given OKLab, convert to XYZ relative to D65
+    var LMStoXYZ = [
+        [1.2268798758459243, -0.5578149944602171, 0.2813910456659647],
+        [-0.0405757452148008, 1.112286803280317, -0.0717110580655164],
+        [-0.0763729366746601, -0.4214933324022432, 1.5869240198367816]
+    ];
+    var OKLabtoLMS = [
+        [1.0, 0.3963377773761749, 0.2158037573099136],
+        [1.0, -0.1055613458156586, -0.0638541728258133],
+        [1.0, -0.0894841775298119, -1.2914855480194092]
+    ];
+
+    var LMSnl = multiplyMatrices(OKLabtoLMS, OKLab);
+    return multiplyMatrices(
+        LMStoXYZ,
+        LMSnl.map((c) => c ** 3)
+    );
+}
+
+export default oklab2rgb;

simview/static/lib/chroma-js-3.1.2/src/io/oklab/rgb2oklab.js

@@ -0,0 +1,37 @@
+import { unpack } from '../../utils/index.js';
+import multiplyMatrices from '../../utils/multiply-matrices.js';
+import { rgb2xyz } from '../lab/rgb2lab.js';
+
+const rgb2oklab = (...args) => {
+    const [r, g, b, ...rest] = unpack(args, 'rgb');
+    const xyz = rgb2xyz(r, g, b);
+    const oklab = XYZ_to_OKLab(xyz);
+    return [...oklab, ...(rest.length > 0 && rest[0] < 1 ? [rest[0]] : [])];
+};
+
+// from https://www.w3.org/TR/css-color-4/#color-conversion-code
+function XYZ_to_OKLab(XYZ) {
+    // Given XYZ relative to D65, convert to OKLab
+    const XYZtoLMS = [
+        [0.819022437996703, 0.3619062600528904, -0.1288737815209879],
+        [0.0329836539323885, 0.9292868615863434, 0.0361446663506424],
+        [0.0481771893596242, 0.2642395317527308, 0.6335478284694309]
+    ];
+    const LMStoOKLab = [
+        [0.210454268309314, 0.7936177747023054, -0.0040720430116193],
+        [1.9779985324311684, -2.4285922420485799, 0.450593709617411],
+        [0.0259040424655478, 0.7827717124575296, -0.8086757549230774]
+    ];
+
+    const LMS = multiplyMatrices(XYZtoLMS, XYZ);
+    // JavaScript Math.cbrt returns a sign-matched cube root
+    // beware if porting to other languages
+    // especially if tempted to use a general power function
+    return multiplyMatrices(
+        LMStoOKLab,
+        LMS.map((c) => Math.cbrt(c))
+    );
+    // L in range [0,1]. For use in CSS, multiply by 100 and add a percent
+}
+
+export default rgb2oklab;

simview/static/lib/chroma-js-3.1.2/src/io/oklch/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 oklch2rgb from './oklch2rgb.js';
+import rgb2oklch from './rgb2oklch.js';
+
+Color.prototype.oklch = function () {
+    return rgb2oklch(this._rgb);
+};
+
+const oklch = (...args) => new Color(...args, 'oklch');
+Object.assign(chroma, { oklch });
+
+input.format.oklch = oklch2rgb;
+
+input.autodetect.push({
+    p: 2,
+    test: (...args) => {
+        args = unpack(args, 'oklch');
+        if (type(args) === 'array' && args.length === 3) {
+            return 'oklch';
+        }
+    }
+});
+
+export { oklch };

simview/static/lib/chroma-js-3.1.2/src/io/oklch/oklch2rgb.js

@@ -0,0 +1,13 @@
+import { unpack } from '../../utils/index.js';
+import lch2lab from '../lch/lch2lab.js';
+import oklab2rgb from '../oklab/oklab2rgb.js';
+
+const oklch2rgb = (...args) => {
+    args = unpack(args, 'lch');
+    const [l, c, h, ...rest] = args;
+    const [L, a, b_] = lch2lab(l, c, h);
+    const [r, g, b] = oklab2rgb(L, a, b_);
+    return [r, g, b, ...(rest.length > 0 && rest[0] < 1 ? [rest[0]] : [])];
+};
+
+export default oklch2rgb;

simview/static/lib/chroma-js-3.1.2/src/io/oklch/rgb2oklch.js

@@ -0,0 +1,12 @@
+import { unpack } from '../../utils/index.js';
+import rgb2oklab from '../oklab/rgb2oklab.js';
+import lab2lch from '../lch/lab2lch.js';
+
+const rgb2oklch = (...args) => {
+    const [r, g, b, ...rest] = unpack(args, 'rgb');
+    const [l, a, b_] = rgb2oklab(r, g, b);
+    const [L, c, h] = lab2lch(l, a, b_);
+    return [L, c, h, ...(rest.length > 0 && rest[0] < 1 ? [rest[0]] : [])];
+};
+
+export default rgb2oklch;

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

@@ -0,0 +1,44 @@
+import chroma from '../../chroma.js';
+import Color from '../../Color.js';
+import input from '../input.js';
+import { unpack, type } from '../../utils/index.js';
+const { round } = Math;
+
+Color.prototype.rgb = function (rnd = true) {
+    if (rnd === false) return this._rgb.slice(0, 3);
+    return this._rgb.slice(0, 3).map(round);
+};
+
+Color.prototype.rgba = function (rnd = true) {
+    return this._rgb.slice(0, 4).map((v, i) => {
+        return i < 3 ? (rnd === false ? v : round(v)) : v;
+    });
+};
+
+const rgb = (...args) => new Color(...args, 'rgb');
+Object.assign(chroma, { rgb });
+
+input.format.rgb = (...args) => {
+    const rgba = unpack(args, 'rgba');
+    if (rgba[3] === undefined) rgba[3] = 1;
+    return rgba;
+};
+
+input.autodetect.push({
+    p: 3,
+    test: (...args) => {
+        args = unpack(args, 'rgba');
+        if (
+            type(args) === 'array' &&
+            (args.length === 3 ||
+                (args.length === 4 &&
+                    type(args[3]) == 'number' &&
+                    args[3] >= 0 &&
+                    args[3] <= 1))
+        ) {
+            return 'rgb';
+        }
+    }
+});
+
+export { rgb };

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

@@ -0,0 +1,22 @@
+import chroma from '../../chroma.js';
+import Color from '../../Color.js';
+import input from '../input.js';
+import temperature2rgb from './temperature2rgb.js';
+import rgb2temperature from './rgb2temperature.js';
+
+Color.prototype.temp =
+    Color.prototype.kelvin =
+    Color.prototype.temperature =
+        function () {
+            return rgb2temperature(this._rgb);
+        };
+
+const temp = (...args) => new Color(...args, 'temp');
+Object.assign(chroma, { temp, kelvin: temp, temperature: temp });
+
+input.format.temp =
+    input.format.kelvin =
+    input.format.temperature =
+        temperature2rgb;
+
+export { temp, temp as kelvin, temp as temperature };

simview/static/lib/chroma-js-3.1.2/src/io/temp/rgb2temperature.js

@@ -0,0 +1,30 @@
+/*
+ * Based on implementation by Neil Bartlett
+ * https://github.com/neilbartlett/color-temperature
+ **/
+
+import temperature2rgb from './temperature2rgb.js';
+import { unpack } from '../../utils/index.js';
+const { round } = Math;
+
+const rgb2temperature = (...args) => {
+    const rgb = unpack(args, 'rgb');
+    const r = rgb[0],
+        b = rgb[2];
+    let minTemp = 1000;
+    let maxTemp = 40000;
+    const eps = 0.4;
+    let temp;
+    while (maxTemp - minTemp > eps) {
+        temp = (maxTemp + minTemp) * 0.5;
+        const rgb = temperature2rgb(temp);
+        if (rgb[2] / rgb[0] >= b / r) {
+            maxTemp = temp;
+        } else {
+            minTemp = temp;
+        }
+    }
+    return round(temp);
+};
+
+export default rgb2temperature;

simview/static/lib/chroma-js-3.1.2/src/io/temp/temperature2rgb.js

@@ -0,0 +1,39 @@
+/*
+ * Based on implementation by Neil Bartlett
+ * https://github.com/neilbartlett/color-temperature
+ */
+
+const { log } = Math;
+
+const temperature2rgb = (kelvin) => {
+    const temp = kelvin / 100;
+    let r, g, b;
+    if (temp < 66) {
+        r = 255;
+        g =
+            temp < 6
+                ? 0
+                : -155.25485562709179 -
+                  0.44596950469579133 * (g = temp - 2) +
+                  104.49216199393888 * log(g);
+        b =
+            temp < 20
+                ? 0
+                : -254.76935184120902 +
+                  0.8274096064007395 * (b = temp - 10) +
+                  115.67994401066147 * log(b);
+    } else {
+        r =
+            351.97690566805693 +
+            0.114206453784165 * (r = temp - 55) -
+            40.25366309332127 * log(r);
+        g =
+            325.4494125711974 +
+            0.07943456536662342 * (g = temp - 50) -
+            28.0852963507957 * log(g);
+        b = 255;
+    }
+    return [r, g, b, 1];
+};
+
+export default temperature2rgb;

simview/static/lib/chroma-js-3.1.2/src/ops/alpha.js

@@ -0,0 +1,13 @@
+import Color from '../Color.js';
+import { type } from '../utils/index.js';
+
+Color.prototype.alpha = function (a, mutate = false) {
+    if (a !== undefined && type(a) === 'number') {
+        if (mutate) {
+            this._rgb[3] = a;
+            return this;
+        }
+        return new Color([this._rgb[0], this._rgb[1], this._rgb[2], a], 'rgb');
+    }
+    return this._rgb[3];
+};

simview/static/lib/chroma-js-3.1.2/src/ops/clipped.js

@@ -0,0 +1,5 @@
+import Color from '../Color.js';
+
+Color.prototype.clipped = function () {
+    return this._rgb._clipped || false;
+};

simview/static/lib/chroma-js-3.1.2/src/ops/darken.js

@@ -0,0 +1,17 @@
+import '../io/lab/index.js';
+import Color from '../Color.js';
+import LAB_CONSTANTS from '../io/lab/lab-constants.js';
+
+Color.prototype.darken = function (amount = 1) {
+    const me = this;
+    const lab = me.lab();
+    lab[0] -= LAB_CONSTANTS.Kn * amount;
+    return new Color(lab, 'lab').alpha(me.alpha(), true);
+};
+
+Color.prototype.brighten = function (amount = 1) {
+    return this.darken(-amount);
+};
+
+Color.prototype.darker = Color.prototype.darken;
+Color.prototype.brighter = Color.prototype.brighten;

simview/static/lib/chroma-js-3.1.2/src/ops/get.js

@@ -0,0 +1,13 @@
+import Color from '../Color.js';
+
+Color.prototype.get = function (mc) {
+    const [mode, channel] = mc.split('.');
+    const src = this[mode]();
+    if (channel) {
+        const i = mode.indexOf(channel) - (mode.substr(0, 2) === 'ok' ? 2 : 0);
+        if (i > -1) return src[i];
+        throw new Error(`unknown channel ${channel} in mode ${mode}`);
+    } else {
+        return src;
+    }
+};

simview/static/lib/chroma-js-3.1.2/src/ops/luminance.js

@@ -0,0 +1,54 @@
+import Color from '../Color.js';
+import { type } from '../utils/index.js';
+const { pow } = Math;
+
+const EPS = 1e-7;
+const MAX_ITER = 20;
+
+Color.prototype.luminance = function (lum, mode = 'rgb') {
+    if (lum !== undefined && type(lum) === 'number') {
+        if (lum === 0) {
+            // return pure black
+            return new Color([0, 0, 0, this._rgb[3]], 'rgb');
+        }
+        if (lum === 1) {
+            // return pure white
+            return new Color([255, 255, 255, this._rgb[3]], 'rgb');
+        }
+        // compute new color using...
+        let cur_lum = this.luminance();
+        let max_iter = MAX_ITER;
+
+        const test = (low, high) => {
+            const mid = low.interpolate(high, 0.5, mode);
+            const lm = mid.luminance();
+            if (Math.abs(lum - lm) < EPS || !max_iter--) {
+                // close enough
+                return mid;
+            }
+            return lm > lum ? test(low, mid) : test(mid, high);
+        };
+
+        const rgb = (
+            cur_lum > lum
+                ? test(new Color([0, 0, 0]), this)
+                : test(this, new Color([255, 255, 255]))
+        ).rgb();
+        return new Color([...rgb, this._rgb[3]]);
+    }
+    return rgb2luminance(...this._rgb.slice(0, 3));
+};
+
+const rgb2luminance = (r, g, b) => {
+    // relative luminance
+    // see http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef
+    r = luminance_x(r);
+    g = luminance_x(g);
+    b = luminance_x(b);
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+};
+
+const luminance_x = (x) => {
+    x /= 255;
+    return x <= 0.03928 ? x / 12.92 : pow((x + 0.055) / 1.055, 2.4);
+};

simview/static/lib/chroma-js-3.1.2/src/ops/mix.js

@@ -0,0 +1,10 @@
+import Color from '../Color.js';
+import mix from '../generator/mix.js';
+
+Color.prototype.mix = Color.prototype.interpolate = function (
+    col2,
+    f = 0.5,
+    ...rest
+) {
+    return mix(this, col2, f, ...rest);
+};

simview/static/lib/chroma-js-3.1.2/src/ops/premultiply.js

@@ -0,0 +1,12 @@
+import Color from '../Color.js';
+
+Color.prototype.premultiply = function (mutate = false) {
+    const rgb = this._rgb;
+    const a = rgb[3];
+    if (mutate) {
+        this._rgb = [rgb[0] * a, rgb[1] * a, rgb[2] * a, a];
+        return this;
+    } else {
+        return new Color([rgb[0] * a, rgb[1] * a, rgb[2] * a, a], 'rgb');
+    }
+};

simview/static/lib/chroma-js-3.1.2/src/ops/saturate.js

@@ -0,0 +1,15 @@
+import '../io/lch/index.js';
+import Color from '../Color.js';
+import LAB_CONSTANTS from '../io/lab/lab-constants.js';
+
+Color.prototype.saturate = function (amount = 1) {
+    const me = this;
+    const lch = me.lch();
+    lch[1] += LAB_CONSTANTS.Kn * amount;
+    if (lch[1] < 0) lch[1] = 0;
+    return new Color(lch, 'lch').alpha(me.alpha(), true);
+};
+
+Color.prototype.desaturate = function (amount = 1) {
+    return this.saturate(-amount);
+};

simview/static/lib/chroma-js-3.1.2/src/ops/set.js

@@ -0,0 +1,43 @@
+import Color from '../Color.js';
+import { type } from '../utils/index.js';
+
+Color.prototype.set = function (mc, value, mutate = false) {
+    const [mode, channel] = mc.split('.');
+    const src = this[mode]();
+    if (channel) {
+        const i = mode.indexOf(channel) - (mode.substr(0, 2) === 'ok' ? 2 : 0);
+        if (i > -1) {
+            if (type(value) == 'string') {
+                switch (value.charAt(0)) {
+                    case '+':
+                        src[i] += +value;
+                        break;
+                    case '-':
+                        src[i] += +value;
+                        break;
+                    case '*':
+                        src[i] *= +value.substr(1);
+                        break;
+                    case '/':
+                        src[i] /= +value.substr(1);
+                        break;
+                    default:
+                        src[i] = +value;
+                }
+            } else if (type(value) === 'number') {
+                src[i] = value;
+            } else {
+                throw new Error(`unsupported value for Color.set`);
+            }
+            const out = new Color(src, mode);
+            if (mutate) {
+                this._rgb = out._rgb;
+                return this;
+            }
+            return out;
+        }
+        throw new Error(`unknown channel ${channel} in mode ${mode}`);
+    } else {
+        return src;
+    }
+};

simview/static/lib/chroma-js-3.1.2/src/ops/shade.js

@@ -0,0 +1,11 @@
+import '../io/lab/index.js';
+import Color from '../Color.js';
+import mix from '../generator/mix.js';
+
+Color.prototype.tint = function (f = 0.5, ...rest) {
+    return mix(this, 'white', f, ...rest);
+};
+
+Color.prototype.shade = function (f = 0.5, ...rest) {
+    return mix(this, 'black', f, ...rest);
+};