simview 3.2__py3-none-any.whl

simview/static/lib/chroma-js-3.1.2/src/Color.js

@@ -0,0 +1,49 @@
+import { last, clip_rgb, type } from './utils/index.js';
+import _input from './io/input.js';
+
+class Color {
+    constructor(...args) {
+        const me = this;
+        if (
+            type(args[0]) === 'object' &&
+            args[0].constructor &&
+            args[0].constructor === this.constructor
+        ) {
+            // the argument is already a Color instance
+            return args[0];
+        }
+        // last argument could be the mode
+        let mode = last(args);
+        let autodetect = false;
+        if (!mode) {
+            autodetect = true;
+
+            if (!_input.sorted) {
+                _input.autodetect = _input.autodetect.sort((a, b) => b.p - a.p);
+                _input.sorted = true;
+            }
+
+            // auto-detect format
+            for (let chk of _input.autodetect) {
+                mode = chk.test(...args);
+                if (mode) break;
+            }
+        }
+        if (_input.format[mode]) {
+            const rgb = _input.format[mode].apply(
+                null,
+                autodetect ? args : args.slice(0, -1)
+            );
+            me._rgb = clip_rgb(rgb);
+        } else {
+            throw new Error('unknown format: ' + args);
+        }
+        // add alpha channel
+        if (me._rgb.length === 3) me._rgb.push(1);
+    }
+    toString() {
+        if (type(this.hex) == 'function') return this.hex();
+        return `[${this._rgb.join(',')}]`;
+    }
+}
+export default Color;

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

@@ -0,0 +1,10 @@
+import Color from './Color.js';
+import { version } from './version.js';
+
+const chroma = (...args) => {
+    return new Color(...args);
+};
+
+chroma.version = version;
+
+export default chroma;

simview/static/lib/chroma-js-3.1.2/src/colors/colorbrewer.js

@@ -0,0 +1,81 @@
+/**
+    ColorBrewer colors for chroma.js
+
+    Copyright (c) 2002 Cynthia Brewer, Mark Harrower, and The
+    Pennsylvania State University.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software distributed
+    under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+    CONDITIONS OF ANY KIND, either express or implied. See the License for the
+    specific language governing permissions and limitations under the License.
+*/
+
+const colorbrewer = {
+    // sequential
+    OrRd: ['#fff7ec', '#fee8c8', '#fdd49e', '#fdbb84', '#fc8d59', '#ef6548', '#d7301f', '#b30000', '#7f0000'],
+    PuBu: ['#fff7fb', '#ece7f2', '#d0d1e6', '#a6bddb', '#74a9cf', '#3690c0', '#0570b0', '#045a8d', '#023858'],
+    BuPu: ['#f7fcfd', '#e0ecf4', '#bfd3e6', '#9ebcda', '#8c96c6', '#8c6bb1', '#88419d', '#810f7c', '#4d004b'],
+    Oranges: ['#fff5eb', '#fee6ce', '#fdd0a2', '#fdae6b', '#fd8d3c', '#f16913', '#d94801', '#a63603', '#7f2704'],
+    BuGn: ['#f7fcfd', '#e5f5f9', '#ccece6', '#99d8c9', '#66c2a4', '#41ae76', '#238b45', '#006d2c', '#00441b'],
+    YlOrBr: ['#ffffe5', '#fff7bc', '#fee391', '#fec44f', '#fe9929', '#ec7014', '#cc4c02', '#993404', '#662506'],
+    YlGn: ['#ffffe5', '#f7fcb9', '#d9f0a3', '#addd8e', '#78c679', '#41ab5d', '#238443', '#006837', '#004529'],
+    Reds: ['#fff5f0', '#fee0d2', '#fcbba1', '#fc9272', '#fb6a4a', '#ef3b2c', '#cb181d', '#a50f15', '#67000d'],
+    RdPu: ['#fff7f3', '#fde0dd', '#fcc5c0', '#fa9fb5', '#f768a1', '#dd3497', '#ae017e', '#7a0177', '#49006a'],
+    Greens: ['#f7fcf5', '#e5f5e0', '#c7e9c0', '#a1d99b', '#74c476', '#41ab5d', '#238b45', '#006d2c', '#00441b'],
+    YlGnBu: ['#ffffd9', '#edf8b1', '#c7e9b4', '#7fcdbb', '#41b6c4', '#1d91c0', '#225ea8', '#253494', '#081d58'],
+    Purples: ['#fcfbfd', '#efedf5', '#dadaeb', '#bcbddc', '#9e9ac8', '#807dba', '#6a51a3', '#54278f', '#3f007d'],
+    GnBu: ['#f7fcf0', '#e0f3db', '#ccebc5', '#a8ddb5', '#7bccc4', '#4eb3d3', '#2b8cbe', '#0868ac', '#084081'],
+    Greys: ['#ffffff', '#f0f0f0', '#d9d9d9', '#bdbdbd', '#969696', '#737373', '#525252', '#252525', '#000000'],
+    YlOrRd: ['#ffffcc', '#ffeda0', '#fed976', '#feb24c', '#fd8d3c', '#fc4e2a', '#e31a1c', '#bd0026', '#800026'],
+    PuRd: ['#f7f4f9', '#e7e1ef', '#d4b9da', '#c994c7', '#df65b0', '#e7298a', '#ce1256', '#980043', '#67001f'],
+    Blues: ['#f7fbff', '#deebf7', '#c6dbef', '#9ecae1', '#6baed6', '#4292c6', '#2171b5', '#08519c', '#08306b'],
+    PuBuGn: ['#fff7fb', '#ece2f0', '#d0d1e6', '#a6bddb', '#67a9cf', '#3690c0', '#02818a', '#016c59', '#014636'],
+    Viridis: ['#440154', '#482777', '#3f4a8a', '#31678e', '#26838f', '#1f9d8a', '#6cce5a', '#b6de2b', '#fee825'],
+
+    // diverging
+    Spectral: ['#9e0142', '#d53e4f', '#f46d43', '#fdae61', '#fee08b', '#ffffbf', '#e6f598', '#abdda4', '#66c2a5', '#3288bd', '#5e4fa2'],
+    RdYlGn: ['#a50026', '#d73027', '#f46d43', '#fdae61', '#fee08b', '#ffffbf', '#d9ef8b', '#a6d96a', '#66bd63', '#1a9850', '#006837'],
+    RdBu: ['#67001f', '#b2182b', '#d6604d', '#f4a582', '#fddbc7', '#f7f7f7', '#d1e5f0', '#92c5de', '#4393c3', '#2166ac', '#053061'],
+    PiYG: ['#8e0152', '#c51b7d', '#de77ae', '#f1b6da', '#fde0ef', '#f7f7f7', '#e6f5d0', '#b8e186', '#7fbc41', '#4d9221', '#276419'],
+    PRGn: ['#40004b', '#762a83', '#9970ab', '#c2a5cf', '#e7d4e8', '#f7f7f7', '#d9f0d3', '#a6dba0', '#5aae61', '#1b7837', '#00441b'],
+    RdYlBu: ['#a50026', '#d73027', '#f46d43', '#fdae61', '#fee090', '#ffffbf', '#e0f3f8', '#abd9e9', '#74add1', '#4575b4', '#313695'],
+    BrBG: ['#543005', '#8c510a', '#bf812d', '#dfc27d', '#f6e8c3', '#f5f5f5', '#c7eae5', '#80cdc1', '#35978f', '#01665e', '#003c30'],
+    RdGy: ['#67001f', '#b2182b', '#d6604d', '#f4a582', '#fddbc7', '#ffffff', '#e0e0e0', '#bababa', '#878787', '#4d4d4d', '#1a1a1a'],
+    PuOr: ['#7f3b08', '#b35806', '#e08214', '#fdb863', '#fee0b6', '#f7f7f7', '#d8daeb', '#b2abd2', '#8073ac', '#542788', '#2d004b'],
+
+    // qualitative
+    Set2: ['#66c2a5', '#fc8d62', '#8da0cb', '#e78ac3', '#a6d854', '#ffd92f', '#e5c494', '#b3b3b3'],
+    Accent: ['#7fc97f', '#beaed4', '#fdc086', '#ffff99', '#386cb0', '#f0027f', '#bf5b17', '#666666'],
+    Set1: ['#e41a1c', '#377eb8', '#4daf4a', '#984ea3', '#ff7f00', '#ffff33', '#a65628', '#f781bf', '#999999'],
+    Set3: ['#8dd3c7', '#ffffb3', '#bebada', '#fb8072', '#80b1d3', '#fdb462', '#b3de69', '#fccde5', '#d9d9d9', '#bc80bd', '#ccebc5', '#ffed6f'],
+    Dark2: ['#1b9e77', '#d95f02', '#7570b3', '#e7298a', '#66a61e', '#e6ab02', '#a6761d', '#666666'],
+    Paired: ['#a6cee3', '#1f78b4', '#b2df8a', '#33a02c', '#fb9a99', '#e31a1c', '#fdbf6f', '#ff7f00', '#cab2d6', '#6a3d9a', '#ffff99', '#b15928'],
+    Pastel2: ['#b3e2cd', '#fdcdac', '#cbd5e8', '#f4cae4', '#e6f5c9', '#fff2ae', '#f1e2cc', '#cccccc'],
+    Pastel1: ['#fbb4ae', '#b3cde3', '#ccebc5', '#decbe4', '#fed9a6', '#ffffcc', '#e5d8bd', '#fddaec', '#f2f2f2']
+};
+
+const colorbrewerTypes = Object.keys(colorbrewer);
+const typeMap = new Map(colorbrewerTypes.map((key) => [key.toLowerCase(), key]));
+
+// use Proxy to allow case-insensitive access to palettes
+const colorbrewerProxy =
+    typeof Proxy === 'function'
+        ? new Proxy(colorbrewer, {
+              get(target, prop) {
+                  const lower = prop.toLowerCase();
+                  if (typeMap.has(lower)) {
+                      return target[typeMap.get(lower)];
+                  }
+              },
+              getOwnPropertyNames() {
+                  return Object.getOwnPropertyNames(colorbrewerTypes);
+              }
+          })
+        : colorbrewer;
+
+export default colorbrewerProxy;

simview/static/lib/chroma-js-3.1.2/src/colors/w3cx11.js

@@ -0,0 +1,164 @@
+/**
+	X11 color names
+
+	http://www.w3.org/TR/css3-color/#svg-color
+*/
+
+const w3cx11 = {
+    aliceblue: '#f0f8ff',
+    antiquewhite: '#faebd7',
+    aqua: '#00ffff',
+    aquamarine: '#7fffd4',
+    azure: '#f0ffff',
+    beige: '#f5f5dc',
+    bisque: '#ffe4c4',
+    black: '#000000',
+    blanchedalmond: '#ffebcd',
+    blue: '#0000ff',
+    blueviolet: '#8a2be2',
+    brown: '#a52a2a',
+    burlywood: '#deb887',
+    cadetblue: '#5f9ea0',
+    chartreuse: '#7fff00',
+    chocolate: '#d2691e',
+    coral: '#ff7f50',
+    cornflowerblue: '#6495ed',
+    cornsilk: '#fff8dc',
+    crimson: '#dc143c',
+    cyan: '#00ffff',
+    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: '#ff00ff',
+    gainsboro: '#dcdcdc',
+    ghostwhite: '#f8f8ff',
+    gold: '#ffd700',
+    goldenrod: '#daa520',
+    gray: '#808080',
+    green: '#008000',
+    greenyellow: '#adff2f',
+    grey: '#808080',
+    honeydew: '#f0fff0',
+    hotpink: '#ff69b4',
+    indianred: '#cd5c5c',
+    indigo: '#4b0082',
+    ivory: '#fffff0',
+    khaki: '#f0e68c',
+    laserlemon: '#ffff54',
+    lavender: '#e6e6fa',
+    lavenderblush: '#fff0f5',
+    lawngreen: '#7cfc00',
+    lemonchiffon: '#fffacd',
+    lightblue: '#add8e6',
+    lightcoral: '#f08080',
+    lightcyan: '#e0ffff',
+    lightgoldenrod: '#fafad2',
+    lightgoldenrodyellow: '#fafad2',
+    lightgray: '#d3d3d3',
+    lightgreen: '#90ee90',
+    lightgrey: '#d3d3d3',
+    lightpink: '#ffb6c1',
+    lightsalmon: '#ffa07a',
+    lightseagreen: '#20b2aa',
+    lightskyblue: '#87cefa',
+    lightslategray: '#778899',
+    lightslategrey: '#778899',
+    lightsteelblue: '#b0c4de',
+    lightyellow: '#ffffe0',
+    lime: '#00ff00',
+    limegreen: '#32cd32',
+    linen: '#faf0e6',
+    magenta: '#ff00ff',
+    maroon: '#800000',
+    maroon2: '#7f0000',
+    maroon3: '#b03060',
+    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',
+    purple2: '#7f007f',
+    purple3: '#a020f0',
+    rebeccapurple: '#663399',
+    red: '#ff0000',
+    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: '#ffffff',
+    whitesmoke: '#f5f5f5',
+    yellow: '#ffff00',
+    yellowgreen: '#9acd32'
+};
+
+export default w3cx11;

simview/static/lib/chroma-js-3.1.2/src/generator/average.js

@@ -0,0 +1,88 @@
+import Color from '../Color.js';
+import { clip_rgb } from '../utils/index.js';
+
+const { pow, sqrt, PI, cos, sin, atan2 } = Math;
+
+export default (colors, mode = 'lrgb', weights = null) => {
+    const l = colors.length;
+    if (!weights) weights = Array.from(new Array(l)).map(() => 1);
+    // normalize weights
+    const k =
+        l /
+        weights.reduce(function (a, b) {
+            return a + b;
+        });
+    weights.forEach((w, i) => {
+        weights[i] *= k;
+    });
+    // convert colors to Color objects
+    colors = colors.map((c) => new Color(c));
+    if (mode === 'lrgb') {
+        return _average_lrgb(colors, weights);
+    }
+    const first = colors.shift();
+    const xyz = first.get(mode);
+    const cnt = [];
+    let dx = 0;
+    let dy = 0;
+    // initial color
+    for (let i = 0; i < xyz.length; i++) {
+        xyz[i] = (xyz[i] || 0) * weights[0];
+        cnt.push(isNaN(xyz[i]) ? 0 : weights[0]);
+        if (mode.charAt(i) === 'h' && !isNaN(xyz[i])) {
+            const A = (xyz[i] / 180) * PI;
+            dx += cos(A) * weights[0];
+            dy += sin(A) * weights[0];
+        }
+    }
+
+    let alpha = first.alpha() * weights[0];
+    colors.forEach((c, ci) => {
+        const xyz2 = c.get(mode);
+        alpha += c.alpha() * weights[ci + 1];
+        for (let i = 0; i < xyz.length; i++) {
+            if (!isNaN(xyz2[i])) {
+                cnt[i] += weights[ci + 1];
+                if (mode.charAt(i) === 'h') {
+                    const A = (xyz2[i] / 180) * PI;
+                    dx += cos(A) * weights[ci + 1];
+                    dy += sin(A) * weights[ci + 1];
+                } else {
+                    xyz[i] += xyz2[i] * weights[ci + 1];
+                }
+            }
+        }
+    });
+
+    for (let i = 0; i < xyz.length; i++) {
+        if (mode.charAt(i) === 'h') {
+            let A = (atan2(dy / cnt[i], dx / cnt[i]) / PI) * 180;
+            while (A < 0) A += 360;
+            while (A >= 360) A -= 360;
+            xyz[i] = A;
+        } else {
+            xyz[i] = xyz[i] / cnt[i];
+        }
+    }
+    alpha /= l;
+    return new Color(xyz, mode).alpha(alpha > 0.99999 ? 1 : alpha, true);
+};
+
+const _average_lrgb = (colors, weights) => {
+    const l = colors.length;
+    const xyz = [0, 0, 0, 0];
+    for (let i = 0; i < colors.length; i++) {
+        const col = colors[i];
+        const f = weights[i] / l;
+        const rgb = col._rgb;
+        xyz[0] += pow(rgb[0], 2) * f;
+        xyz[1] += pow(rgb[1], 2) * f;
+        xyz[2] += pow(rgb[2], 2) * f;
+        xyz[3] += rgb[3] * f;
+    }
+    xyz[0] = sqrt(xyz[0]);
+    xyz[1] = sqrt(xyz[1]);
+    xyz[2] = sqrt(xyz[2]);
+    if (xyz[3] > 0.9999999) xyz[3] = 1;
+    return new Color(clip_rgb(xyz));
+};

simview/static/lib/chroma-js-3.1.2/src/generator/bezier.js

@@ -0,0 +1,86 @@
+//
+// interpolates between a set of colors uzing a bezier spline
+//
+
+// @requires utils lab
+import Color from '../Color.js';
+import '../io/lab/index.js';
+import scale from './scale.js';
+
+// nth row of the pascal triangle
+const binom_row = function (n) {
+    let row = [1, 1];
+    for (let i = 1; i < n; i++) {
+        let newrow = [1];
+        for (let j = 1; j <= row.length; j++) {
+            newrow[j] = (row[j] || 0) + row[j - 1];
+        }
+        row = newrow;
+    }
+    return row;
+};
+
+const bezier = function (colors) {
+    let I, lab0, lab1, lab2;
+    colors = colors.map((c) => new Color(c));
+    if (colors.length === 2) {
+        // linear interpolation
+        [lab0, lab1] = colors.map((c) => c.lab());
+        I = function (t) {
+            const lab = [0, 1, 2].map((i) => lab0[i] + t * (lab1[i] - lab0[i]));
+            return new Color(lab, 'lab');
+        };
+    } else if (colors.length === 3) {
+        // quadratic bezier interpolation
+        [lab0, lab1, lab2] = colors.map((c) => c.lab());
+        I = function (t) {
+            const lab = [0, 1, 2].map(
+                (i) =>
+                    (1 - t) * (1 - t) * lab0[i] +
+                    2 * (1 - t) * t * lab1[i] +
+                    t * t * lab2[i]
+            );
+            return new Color(lab, 'lab');
+        };
+    } else if (colors.length === 4) {
+        // cubic bezier interpolation
+        let lab3;
+        [lab0, lab1, lab2, lab3] = colors.map((c) => c.lab());
+        I = function (t) {
+            const lab = [0, 1, 2].map(
+                (i) =>
+                    (1 - t) * (1 - t) * (1 - t) * lab0[i] +
+                    3 * (1 - t) * (1 - t) * t * lab1[i] +
+                    3 * (1 - t) * t * t * lab2[i] +
+                    t * t * t * lab3[i]
+            );
+            return new Color(lab, 'lab');
+        };
+    } else if (colors.length >= 5) {
+        // general case (degree n bezier)
+        let labs, row, n;
+        labs = colors.map((c) => c.lab());
+        n = colors.length - 1;
+        row = binom_row(n);
+        I = function (t) {
+            const u = 1 - t;
+            const lab = [0, 1, 2].map((i) =>
+                labs.reduce(
+                    (sum, el, j) =>
+                        sum + row[j] * u ** (n - j) * t ** j * el[i],
+                    0
+                )
+            );
+            return new Color(lab, 'lab');
+        };
+    } else {
+        throw new RangeError('No point in running bezier with only one color.');
+    }
+    return I;
+};
+
+export default (colors) => {
+    const f = bezier(colors);
+    f.scale = () => scale(f);
+    return f;
+};

simview/static/lib/chroma-js-3.1.2/src/generator/blend.js

@@ -0,0 +1,57 @@
+/*
+ * interpolates between a set of colors uzing a bezier spline
+ * blend mode formulas taken from https://web.archive.org/web/20180110014946/http://www.venture-ware.com/kevin/coding/lets-learn-math-photoshop-blend-modes/
+ */
+
+import '../io/rgb/index.js';
+import chroma from '../chroma.js';
+
+const blend = (bottom, top, mode) => {
+    if (!blend[mode]) {
+        throw new Error('unknown blend mode ' + mode);
+    }
+    return blend[mode](bottom, top);
+};
+
+const blend_f = (f) => (bottom, top) => {
+    const c0 = chroma(top).rgb();
+    const c1 = chroma(bottom).rgb();
+    return chroma.rgb(f(c0, c1));
+};
+
+const each = (f) => (c0, c1) => {
+    const out = [];
+    out[0] = f(c0[0], c1[0]);
+    out[1] = f(c0[1], c1[1]);
+    out[2] = f(c0[2], c1[2]);
+    return out;
+};
+
+const normal = (a) => a;
+const multiply = (a, b) => (a * b) / 255;
+const darken = (a, b) => (a > b ? b : a);
+const lighten = (a, b) => (a > b ? a : b);
+const screen = (a, b) => 255 * (1 - (1 - a / 255) * (1 - b / 255));
+const overlay = (a, b) =>
+    b < 128 ? (2 * a * b) / 255 : 255 * (1 - 2 * (1 - a / 255) * (1 - b / 255));
+const burn = (a, b) => 255 * (1 - (1 - b / 255) / (a / 255));
+const dodge = (a, b) => {
+    if (a === 255) return 255;
+    a = (255 * (b / 255)) / (1 - a / 255);
+    return a > 255 ? 255 : a;
+};
+
+// # add = (a,b) ->
+// #     if (a + b > 255) then 255 else a + b
+
+blend.normal = blend_f(each(normal));
+blend.multiply = blend_f(each(multiply));
+blend.screen = blend_f(each(screen));
+blend.overlay = blend_f(each(overlay));
+blend.darken = blend_f(each(darken));
+blend.lighten = blend_f(each(lighten));
+blend.dodge = blend_f(each(dodge));
+blend.burn = blend_f(each(burn));
+// blend.add = blend_f(each(add));
+
+export default blend;

simview/static/lib/chroma-js-3.1.2/src/generator/cubehelix.js

@@ -0,0 +1,87 @@
+// cubehelix interpolation
+// based on D.A. Green "A colour scheme for the display of astronomical intensity images"
+// http://astron-soc.in/bulletin/11June/289392011.pdf
+import { type, clip_rgb, TWOPI } from '../utils/index.js';
+import chroma from '../chroma.js';
+const { pow, sin, cos } = Math;
+
+export default function (
+    start = 300,
+    rotations = -1.5,
+    hue = 1,
+    gamma = 1,
+    lightness = [0, 1]
+) {
+    let dh = 0,
+        dl;
+    if (type(lightness) === 'array') {
+        dl = lightness[1] - lightness[0];
+    } else {
+        dl = 0;
+        lightness = [lightness, lightness];
+    }
+    const f = function (fract) {
+        const a = TWOPI * ((start + 120) / 360 + rotations * fract);
+        const l = pow(lightness[0] + dl * fract, gamma);
+        const h = dh !== 0 ? hue[0] + fract * dh : hue;
+        const amp = (h * l * (1 - l)) / 2;
+        const cos_a = cos(a);
+        const sin_a = sin(a);
+        const r = l + amp * (-0.14861 * cos_a + 1.78277 * sin_a);
+        const g = l + amp * (-0.29227 * cos_a - 0.90649 * sin_a);
+        const b = l + amp * (+1.97294 * cos_a);
+        return chroma(clip_rgb([r * 255, g * 255, b * 255, 1]));
+    };
+    f.start = function (s) {
+        if (s == null) {
+            return start;
+        }
+        start = s;
+        return f;
+    };
+    f.rotations = function (r) {
+        if (r == null) {
+            return rotations;
+        }
+        rotations = r;
+        return f;
+    };
+    f.gamma = function (g) {
+        if (g == null) {
+            return gamma;
+        }
+        gamma = g;
+        return f;
+    };
+    f.hue = function (h) {
+        if (h == null) {
+            return hue;
+        }
+        hue = h;
+        if (type(hue) === 'array') {
+            dh = hue[1] - hue[0];
+            if (dh === 0) {
+                hue = hue[1];
+            }
+        } else {
+            dh = 0;
+        }
+        return f;
+    };
+    f.lightness = function (h) {
+        if (h == null) {
+            return lightness;
+        }
+        if (type(h) === 'array') {
+            lightness = h;
+            dl = h[1] - h[0];
+        } else {
+            lightness = [h, h];
+            dl = 0;
+        }
+        return f;
+    };
+    f.scale = () => chroma.scale(f);
+    f.hue(hue);
+    return f;
+}

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

@@ -0,0 +1,19 @@
+import Color from '../Color.js';
+import { type } from '../utils/index.js';
+import interpolator from '../interpolator/index.js';
+
+export default (col1, col2, f = 0.5, ...rest) => {
+    let mode = rest[0] || 'lrgb';
+    if (!interpolator[mode] && !rest.length) {
+        // fall back to the first supported mode
+        mode = Object.keys(interpolator)[0];
+    }
+    if (!interpolator[mode]) {
+        throw new Error(`interpolation mode ${mode} is not defined`);
+    }
+    if (type(col1) !== 'object') col1 = new Color(col1);
+    if (type(col2) !== 'object') col2 = new Color(col2);
+    return interpolator[mode](col1, col2, f).alpha(
+        col1.alpha() + f * (col2.alpha() - col1.alpha())
+    );
+};

simview/static/lib/chroma-js-3.1.2/src/generator/random.js

@@ -0,0 +1,12 @@
+import Color from '../Color.js';
+const digits = '0123456789abcdef';
+
+const { floor, random } = Math;
+
+export default () => {
+    let code = '#';
+    for (let i = 0; i < 6; i++) {
+        code += digits.charAt(floor(random() * 16));
+    }
+    return new Color(code, 'hex');
+};