4307 lines
124 KiB
JavaScript
4307 lines
124 KiB
JavaScript
// Metro module 689 (f690).
|
|
function $mk101373($env) {
|
|
return function(a0, a1) {
|
|
const r3 = $env.$parent[206];
|
|
return r3.rgb((0, $env[0])(r3(a1).rgb(), r3(a0).rgb()));
|
|
};
|
|
}
|
|
function $mk101374($env) {
|
|
return function(a0, a1) {
|
|
const r8 = $env[0];
|
|
return [r8(a0[0], a1[0]), r8(a0[1], a1[1]), r8(a0[2], a1[2])];
|
|
};
|
|
}
|
|
const n = function n() {
|
|
"use strict";
|
|
let env12443;
|
|
const r11 = env12443 = {};
|
|
const r12 = {};
|
|
env12443[0] = r12;
|
|
const r10 = ["Boolean", "Number", "String", "Function", "Array", "Date", "RegExp", "Undefined", "Null"];
|
|
const r6 = 0 < r10.length;
|
|
let r1 = 0;
|
|
if (r6) {
|
|
do {
|
|
const r14 = r10[r1];
|
|
r12["[object " + r14 + "]"] = r14.toLowerCase();
|
|
r1 = r1 + 1;
|
|
} while (r1 < r10.length);
|
|
}
|
|
let env12444;
|
|
let env12445;
|
|
let env12446;
|
|
let env12447;
|
|
let env12448;
|
|
let env12449;
|
|
let env12450;
|
|
let env12451;
|
|
let env12452;
|
|
let env12453;
|
|
let env12454;
|
|
let env12455;
|
|
let env12456;
|
|
let env12457;
|
|
let env12458;
|
|
let env12459;
|
|
const limit$2 = function limit$2(a0, a1, a2) {};
|
|
const type$p = function type$p(a0) {};
|
|
env12443[1] = type$p;
|
|
env12443[2] = type$p;
|
|
const PI = Math.PI;
|
|
const clip_rgb = function clip_rgb(a0) {
|
|
a0._clipped = false;
|
|
a0._unclipped = a0.slice(0);
|
|
let r2 = 0;
|
|
while (true) {
|
|
const r0 = r2;
|
|
if (r0 < 3) {
|
|
if (a0[r0] < 0 || a0[r0] > 255) {
|
|
a0._clipped = true;
|
|
}
|
|
let r18 = a0[r0];
|
|
const r19 = r18 < 0;
|
|
let r20 = 0;
|
|
if (!r19) {
|
|
if (r18 > 255) {
|
|
r18 = 255;
|
|
}
|
|
r20 = r18;
|
|
}
|
|
a0[r0] = r20;
|
|
} else if (r0 === 3) {
|
|
let r11 = a0[r0];
|
|
const r6 = r11 < 0;
|
|
let r14 = 0;
|
|
if (!r6) {
|
|
if (r11 > 1) {
|
|
r11 = 1;
|
|
}
|
|
r14 = r11;
|
|
}
|
|
a0[r0] = r14;
|
|
}
|
|
r2 = r0 + 1;
|
|
if (!(r2 <= 3)) {
|
|
return a0;
|
|
}
|
|
}
|
|
};
|
|
const unpack = function unpack(a0, a1) {
|
|
let r20;
|
|
const r7 = a1 === void 0 ? null : a1;
|
|
L19: {
|
|
if (a0.length >= 3) {
|
|
r20 = Array.prototype.slice.call(a0);
|
|
} else {
|
|
const r4 = env12443[1];
|
|
if ((env12443[0][Object.prototype.toString.call(a0[0])] || "object") == "object" && r7) {
|
|
r20 = r7.split("").filter(function(item) {
|
|
return a0[0][item] !== void 0;
|
|
}).map(function(item) {
|
|
return a0[0][item];
|
|
});
|
|
break L19;
|
|
}
|
|
r20 = a0[0];
|
|
}
|
|
}
|
|
return r20;
|
|
};
|
|
const last = function last(a0) {};
|
|
const r35 = 2 * PI;
|
|
const r5 = PI / 3;
|
|
const r36 = PI / 180;
|
|
const r37 = 180 / PI;
|
|
const r39 = {
|
|
format: {},
|
|
autodetect: []
|
|
};
|
|
env12443[3] = last;
|
|
env12443[4] = clip_rgb;
|
|
env12443[5] = type$p;
|
|
env12443[6] = r39;
|
|
const Color = function Color() {
|
|
let r24, r79;
|
|
const r8 = [];
|
|
const r22 = +arguments.length;
|
|
let r10 = r22 - 1;
|
|
if (r22) {
|
|
do {
|
|
r8[r10] = arguments[r10];
|
|
r24 = +r10;
|
|
r10 = r24 - 1;
|
|
} while (r24);
|
|
}
|
|
const r26 = env12443[5];
|
|
const r12 = r8[0];
|
|
const r15 = env12443[0];
|
|
if ((r15[Object.prototype.toString.call(r12)] || "object") === "object" && r8[0].constructor && r8[0].constructor === this.constructor) {
|
|
return r8[0];
|
|
}
|
|
const r3 = r8.length < 2;
|
|
let r44 = null;
|
|
if (!r3) {
|
|
const r47 = r8.length - 1;
|
|
const r48 = env12443[2];
|
|
r44 = (r15[Object.prototype.toString.call(r8[r47])] || "object") == "string" ? r8[r47].toLowerCase() : null;
|
|
}
|
|
let r61 = false;
|
|
let r62 = r44;
|
|
if (!r62) {
|
|
const r63 = env12443[6];
|
|
if (!r63.sorted) {
|
|
r63.autodetect = r63.autodetect.sort(function(a, b) {
|
|
return b.p - a.p;
|
|
});
|
|
r63.sorted = true;
|
|
}
|
|
const autodetect = r63.autodetect;
|
|
const length = autodetect.length;
|
|
let r0 = 0;
|
|
const r71 = 0 < length;
|
|
r61 = true;
|
|
r62 = r44;
|
|
if (r71) {
|
|
do {
|
|
const r73 = autodetect[r0];
|
|
const r76 = r73.test.apply(r73, r8);
|
|
const r1 = r0;
|
|
r61 = true;
|
|
r62 = r76;
|
|
if (r76) {
|
|
break;
|
|
}
|
|
const r77 = r1 + 1;
|
|
r79 = r77 < autodetect.length;
|
|
r0 = r77;
|
|
r61 = true;
|
|
r62 = r76;
|
|
} while (r79);
|
|
}
|
|
}
|
|
const r80 = env12443[6];
|
|
if (r80.format[r62]) {
|
|
const _rgb = r80.format[r62].apply(null, r61 ? r8 : r8.slice(0, -1));
|
|
(0, env12443[4])(_rgb);
|
|
this._rgb = _rgb;
|
|
if (this._rgb.length === 3) {
|
|
this._rgb.push(1);
|
|
}
|
|
return void 0;
|
|
}
|
|
throw new Error("unknown format: " + r8);
|
|
};
|
|
Color.prototype.toString = function toString() {
|
|
const r1 = env12443[5];
|
|
return (env12443[0][Object.prototype.toString.call(this.hex)] || "object") == "function" ? this.hex() : "[" + this._rgb.join(",") + "]";
|
|
};
|
|
const chroma$k = function chroma$k() {
|
|
let r13;
|
|
const r6 = [];
|
|
const r11 = +arguments.length;
|
|
let r2 = r11 - 1;
|
|
if (r11) {
|
|
do {
|
|
r6[r2] = arguments[r2];
|
|
r13 = +r2;
|
|
r2 = r13 - 1;
|
|
} while (r13);
|
|
}
|
|
return new (Function.prototype.bind.apply(env12443[7].Color, [null].concat(r6)))();
|
|
};
|
|
env12443[7] = chroma$k;
|
|
chroma$k.Color = Color;
|
|
chroma$k.version = "2.4.2";
|
|
env12443[8] = unpack;
|
|
env12443[9] = Math.max;
|
|
env12443[10] = unpack;
|
|
env12443[11] = Color;
|
|
env12443[12] = unpack;
|
|
env12443[13] = type$p;
|
|
env12443[14] = function rgb2cmyk_1() {
|
|
let r15;
|
|
const r11 = [];
|
|
const r13 = +arguments.length;
|
|
let r9 = r13 - 1;
|
|
if (r13) {
|
|
do {
|
|
r11[r9] = arguments[r9];
|
|
r15 = +r9;
|
|
r9 = r15 - 1;
|
|
} while (r15);
|
|
}
|
|
const r17 = env12443[8];
|
|
let r1 = 0;
|
|
const r19 = r17(r11, "rgb");
|
|
const r20 = r19[0];
|
|
const r21 = r19[1];
|
|
const r22 = r19[2];
|
|
const r23 = env12443[9];
|
|
const r3 = r20 / 255;
|
|
const r4 = r21 / 255;
|
|
const r5 = r22 / 255;
|
|
const r26 = 1 - r23(r3, r23(r4, r5));
|
|
if (r26 < 1) {
|
|
r1 = 1 / (1 - r26);
|
|
}
|
|
return [(1 - r3 - r26) * r1, (1 - r4 - r26) * r1, (1 - r5 - r26) * r1, r26];
|
|
};
|
|
Color.prototype.cmyk = function() {
|
|
return (0, env12443[14])(this._rgb);
|
|
};
|
|
chroma$k.cmyk = function() {
|
|
let r14;
|
|
const r7 = [];
|
|
const r12 = +arguments.length;
|
|
let r2 = r12 - 1;
|
|
if (r12) {
|
|
do {
|
|
r7[r2] = arguments[r2];
|
|
r14 = +r2;
|
|
r2 = r14 - 1;
|
|
} while (r14);
|
|
}
|
|
return new (Function.prototype.bind.apply(env12443[11], [null].concat(r7, ["cmyk"])))();
|
|
};
|
|
r39.format.cmyk = function cmyk2rgb_1() {
|
|
let r16;
|
|
const r9 = [];
|
|
const r14 = +arguments.length;
|
|
let r8 = r14 - 1;
|
|
if (r14) {
|
|
do {
|
|
r9[r8] = arguments[r8];
|
|
r16 = +r8;
|
|
r8 = r16 - 1;
|
|
} while (r16);
|
|
}
|
|
const r12 = (0, env12443[10])(r9, "cmyk");
|
|
const r20 = r12[0];
|
|
const r11 = r12[1];
|
|
const r21 = r12[2];
|
|
const r22 = r12[3];
|
|
const r25 = r12.length > 4 ? r12[4] : 1;
|
|
return r22 === 1 ? [0, 0, 0, r25] : [r20 >= 1 ? 0 : 255 * (1 - r20) * (1 - r22), r11 >= 1 ? 0 : 255 * (1 - r11) * (1 - r22), r21 >= 1 ? 0 : 255 * (1 - r21) * (1 - r22), r25];
|
|
};
|
|
r39.autodetect.push({
|
|
p: 2,
|
|
test: function test() {
|
|
let r12;
|
|
const r5 = [];
|
|
const r10 = +arguments.length;
|
|
let r3 = r10 - 1;
|
|
if (r10) {
|
|
do {
|
|
r5[r3] = arguments[r3];
|
|
r12 = +r3;
|
|
r3 = r12 - 1;
|
|
} while (r12);
|
|
}
|
|
const r16 = (0, env12443[12])(r5, "cmyk");
|
|
if ((env12443[0][Object.prototype.toString.call(r16)] || "object") === "array" && r16.length === 4) {
|
|
return "cmyk";
|
|
}
|
|
}
|
|
});
|
|
env12443[15] = unpack;
|
|
env12443[16] = last;
|
|
env12443[17] = function rnd(a0) {};
|
|
env12443[18] = unpack;
|
|
const rgb2hsl_1 = function rgb2hsl_1() {
|
|
let r19, r37, NaN2;
|
|
const r11 = [];
|
|
const r17 = +arguments.length;
|
|
let r10 = r17 - 1;
|
|
if (r17) {
|
|
do {
|
|
r11[r10] = arguments[r10];
|
|
r19 = +r10;
|
|
r10 = r19 - 1;
|
|
} while (r19);
|
|
}
|
|
const r23 = (0, env12443[18])(r11, "rgba");
|
|
const r24 = r23[0];
|
|
const r25 = r23[1];
|
|
const r26 = r23[2];
|
|
const r2 = r24 / 255;
|
|
const r3 = r25 / 255;
|
|
const r0 = r26 / 255;
|
|
const r13 = Math.min(r2, r3, r0);
|
|
const r31 = Math.max(r2, r3, r0);
|
|
const r33 = (r31 + r13) / 2;
|
|
if (r31 === r13) {
|
|
NaN2 = Number.NaN;
|
|
r37 = 0;
|
|
} else {
|
|
r37 = r33 < 0.5 ? (r31 - r13) / (r31 + r13) : (r31 - r13) / (2 - r31 - r13);
|
|
NaN2 = void 0;
|
|
}
|
|
if (r2 == r31) {
|
|
NaN2 = (r3 - r0) / (r31 - r13);
|
|
} else if (r3 == r31) {
|
|
NaN2 = 2 + (r0 - r2) / (r31 - r13);
|
|
} else if (r0 == r31) {
|
|
NaN2 = 4 + (r2 - r3) / (r31 - r13);
|
|
}
|
|
const r50 = NaN2 * 60;
|
|
let r51 = r50;
|
|
if (r51 < 0) {
|
|
r51 = r50 + 360;
|
|
}
|
|
return r23.length > 3 && r23[3] !== void 0 ? [r51, r37, r33, r23[3]] : [r51, r37, r33];
|
|
};
|
|
env12443[19] = unpack;
|
|
env12443[20] = last;
|
|
env12443[21] = function hsl2css_1() {
|
|
let r20;
|
|
const r10 = [];
|
|
const r18 = +arguments.length;
|
|
let r6 = r18 - 1;
|
|
if (r18) {
|
|
do {
|
|
r10[r6] = arguments[r6];
|
|
r20 = +r6;
|
|
r6 = r20 - 1;
|
|
} while (r20);
|
|
}
|
|
const r8 = (0, env12443[15])(r10, "hsla");
|
|
const r4 = r10.length < 2;
|
|
let r27 = null;
|
|
if (!r4) {
|
|
const r28 = r10.length - 1;
|
|
const r29 = env12443[2];
|
|
r27 = (env12443[0][Object.prototype.toString.call(r10[r28])] || "object") == "string" ? r10[r28].toLowerCase() : null;
|
|
}
|
|
if (!r27) {
|
|
r27 = "lsa";
|
|
}
|
|
const r42 = env12443[17];
|
|
r8[0] = Math.round(100 * (r8[0] || 0)) / 100;
|
|
const r60 = Math.round(100 * (100 * r8[1])) / 100;
|
|
let r61 = 1;
|
|
r8[1] = r60 + "%";
|
|
const r65 = 100 * r8[2];
|
|
L32: {
|
|
L29: {
|
|
r8[2] = Math.round(100 * r65) / 100 + "%";
|
|
if (r27 !== "hsla") {
|
|
if (r8.length > 3 && r8[3] < 1) {
|
|
break L29;
|
|
}
|
|
r8.length = 3;
|
|
break L32;
|
|
}
|
|
}
|
|
if (r8.length > 3) {
|
|
r61 = r8[3];
|
|
}
|
|
r8[3] = r61;
|
|
r27 = "hsla";
|
|
}
|
|
return r27 + "(" + r8.join(",") + ")";
|
|
};
|
|
env12443[22] = rgb2hsl_1;
|
|
env12443[23] = Math.round;
|
|
env12443[24] = unpack;
|
|
env12443[25] = Math.round;
|
|
const hsl2rgb_1 = function hsl2rgb_1() {
|
|
let r23, r74, r75, r76;
|
|
const r15 = [];
|
|
const r21 = +arguments.length;
|
|
let r13 = r21 - 1;
|
|
if (r21) {
|
|
do {
|
|
r15[r13] = arguments[r13];
|
|
r23 = +r13;
|
|
r13 = r23 - 1;
|
|
} while (r23);
|
|
}
|
|
const r27 = (0, env12443[24])(r15, "hsl");
|
|
const r18 = r27[0];
|
|
const r28 = r27[1];
|
|
const r29 = r27[2];
|
|
if (r28 === 0) {
|
|
r76 = 255 * r29;
|
|
r75 = r76;
|
|
r74 = r75;
|
|
} else {
|
|
const r16 = [0, 0, 0];
|
|
const r30 = r29 < 0.5 ? r29 * (1 + r28) : r29 + r28 - r29 * r28;
|
|
const r3 = 2 * r29 - r30;
|
|
const r7 = r18 / 360;
|
|
const r33 = [r7 + 0.3333333333333333, r7, r7 - 0.3333333333333333];
|
|
let r40 = 0;
|
|
while (true) {
|
|
const r41 = r33[r40];
|
|
const r1 = r40;
|
|
if (r41 < 0) {
|
|
r33[r1] = r33[r1] + 1;
|
|
}
|
|
if (r33[r1] > 1) {
|
|
r33[r1] = r33[r1] - 1;
|
|
}
|
|
if (6 * r33[r1] < 1) {
|
|
r16[r1] = r3 + 6 * (r30 - r3) * r33[r1];
|
|
} else if (2 * r33[r1] < 1) {
|
|
r16[r1] = r30;
|
|
} else if (3 * r33[r1] < 2) {
|
|
r16[r1] = r3 + (r30 - r3) * (0.6666666666666666 - r33[r1]) * 6;
|
|
} else {
|
|
r16[r1] = r3;
|
|
}
|
|
r40 = r1 + 1;
|
|
if (!(r40 < 3)) {
|
|
const r62 = env12443[25];
|
|
const r67 = [r62(255 * r16[0]), r62(255 * r16[1]), r62(255 * r16[2])];
|
|
r74 = r67[0];
|
|
r75 = r67[1];
|
|
r76 = r67[2];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return r27.length > 3 ? [r74, r75, r76, r27[3]] : [r74, r75, r76, 1];
|
|
};
|
|
env12443[26] = hsl2rgb_1;
|
|
env12443[27] = r39;
|
|
env12443[28] = /^rgb\(\s*(-?\d+),\s*(-?\d+)\s*,\s*(-?\d+)\s*\)$/;
|
|
env12443[29] = /^rgba\(\s*(-?\d+),\s*(-?\d+)\s*,\s*(-?\d+)\s*,\s*([01]|[01]?\.\d+)\)$/;
|
|
env12443[30] = /^rgb\(\s*(-?\d+(?:\.\d+)?)%,\s*(-?\d+(?:\.\d+)?)%\s*,\s*(-?\d+(?:\.\d+)?)%\s*\)$/;
|
|
env12443[31] = /^rgba\(\s*(-?\d+(?:\.\d+)?)%,\s*(-?\d+(?:\.\d+)?)%\s*,\s*(-?\d+(?:\.\d+)?)%\s*,\s*([01]|[01]?\.\d+)\)$/;
|
|
env12443[32] = /^hsl\(\s*(-?\d+(?:\.\d+)?),\s*(-?\d+(?:\.\d+)?)%\s*,\s*(-?\d+(?:\.\d+)?)%\s*\)$/;
|
|
env12443[33] = /^hsla\(\s*(-?\d+(?:\.\d+)?),\s*(-?\d+(?:\.\d+)?)%\s*,\s*(-?\d+(?:\.\d+)?)%\s*,\s*([01]|[01]?\.\d+)\)$/;
|
|
env12443[34] = Math.round;
|
|
const css2rgb$1 = function css2rgb$1(a0) {
|
|
let r6, r19;
|
|
L4: {
|
|
r6 = a0.toLowerCase().trim();
|
|
const r14 = env12443[27];
|
|
if (r14.format.named) {
|
|
try {
|
|
r19 = r14.format.named(r6);
|
|
} catch ($e) {
|
|
break L4;
|
|
}
|
|
return r19;
|
|
}
|
|
}
|
|
const r3 = r6.match(env12443[28]);
|
|
if (r3) {
|
|
const r99 = r3.slice(1, 4);
|
|
let r101 = 0;
|
|
while (true) {
|
|
r99[r101] = +r99[r101];
|
|
r101 = r101 + 1;
|
|
if (!(r101 < 3)) {
|
|
r99[3] = 1;
|
|
return r99;
|
|
}
|
|
}
|
|
} else {
|
|
const r2 = r6.match(env12443[29]);
|
|
if (r2) {
|
|
const r91 = r2.slice(1, 5);
|
|
let r93 = 0;
|
|
while (true) {
|
|
r91[r93] = +r91[r93];
|
|
r93 = r93 + 1;
|
|
if (!(r93 < 4)) {
|
|
return r91;
|
|
}
|
|
}
|
|
} else {
|
|
const r5 = r6.match(env12443[30]);
|
|
if (r5) {
|
|
const r79 = r5.slice(1, 4);
|
|
let r83 = 0;
|
|
while (true) {
|
|
r79[r83] = (0, env12443[34])(2.55 * r79[r83]);
|
|
r83 = r83 + 1;
|
|
if (!(r83 < 3)) {
|
|
r79[3] = 1;
|
|
return r79;
|
|
}
|
|
}
|
|
} else {
|
|
const r4 = r6.match(env12443[31]);
|
|
if (!r4) {
|
|
const r7 = r6.match(env12443[32]);
|
|
if (r7) {
|
|
const r52 = r7.slice(1, 4);
|
|
r52[1] = r52[1] * 0.01;
|
|
r52[2] = r52[2] * 0.01;
|
|
const r61 = (0, env12443[26])(r52);
|
|
r61[3] = 1;
|
|
return r61;
|
|
}
|
|
const r33 = r6.match(env12443[33]);
|
|
if (r33) {
|
|
const r9 = r33.slice(1, 4);
|
|
r9[1] = r9[1] * 0.01;
|
|
r9[2] = r9[2] * 0.01;
|
|
const r45 = (0, env12443[26])(r9);
|
|
r45[3] = +r33[4];
|
|
return r45;
|
|
}
|
|
return void 0;
|
|
}
|
|
const r66 = r4.slice(1, 5);
|
|
let r70 = 0;
|
|
while (true) {
|
|
r66[r70] = (0, env12443[34])(2.55 * r66[r70]);
|
|
r70 = r70 + 1;
|
|
if (!(r70 < 3)) {
|
|
r66[3] = +r66[3];
|
|
return r66;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
css2rgb$1.test = function(a0) {
|
|
return env12443[28].test(a0) || env12443[29].test(a0) || env12443[30].test(a0) || env12443[31].test(a0) || env12443[32].test(a0) || env12443[33].test(a0);
|
|
};
|
|
env12443[35] = Color;
|
|
env12443[36] = type$p;
|
|
env12443[37] = function rgb2css_1() {
|
|
let r22, r73;
|
|
const r12 = [];
|
|
const r20 = +arguments.length;
|
|
let r8 = r20 - 1;
|
|
if (r20) {
|
|
do {
|
|
r12[r8] = arguments[r8];
|
|
r22 = +r8;
|
|
r8 = r22 - 1;
|
|
} while (r22);
|
|
}
|
|
const r11 = (0, env12443[19])(r12, "rgba");
|
|
const r3 = r12.length < 2;
|
|
let r10 = null;
|
|
if (!r3) {
|
|
const r29 = r12.length - 1;
|
|
const r30 = env12443[2];
|
|
r10 = (env12443[0][Object.prototype.toString.call(r12[r29])] || "object") == "string" ? r12[r29].toLowerCase() : null;
|
|
}
|
|
if (!r10) {
|
|
r10 = "rgb";
|
|
}
|
|
if (r10.substr(0, 3) == "hsl") {
|
|
r73 = (0, env12443[21])((0, env12443[22])(r11), r10);
|
|
} else {
|
|
const r48 = env12443[23];
|
|
r11[0] = r48(r11[0]);
|
|
const r52 = r48(r11[1]);
|
|
let r53 = 1;
|
|
r11[1] = r52;
|
|
r11[2] = r48(r11[2]);
|
|
const r56 = r10 === "rgba" || r11.length > 3 && r11[3] < 1;
|
|
let r59 = r10;
|
|
if (r56) {
|
|
if (r11.length > 3) {
|
|
r53 = r11[3];
|
|
}
|
|
r11[3] = r53;
|
|
r59 = "rgba";
|
|
}
|
|
r73 = r59 + "(" + r11.slice(0, r59 === "rgb" ? 3 : 4).join(",") + ")";
|
|
}
|
|
return r73;
|
|
};
|
|
env12443[38] = css2rgb$1;
|
|
Color.prototype.css = function(a0) {
|
|
return (0, env12443[37])(this._rgb, a0);
|
|
};
|
|
chroma$k.css = function() {
|
|
let r14;
|
|
const r7 = [];
|
|
const r12 = +arguments.length;
|
|
let r2 = r12 - 1;
|
|
if (r12) {
|
|
do {
|
|
r7[r2] = arguments[r2];
|
|
r14 = +r2;
|
|
r2 = r14 - 1;
|
|
} while (r14);
|
|
}
|
|
return new (Function.prototype.bind.apply(env12443[35], [null].concat(r7, ["css"])))();
|
|
};
|
|
r39.format.css = css2rgb$1;
|
|
r39.autodetect.push({
|
|
p: 5,
|
|
test: function test(a0) {
|
|
let r15;
|
|
const r6 = [];
|
|
const r1 = arguments.length - 1;
|
|
let r0 = r1 - 1;
|
|
if (0 < r1) {
|
|
do {
|
|
r6[r0] = arguments[r0 + 1];
|
|
const r3 = r0 - 1;
|
|
r15 = r0;
|
|
r0 = r3;
|
|
} while (0 < r15);
|
|
}
|
|
if (!r6.length) {
|
|
if ((env12443[0][Object.prototype.toString.call(a0)] || "object") === "string" && env12443[38].test(a0)) {
|
|
return "css";
|
|
}
|
|
}
|
|
}
|
|
});
|
|
env12443[39] = Color;
|
|
env12443[40] = unpack;
|
|
r39.format.gl = function() {
|
|
let r11;
|
|
const r6 = [];
|
|
const r9 = +arguments.length;
|
|
let r5 = r9 - 1;
|
|
if (r9) {
|
|
do {
|
|
r6[r5] = arguments[r5];
|
|
r11 = +r5;
|
|
r5 = r11 - 1;
|
|
} while (r11);
|
|
}
|
|
const r15 = (0, env12443[40])(r6, "rgba");
|
|
r15[0] = r15[0] * 255;
|
|
r15[1] = r15[1] * 255;
|
|
r15[2] = r15[2] * 255;
|
|
return r15;
|
|
};
|
|
chroma$k.gl = function() {
|
|
let r14;
|
|
const r7 = [];
|
|
const r12 = +arguments.length;
|
|
let r2 = r12 - 1;
|
|
if (r12) {
|
|
do {
|
|
r7[r2] = arguments[r2];
|
|
r14 = +r2;
|
|
r2 = r14 - 1;
|
|
} while (r14);
|
|
}
|
|
return new (Function.prototype.bind.apply(env12443[39], [null].concat(r7, ["gl"])))();
|
|
};
|
|
Color.prototype.gl = function() {
|
|
const _rgb = this._rgb;
|
|
return [_rgb[0] / 255, _rgb[1] / 255, _rgb[2] / 255, _rgb[3]];
|
|
};
|
|
env12443[41] = unpack;
|
|
env12443[42] = unpack;
|
|
env12443[43] = Math.floor;
|
|
env12443[44] = unpack;
|
|
env12443[45] = type$p;
|
|
env12443[46] = Color;
|
|
env12443[47] = function rgb2hcg_1() {
|
|
let r17, NaN2;
|
|
const r9 = [];
|
|
const r15 = +arguments.length;
|
|
let r8 = r15 - 1;
|
|
if (r15) {
|
|
do {
|
|
r9[r8] = arguments[r8];
|
|
r17 = +r8;
|
|
r8 = r17 - 1;
|
|
} while (r17);
|
|
}
|
|
const r21 = (0, env12443[41])(r9, "rgb");
|
|
const r22 = r21[0];
|
|
const r23 = r21[1];
|
|
const r12 = r21[2];
|
|
const r13 = Math.min(r22, r23, r12);
|
|
const r28 = Math.max(r22, r23, r12);
|
|
const r29 = r28 - r13;
|
|
const r5 = 100 * r29;
|
|
const r30 = r13 / (255 - r29);
|
|
if (r29 === 0) {
|
|
NaN2 = Number.NaN;
|
|
} else {
|
|
let r7 = r22 === r28 ? (r23 - r12) / r29 : void 0;
|
|
if (r23 === r28) {
|
|
r7 = 2 + (r12 - r22) / r29;
|
|
}
|
|
if (r12 === r28) {
|
|
r7 = 4 + (r22 - r23) / r29;
|
|
}
|
|
const r38 = r7 * 60;
|
|
NaN2 = r38;
|
|
if (NaN2 < 0) {
|
|
NaN2 = r38 + 360;
|
|
}
|
|
}
|
|
return [NaN2, r5 / 255, r30 * 100];
|
|
};
|
|
Color.prototype.hcg = function() {
|
|
return (0, env12443[47])(this._rgb);
|
|
};
|
|
chroma$k.hcg = function() {
|
|
let r14;
|
|
const r7 = [];
|
|
const r12 = +arguments.length;
|
|
let r2 = r12 - 1;
|
|
if (r12) {
|
|
do {
|
|
r7[r2] = arguments[r2];
|
|
r14 = +r2;
|
|
r2 = r14 - 1;
|
|
} while (r14);
|
|
}
|
|
return new (Function.prototype.bind.apply(env12443[46], [null].concat(r7, ["hcg"])))();
|
|
};
|
|
r39.format.hcg = function hcg2rgb_1() {
|
|
let r19;
|
|
const r11 = [];
|
|
const r17 = +arguments.length;
|
|
let r9 = r17 - 1;
|
|
if (r17) {
|
|
do {
|
|
r11[r9] = arguments[r9];
|
|
r19 = +r9;
|
|
r9 = r19 - 1;
|
|
} while (r19);
|
|
}
|
|
const r23 = (0, env12443[42])(r11, "hcg");
|
|
let r14 = r23[0];
|
|
const r13 = r23[1];
|
|
const r3 = r23[2] * 255;
|
|
const r4 = 255 * r13;
|
|
let r25 = r3;
|
|
let r26 = r25;
|
|
let r12 = r26;
|
|
if (r13 !== 0) {
|
|
if (r14 === 360) {
|
|
r14 = 0;
|
|
}
|
|
let r15 = r14;
|
|
if (r15 > 360) {
|
|
r15 = r14 - 360;
|
|
}
|
|
let r28 = r15;
|
|
if (r28 < 0) {
|
|
r28 = r15 + 360;
|
|
}
|
|
const r29 = env12443[43];
|
|
const r31 = r28 / 60;
|
|
const r32 = r29(r31);
|
|
const r1 = r31 - r32;
|
|
const r34 = r3 * (1 - r13);
|
|
const r36 = r34 + r4 * r1;
|
|
const r6 = r34 + r4;
|
|
if (r32 === 0) {
|
|
const r49 = [r6, r36, r34];
|
|
r12 = r49[0];
|
|
r26 = r49[1];
|
|
r25 = r49[2];
|
|
} else {
|
|
const r39 = r34 + r4 * (1 - r1);
|
|
if (r32 === 1) {
|
|
const r48 = [r39, r6, r34];
|
|
r12 = r48[0];
|
|
r26 = r48[1];
|
|
r25 = r48[2];
|
|
} else if (r32 === 2) {
|
|
const r47 = [r34, r6, r36];
|
|
r12 = r47[0];
|
|
r26 = r47[1];
|
|
r25 = r47[2];
|
|
} else if (r32 === 3) {
|
|
const r46 = [r34, r39, r6];
|
|
r12 = r46[0];
|
|
r26 = r46[1];
|
|
r25 = r46[2];
|
|
} else if (r32 === 4) {
|
|
const r45 = [r36, r34, r6];
|
|
r12 = r45[0];
|
|
r26 = r45[1];
|
|
r25 = r45[2];
|
|
} else {
|
|
r25 = void 0;
|
|
r26 = void 0;
|
|
r12 = void 0;
|
|
if (r32 === 5) {
|
|
const r44 = [r6, r34, r39];
|
|
r12 = r44[0];
|
|
r26 = r44[1];
|
|
r25 = r44[2];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return [r12, r26, r25, r23.length > 3 ? r23[3] : 1];
|
|
};
|
|
r39.autodetect.push({
|
|
p: 1,
|
|
test: function test() {
|
|
let r12;
|
|
const r5 = [];
|
|
const r10 = +arguments.length;
|
|
let r3 = r10 - 1;
|
|
if (r10) {
|
|
do {
|
|
r5[r3] = arguments[r3];
|
|
r12 = +r3;
|
|
r3 = r12 - 1;
|
|
} while (r12);
|
|
}
|
|
const r16 = (0, env12443[44])(r5, "hcg");
|
|
if ((env12443[0][Object.prototype.toString.call(r16)] || "object") === "array" && r16.length === 3) {
|
|
return "hcg";
|
|
}
|
|
}
|
|
});
|
|
env12443[48] = unpack;
|
|
env12443[49] = last;
|
|
env12443[50] = Math.round;
|
|
const rgb2hex_1 = function rgb2hex_1() {
|
|
let r24;
|
|
const r14 = [];
|
|
const r22 = +arguments.length;
|
|
let r7 = r22 - 1;
|
|
if (r22) {
|
|
do {
|
|
r14[r7] = arguments[r7];
|
|
r24 = +r7;
|
|
r7 = r24 - 1;
|
|
} while (r24);
|
|
}
|
|
const r9 = (0, env12443[48])(r14, "rgba");
|
|
const r12 = r9[0];
|
|
const r11 = r9[1];
|
|
const r28 = r9[2];
|
|
let r29 = r9[3];
|
|
const r5 = r14.length < 2;
|
|
let r33 = null;
|
|
if (!r5) {
|
|
const r34 = r14.length - 1;
|
|
const r35 = env12443[2];
|
|
r33 = (env12443[0][Object.prototype.toString.call(r14[r34])] || "object") == "string" ? r14[r34].toLowerCase() : null;
|
|
}
|
|
if (!r33) {
|
|
r33 = "auto";
|
|
}
|
|
if (r29 === void 0) {
|
|
r29 = 1;
|
|
}
|
|
if (r33 === "auto") {
|
|
r33 = r29 < 1 ? "rgba" : "rgb";
|
|
}
|
|
const r52 = env12443[50];
|
|
const r63 = "000000" + (r52(r12) << 16 | r52(r11) << 8 | r52(r28)).toString(16);
|
|
const r68 = r63.substr(r63.length - 6);
|
|
const r75 = "0" + r52(255 * r29).toString(16);
|
|
const r79 = r75.substr(r75.length - 2);
|
|
const r81 = r33.toLowerCase();
|
|
if (r81 === "rgba") {
|
|
return "#" + r68 + r79;
|
|
}
|
|
if (r81 === "argb") {
|
|
return "#" + r79 + r68;
|
|
}
|
|
return "#" + r68;
|
|
};
|
|
env12443[51] = /^#?([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/;
|
|
env12443[52] = /^#?([A-Fa-f0-9]{8}|[A-Fa-f0-9]{4})$/;
|
|
const hex2rgb_1 = function hex2rgb_1(a0) {
|
|
if (a0.match(env12443[51])) {
|
|
const r74 = a0.length !== 4 && a0.length !== 7 ? a0 : a0.substr(1);
|
|
const length2 = r74.length;
|
|
let r79 = r74;
|
|
if (length2 === 3) {
|
|
const r82 = r74.split("");
|
|
r79 = r82[0] + r82[0] + r82[1] + r82[1] + r82[2] + r82[2];
|
|
}
|
|
const r97 = parseInt(r79, 16);
|
|
return [r97 >> 16, r97 >> 8 & 255, 255 & r97, 1];
|
|
}
|
|
if (a0.match(env12443[52])) {
|
|
const r9 = a0.length !== 5 && a0.length !== 9 ? a0 : a0.substr(1);
|
|
const length = r9.length;
|
|
let r30 = r9;
|
|
if (length === 4) {
|
|
const r33 = r9.split("");
|
|
r30 = r33[0] + r33[0] + r33[1] + r33[1] + r33[2] + r33[2] + r33[3] + r33[3];
|
|
}
|
|
const r52 = parseInt(r30, 16);
|
|
return [r52 >> 24 & 255, r52 >> 16 & 255, r52 >> 8 & 255, Math.round((255 & r52) / 255 * 100) / 100];
|
|
}
|
|
throw new Error("unknown hex color: " + a0);
|
|
};
|
|
env12443[53] = Color;
|
|
env12443[54] = type$p;
|
|
env12443[55] = rgb2hex_1;
|
|
Color.prototype.hex = function(a0) {
|
|
return (0, env12443[55])(this._rgb, a0);
|
|
};
|
|
chroma$k.hex = function() {
|
|
let r14;
|
|
const r7 = [];
|
|
const r12 = +arguments.length;
|
|
let r2 = r12 - 1;
|
|
if (r12) {
|
|
do {
|
|
r7[r2] = arguments[r2];
|
|
r14 = +r2;
|
|
r2 = r14 - 1;
|
|
} while (r14);
|
|
}
|
|
return new (Function.prototype.bind.apply(env12443[53], [null].concat(r7, ["hex"])))();
|
|
};
|
|
r39.format.hex = hex2rgb_1;
|
|
r39.autodetect.push({
|
|
p: 4,
|
|
test: function test(a0) {
|
|
let r14;
|
|
const r6 = [];
|
|
const r1 = arguments.length - 1;
|
|
let r0 = r1 - 1;
|
|
if (0 < r1) {
|
|
do {
|
|
r6[r0] = arguments[r0 + 1];
|
|
const r3 = r0 - 1;
|
|
r14 = r0;
|
|
r0 = r3;
|
|
} while (0 < r14);
|
|
}
|
|
if (!r6.length) {
|
|
if ((env12443[0][Object.prototype.toString.call(a0)] || "object") === "string" && [3, 4, 5, 6, 7, 8, 9].indexOf(a0.length) >= 0) {
|
|
return "hex";
|
|
}
|
|
}
|
|
}
|
|
});
|
|
env12443[56] = unpack;
|
|
env12443[57] = r35;
|
|
env12443[58] = Math.min;
|
|
env12443[59] = Math.sqrt;
|
|
env12443[60] = Math.acos;
|
|
env12443[61] = unpack;
|
|
env12443[62] = limit$2;
|
|
env12443[63] = r35;
|
|
env12443[64] = r5;
|
|
env12443[65] = Math.cos;
|
|
env12443[66] = unpack;
|
|
env12443[67] = type$p;
|
|
env12443[68] = Color;
|
|
env12443[69] = function rgb2hsi_1() {
|
|
let r18;
|
|
const r13 = [];
|
|
const r16 = +arguments.length;
|
|
let r11 = r16 - 1;
|
|
if (r16) {
|
|
do {
|
|
r13[r11] = arguments[r11];
|
|
r18 = +r11;
|
|
r11 = r18 - 1;
|
|
} while (r18);
|
|
}
|
|
const r22 = (0, env12443[56])(r13, "rgb");
|
|
const r14 = r22[0];
|
|
const r23 = r22[1];
|
|
const r24 = r22[2];
|
|
const r25 = env12443[58];
|
|
const r0 = r14 / 255;
|
|
const r7 = r23 / 255;
|
|
const r5 = r24 / 255;
|
|
const r26 = r25(r0, r7, r5);
|
|
const r29 = (r0 + r7 + r5) / 3;
|
|
const r30 = 0 < r29 ? 1 - r26 / r29 : 0;
|
|
let r31 = NaN;
|
|
if (r30 !== 0) {
|
|
const r32 = r0 - r7;
|
|
const r33 = r0 - r5;
|
|
const r44 = (0, env12443[60])((r32 + r33) / 2 / env12443[59](r32 * r32 + r33 * (r7 - r5)));
|
|
r31 = (r7 < r5 ? env12443[57] - r44 : r44) / env12443[57];
|
|
}
|
|
return [360 * r31, r30, r29];
|
|
};
|
|
Color.prototype.hsi = function() {
|
|
return (0, env12443[69])(this._rgb);
|
|
};
|
|
chroma$k.hsi = function() {
|
|
let r14;
|
|
const r7 = [];
|
|
const r12 = +arguments.length;
|
|
let r2 = r12 - 1;
|
|
if (r12) {
|
|
do {
|
|
r7[r2] = arguments[r2];
|
|
r14 = +r2;
|
|
r2 = r14 - 1;
|
|
} while (r14);
|
|
}
|
|
return new (Function.prototype.bind.apply(env12443[68], [null].concat(r7, ["hsi"])))();
|
|
};
|
|
r39.format.hsi = function hsi2rgb_1() {
|
|
let r23, r36, r47, r49;
|
|
const r14 = [];
|
|
const r21 = +arguments.length;
|
|
let r12 = r21 - 1;
|
|
if (r21) {
|
|
do {
|
|
r14[r12] = arguments[r12];
|
|
r23 = +r12;
|
|
r12 = r23 - 1;
|
|
} while (r23);
|
|
}
|
|
const r27 = (0, env12443[61])(r14, "hsi");
|
|
let r28 = r27[0];
|
|
let r16 = r27[1];
|
|
const r29 = r27[2];
|
|
if (isNaN(r28)) {
|
|
r28 = 0;
|
|
}
|
|
if (isNaN(r16)) {
|
|
r16 = 0;
|
|
}
|
|
let r33 = r28;
|
|
if (r33 > 360) {
|
|
r33 = r28 - 360;
|
|
}
|
|
let r34 = r33;
|
|
if (r34 < 0) {
|
|
r34 = r33 + 360;
|
|
}
|
|
const r2 = r34 / 360;
|
|
if (r2 < 0.3333333333333333) {
|
|
const r68 = (1 - r16) / 3;
|
|
const r69 = env12443[65];
|
|
const r71 = env12443[63] * r2;
|
|
const r79 = (1 + r16 * r69(r71) / r69(env12443[64] - r71)) / 3;
|
|
r36 = 1 - (r68 + r79);
|
|
r47 = r68;
|
|
r49 = r79;
|
|
} else if (r2 < 0.6666666666666666) {
|
|
const r51 = (1 - r16) / 3;
|
|
const r52 = env12443[65];
|
|
const r55 = env12443[63] * (r2 - 0.3333333333333333);
|
|
const r63 = (1 + r16 * r52(r55) / r52(env12443[64] - r55)) / 3;
|
|
r47 = 1 - (r51 + r63);
|
|
r36 = r63;
|
|
r49 = r51;
|
|
} else {
|
|
r36 = (1 - r16) / 3;
|
|
const r37 = env12443[65];
|
|
const r39 = env12443[63] * (r2 - 0.6666666666666666);
|
|
r47 = (1 + r16 * r37(r39) / r37(env12443[64] - r39)) / 3;
|
|
r49 = 1 - (r36 + r47);
|
|
}
|
|
const r81 = env12443[62];
|
|
let r85 = r29 * r49 * 3;
|
|
let r86 = 0;
|
|
if (!(r85 < 0)) {
|
|
if (1 < r85) {
|
|
r85 = 1;
|
|
}
|
|
r86 = r85;
|
|
}
|
|
const r90 = [255 * r86, , , ,];
|
|
let r94 = r29 * r36 * 3;
|
|
let r95 = 0;
|
|
if (!(r94 < 0)) {
|
|
if (1 < r94) {
|
|
r94 = 1;
|
|
}
|
|
r95 = r94;
|
|
}
|
|
r90[1] = 255 * r95;
|
|
let r101 = r29 * r47 * 3;
|
|
let r102 = 0;
|
|
if (!(r101 < 0)) {
|
|
if (1 < r101) {
|
|
r101 = 1;
|
|
}
|
|
r102 = r101;
|
|
}
|
|
r90[2] = 255 * r102;
|
|
r90[3] = r27.length > 3 ? r27[3] : 1;
|
|
return r90;
|
|
};
|
|
r39.autodetect.push({
|
|
p: 2,
|
|
test: function test() {
|
|
let r12;
|
|
const r5 = [];
|
|
const r10 = +arguments.length;
|
|
let r3 = r10 - 1;
|
|
if (r10) {
|
|
do {
|
|
r5[r3] = arguments[r3];
|
|
r12 = +r3;
|
|
r3 = r12 - 1;
|
|
} while (r12);
|
|
}
|
|
const r16 = (0, env12443[66])(r5, "hsi");
|
|
if ((env12443[0][Object.prototype.toString.call(r16)] || "object") === "array" && r16.length === 3) {
|
|
return "hsi";
|
|
}
|
|
}
|
|
});
|
|
env12443[70] = unpack;
|
|
env12443[71] = type$p;
|
|
env12443[72] = Color;
|
|
env12443[73] = rgb2hsl_1;
|
|
Color.prototype.hsl = function() {
|
|
return (0, env12443[73])(this._rgb);
|
|
};
|
|
chroma$k.hsl = function() {
|
|
let r14;
|
|
const r7 = [];
|
|
const r12 = +arguments.length;
|
|
let r2 = r12 - 1;
|
|
if (r12) {
|
|
do {
|
|
r7[r2] = arguments[r2];
|
|
r14 = +r2;
|
|
r2 = r14 - 1;
|
|
} while (r14);
|
|
}
|
|
return new (Function.prototype.bind.apply(env12443[72], [null].concat(r7, ["hsl"])))();
|
|
};
|
|
r39.format.hsl = hsl2rgb_1;
|
|
r39.autodetect.push({
|
|
p: 2,
|
|
test: function test() {
|
|
let r12;
|
|
const r5 = [];
|
|
const r10 = +arguments.length;
|
|
let r3 = r10 - 1;
|
|
if (r10) {
|
|
do {
|
|
r5[r3] = arguments[r3];
|
|
r12 = +r3;
|
|
r3 = r12 - 1;
|
|
} while (r12);
|
|
}
|
|
const r16 = (0, env12443[70])(r5, "hsl");
|
|
if ((env12443[0][Object.prototype.toString.call(r16)] || "object") === "array" && r16.length === 3) {
|
|
return "hsl";
|
|
}
|
|
}
|
|
});
|
|
env12443[74] = unpack;
|
|
env12443[75] = Math.min;
|
|
env12443[76] = Math.max;
|
|
env12443[77] = unpack;
|
|
env12443[78] = Math.floor;
|
|
env12443[79] = unpack;
|
|
env12443[80] = type$p;
|
|
env12443[81] = Color;
|
|
env12443[82] = function rgb2hsv$1() {
|
|
let r16, r35, NaN2;
|
|
const r8 = [];
|
|
const r14 = +arguments.length;
|
|
let r6 = r14 - 1;
|
|
if (r14) {
|
|
do {
|
|
r8[r6] = arguments[r6];
|
|
r16 = +r6;
|
|
r6 = r16 - 1;
|
|
} while (r16);
|
|
}
|
|
const r20 = (0, env12443[74])(r8, "rgb");
|
|
const r9 = r20[0];
|
|
const r21 = r20[1];
|
|
const r11 = r20[2];
|
|
const r23 = (0, env12443[75])(r9, r21, r11);
|
|
const r10 = (0, env12443[76])(r9, r21, r11);
|
|
const r25 = r10 - r23;
|
|
const r26 = r10 / 255;
|
|
if (r10 === 0) {
|
|
NaN2 = Number.NaN;
|
|
r35 = 0;
|
|
} else {
|
|
const r27 = r25 / r10;
|
|
let r28 = r9 === r10 ? (r21 - r11) / r25 : void 0;
|
|
if (r21 === r10) {
|
|
r28 = 2 + (r11 - r9) / r25;
|
|
}
|
|
if (r11 === r10) {
|
|
r28 = 4 + (r9 - r21) / r25;
|
|
}
|
|
const r1 = r28 * 60;
|
|
r35 = r27;
|
|
NaN2 = r1;
|
|
if (NaN2 < 0) {
|
|
NaN2 = r1 + 360;
|
|
r35 = r27;
|
|
}
|
|
}
|
|
return [NaN2, r35, r26];
|
|
};
|
|
Color.prototype.hsv = function() {
|
|
return (0, env12443[82])(this._rgb);
|
|
};
|
|
chroma$k.hsv = function() {
|
|
let r14;
|
|
const r7 = [];
|
|
const r12 = +arguments.length;
|
|
let r2 = r12 - 1;
|
|
if (r12) {
|
|
do {
|
|
r7[r2] = arguments[r2];
|
|
r14 = +r2;
|
|
r2 = r14 - 1;
|
|
} while (r14);
|
|
}
|
|
return new (Function.prototype.bind.apply(env12443[81], [null].concat(r7, ["hsv"])))();
|
|
};
|
|
r39.format.hsv = function hsv2rgb_1() {
|
|
let r18;
|
|
const r10 = [];
|
|
const r16 = +arguments.length;
|
|
let r8 = r16 - 1;
|
|
if (r16) {
|
|
do {
|
|
r10[r8] = arguments[r8];
|
|
r18 = +r8;
|
|
r8 = r18 - 1;
|
|
} while (r18);
|
|
}
|
|
const r22 = (0, env12443[77])(r10, "hsv");
|
|
let r13 = r22[0];
|
|
const r12 = r22[1];
|
|
const r4 = r22[2] * 255;
|
|
let r24 = r4;
|
|
let r25 = r24;
|
|
let r11 = r25;
|
|
if (r12 !== 0) {
|
|
if (r13 === 360) {
|
|
r13 = 0;
|
|
}
|
|
let r14 = r13;
|
|
if (r14 > 360) {
|
|
r14 = r13 - 360;
|
|
}
|
|
let r27 = r14;
|
|
if (r27 < 0) {
|
|
r27 = r14 + 360;
|
|
}
|
|
const r28 = env12443[78];
|
|
const r30 = r27 / 60;
|
|
const r31 = r28(r30);
|
|
const r1 = r30 - r31;
|
|
const r32 = 1 - r12;
|
|
const r3 = r12 * r1;
|
|
const r34 = r12 * (1 - r1);
|
|
const r35 = r4 * r32;
|
|
const r37 = r4 * (1 - r34);
|
|
if (r31 === 0) {
|
|
const r49 = [r4, r37, r35];
|
|
r11 = r49[0];
|
|
r25 = r49[1];
|
|
r24 = r49[2];
|
|
} else {
|
|
const r39 = r4 * (1 - r3);
|
|
if (r31 === 1) {
|
|
const r48 = [r39, r4, r35];
|
|
r11 = r48[0];
|
|
r25 = r48[1];
|
|
r24 = r48[2];
|
|
} else if (r31 === 2) {
|
|
const r47 = [r35, r4, r37];
|
|
r11 = r47[0];
|
|
r25 = r47[1];
|
|
r24 = r47[2];
|
|
} else if (r31 === 3) {
|
|
const r46 = [r35, r39, r4];
|
|
r11 = r46[0];
|
|
r25 = r46[1];
|
|
r24 = r46[2];
|
|
} else if (r31 === 4) {
|
|
const r45 = [r37, r35, r4];
|
|
r11 = r45[0];
|
|
r25 = r45[1];
|
|
r24 = r45[2];
|
|
} else {
|
|
r24 = void 0;
|
|
r25 = void 0;
|
|
r11 = void 0;
|
|
if (r31 === 5) {
|
|
const r44 = [r4, r35, r39];
|
|
r11 = r44[0];
|
|
r25 = r44[1];
|
|
r24 = r44[2];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return [r11, r25, r24, r22.length > 3 ? r22[3] : 1];
|
|
};
|
|
r39.autodetect.push({
|
|
p: 2,
|
|
test: function test() {
|
|
let r12;
|
|
const r5 = [];
|
|
const r10 = +arguments.length;
|
|
let r3 = r10 - 1;
|
|
if (r10) {
|
|
do {
|
|
r5[r3] = arguments[r3];
|
|
r12 = +r3;
|
|
r3 = r12 - 1;
|
|
} while (r12);
|
|
}
|
|
const r16 = (0, env12443[79])(r5, "hsv");
|
|
if ((env12443[0][Object.prototype.toString.call(r16)] || "object") === "array" && r16.length === 3) {
|
|
return "hsv";
|
|
}
|
|
}
|
|
});
|
|
const r160 = {
|
|
Kn: 18,
|
|
Xn: 0.95047,
|
|
Yn: 1,
|
|
Zn: 1.08883,
|
|
t0: 0.137931034,
|
|
t1: 0.206896552,
|
|
t2: 0.12841855,
|
|
t3: 0.008856452
|
|
};
|
|
env12443[83] = r160;
|
|
env12443[84] = unpack;
|
|
env12443[85] = Math.pow;
|
|
env12443[86] = function rgb_xyz(a0) {};
|
|
env12443[87] = function xyz_lab(a0) {};
|
|
env12443[88] = function rgb2xyz(a0, a1, a2) {};
|
|
const rgb2lab_1 = function rgb2lab_1() {
|
|
let r22;
|
|
const r11 = [];
|
|
const r20 = +arguments.length;
|
|
let r9 = r20 - 1;
|
|
if (r20) {
|
|
do {
|
|
r11[r9] = arguments[r9];
|
|
r22 = +r9;
|
|
r9 = r22 - 1;
|
|
} while (r22);
|
|
}
|
|
const r26 = (0, env12443[84])(r11, "rgb");
|
|
const r12 = r26[0];
|
|
const r27 = r26[1];
|
|
const r28 = r26[2];
|
|
const r31 = env12443[86];
|
|
const r4 = r12 / 255;
|
|
const r14 = r4 <= 0.04045 ? r4 / 12.92 : (0, env12443[85])((r4 + 0.055) / 1.055, 2.4);
|
|
const r39 = r27 / 255;
|
|
const r46 = r39 <= 0.04045 ? r39 / 12.92 : (0, env12443[85])((r39 + 0.055) / 1.055, 2.4);
|
|
const r50 = r28 / 255;
|
|
const r57 = r50 <= 0.04045 ? r50 / 12.92 : (0, env12443[85])((r50 + 0.055) / 1.055, 2.4);
|
|
const r59 = env12443[87];
|
|
const r61 = 0.4124564 * r14;
|
|
const r63 = 0.3575761 * r46;
|
|
const r65 = 0.1804375 * r57;
|
|
const r66 = env12443[83];
|
|
const r70 = (r61 + r63 + r65) / r66.Xn;
|
|
const r79 = [r70 > r66.t3 ? (0, env12443[85])(r70, 0.3333333333333333) : r70 / r66.t2 + r66.t0, , ,];
|
|
const r89 = (0.2126729 * r14 + 0.7151522 * r46 + 0.072175 * r57) / r66.Yn;
|
|
r79[1] = r89 > r66.t3 ? (0, env12443[85])(r89, 0.3333333333333333) : r89 / r66.t2 + r66.t0;
|
|
const r107 = (0.0193339 * r14 + 0.119192 * r46 + 0.9503041 * r57) / r66.Zn;
|
|
r79[2] = r107 > r66.t3 ? (0, env12443[85])(r107, 0.3333333333333333) : r107 / r66.t2 + r66.t0;
|
|
const r117 = r79[0];
|
|
const r118 = r79[1];
|
|
const r122 = 116 * r118 - 16;
|
|
return [r122 < 0 ? 0 : r122, 500 * (r117 - r118), 200 * (r118 - r79[2])];
|
|
};
|
|
env12443[89] = r160;
|
|
env12443[90] = unpack;
|
|
env12443[91] = Math.pow;
|
|
env12443[92] = function xyz_rgb(a0) {};
|
|
env12443[93] = function lab_xyz(a0) {};
|
|
const lab2rgb_1 = function lab2rgb_1() {
|
|
let r21;
|
|
const r12 = [];
|
|
const r19 = +arguments.length;
|
|
let r10 = r19 - 1;
|
|
if (r19) {
|
|
do {
|
|
r12[r10] = arguments[r10];
|
|
r21 = +r10;
|
|
r10 = r21 - 1;
|
|
} while (r21);
|
|
}
|
|
const r25 = (0, env12443[90])(r12, "lab");
|
|
const r26 = r25[0];
|
|
const r13 = r25[1];
|
|
const r27 = r25[2];
|
|
const r4 = (r26 + 16) / 116;
|
|
const r2 = isNaN(r13) ? r4 : r4 + r13 / 500;
|
|
const r1 = isNaN(r27) ? r4 : r4 - r27 / 200;
|
|
const r39 = env12443[89];
|
|
const Yn = r39.Yn;
|
|
const r41 = env12443[93];
|
|
const r6 = Yn * (r4 > r39.t1 ? r4 * r4 * r4 : r39.t2 * (r4 - r39.t0));
|
|
const r56 = r39.Xn * (r2 > r39.t1 ? r2 * r2 * r2 : r39.t2 * (r2 - r39.t0));
|
|
const r66 = r39.Zn * (r1 > r39.t1 ? r1 * r1 * r1 : r39.t2 * (r1 - r39.t0));
|
|
const r67 = env12443[92];
|
|
const r5 = 3.2404542 * r56 - 1.5371385 * r6 - 0.4985314 * r66;
|
|
const r88 = [255 * (r5 <= 0.00304 ? 12.92 * r5 : 1.055 * (0, env12443[91])(r5, 0.4166666666666667) - 0.055), , , ,];
|
|
const r7 = -0.969266 * r56 + 1.8760108 * r6 + 0.041556 * r66;
|
|
r88[1] = 255 * (r7 <= 0.00304 ? 12.92 * r7 : 1.055 * (0, env12443[91])(r7, 0.4166666666666667) - 0.055);
|
|
const r116 = 0.0556434 * r56 - 0.2040259 * r6 + 1.0572252 * r66;
|
|
r88[2] = 255 * (r116 <= 0.00304 ? 12.92 * r116 : 1.055 * (0, env12443[91])(r116, 0.4166666666666667) - 0.055);
|
|
r88[3] = r25.length > 3 ? r25[3] : 1;
|
|
return r88;
|
|
};
|
|
env12443[94] = unpack;
|
|
env12443[95] = type$p;
|
|
env12443[96] = Color;
|
|
env12443[97] = rgb2lab_1;
|
|
Color.prototype.lab = function() {
|
|
return (0, env12443[97])(this._rgb);
|
|
};
|
|
chroma$k.lab = function() {
|
|
let r14;
|
|
const r7 = [];
|
|
const r12 = +arguments.length;
|
|
let r2 = r12 - 1;
|
|
if (r12) {
|
|
do {
|
|
r7[r2] = arguments[r2];
|
|
r14 = +r2;
|
|
r2 = r14 - 1;
|
|
} while (r14);
|
|
}
|
|
return new (Function.prototype.bind.apply(env12443[96], [null].concat(r7, ["lab"])))();
|
|
};
|
|
r39.format.lab = lab2rgb_1;
|
|
r39.autodetect.push({
|
|
p: 2,
|
|
test: function test() {
|
|
let r12;
|
|
const r5 = [];
|
|
const r10 = +arguments.length;
|
|
let r3 = r10 - 1;
|
|
if (r10) {
|
|
do {
|
|
r5[r3] = arguments[r3];
|
|
r12 = +r3;
|
|
r3 = r12 - 1;
|
|
} while (r12);
|
|
}
|
|
const r16 = (0, env12443[94])(r5, "lab");
|
|
if ((env12443[0][Object.prototype.toString.call(r16)] || "object") === "array" && r16.length === 3) {
|
|
return "lab";
|
|
}
|
|
}
|
|
});
|
|
env12443[98] = unpack;
|
|
env12443[99] = r37;
|
|
env12443[100] = Math.sqrt;
|
|
env12443[101] = Math.atan2;
|
|
env12443[102] = Math.round;
|
|
const lab2lch_1 = function lab2lch_1() {
|
|
let r15;
|
|
const r8 = [];
|
|
const r13 = +arguments.length;
|
|
let r6 = r13 - 1;
|
|
if (r13) {
|
|
do {
|
|
r8[r6] = arguments[r6];
|
|
r15 = +r6;
|
|
r6 = r15 - 1;
|
|
} while (r15);
|
|
}
|
|
const r19 = (0, env12443[98])(r8, "lab");
|
|
const r20 = r19[0];
|
|
const r10 = r19[1];
|
|
const r9 = r19[2];
|
|
const r24 = (0, env12443[100])(r10 * r10 + r9 * r9);
|
|
let r28 = ((0, env12443[101])(r9, r10) * env12443[99] + 360) % 360;
|
|
if ((0, env12443[102])(10000 * r24) === 0) {
|
|
r28 = Number.NaN;
|
|
}
|
|
return [r20, r24, r28];
|
|
};
|
|
env12443[103] = unpack;
|
|
env12443[104] = rgb2lab_1;
|
|
env12443[105] = lab2lch_1;
|
|
env12443[106] = unpack;
|
|
env12443[107] = r36;
|
|
env12443[108] = Math.sin;
|
|
env12443[109] = Math.cos;
|
|
const lch2lab_1 = function lch2lab_1() {
|
|
let r11;
|
|
const r6 = [];
|
|
const r9 = +arguments.length;
|
|
let r4 = r9 - 1;
|
|
if (r9) {
|
|
do {
|
|
r6[r4] = arguments[r4];
|
|
r11 = +r4;
|
|
r4 = r11 - 1;
|
|
} while (r11);
|
|
}
|
|
const r15 = (0, env12443[106])(r6, "lch");
|
|
const r16 = r15[0];
|
|
const r17 = r15[1];
|
|
let r7 = r15[2];
|
|
if (isNaN(r7)) {
|
|
r7 = 0;
|
|
}
|
|
const r22 = env12443[109];
|
|
const r23 = r7 * env12443[107];
|
|
return [r16, r22(r23) * r17, (0, env12443[108])(r23) * r17];
|
|
};
|
|
env12443[110] = unpack;
|
|
env12443[111] = lch2lab_1;
|
|
env12443[112] = lab2rgb_1;
|
|
const lch2rgb_1 = function lch2rgb_1() {
|
|
let r11;
|
|
const r5 = [];
|
|
const r9 = +arguments.length;
|
|
let r3 = r9 - 1;
|
|
if (r9) {
|
|
do {
|
|
r5[r3] = arguments[r3];
|
|
r11 = +r3;
|
|
r3 = r11 - 1;
|
|
} while (r11);
|
|
}
|
|
const r15 = (0, env12443[110])(r5, "lch");
|
|
const r18 = (0, env12443[111])(r15[0], r15[1], r15[2]);
|
|
const r23 = (0, env12443[112])(r18[0], r18[1], r18[2]);
|
|
return [r23[0], r23[1], r23[2], r15.length > 3 ? r15[3] : 1];
|
|
};
|
|
env12443[113] = unpack;
|
|
env12443[114] = lch2rgb_1;
|
|
env12443[115] = unpack;
|
|
env12443[116] = type$p;
|
|
env12443[117] = Color;
|
|
env12443[118] = r39;
|
|
env12443[119] = function rgb2lch_1() {
|
|
let r10;
|
|
const r5 = [];
|
|
const r8 = +arguments.length;
|
|
let r3 = r8 - 1;
|
|
if (r8) {
|
|
do {
|
|
r5[r3] = arguments[r3];
|
|
r10 = +r3;
|
|
r3 = r10 - 1;
|
|
} while (r10);
|
|
}
|
|
const r14 = (0, env12443[103])(r5, "rgb");
|
|
const r18 = (0, env12443[104])(r14[0], r14[1], r14[2]);
|
|
return (0, env12443[105])(r18[0], r18[1], r18[2]);
|
|
};
|
|
Color.prototype.lch = function() {
|
|
return (0, env12443[119])(this._rgb);
|
|
};
|
|
Color.prototype.hcl = function() {
|
|
return (0, env12443[119])(this._rgb).reverse();
|
|
};
|
|
chroma$k.lch = function() {
|
|
let r14;
|
|
const r7 = [];
|
|
const r12 = +arguments.length;
|
|
let r2 = r12 - 1;
|
|
if (r12) {
|
|
do {
|
|
r7[r2] = arguments[r2];
|
|
r14 = +r2;
|
|
r2 = r14 - 1;
|
|
} while (r14);
|
|
}
|
|
return new (Function.prototype.bind.apply(env12443[117], [null].concat(r7, ["lch"])))();
|
|
};
|
|
chroma$k.hcl = function() {
|
|
let r14;
|
|
const r7 = [];
|
|
const r12 = +arguments.length;
|
|
let r2 = r12 - 1;
|
|
if (r12) {
|
|
do {
|
|
r7[r2] = arguments[r2];
|
|
r14 = +r2;
|
|
r2 = r14 - 1;
|
|
} while (r14);
|
|
}
|
|
return new (Function.prototype.bind.apply(env12443[117], [null].concat(r7, ["hcl"])))();
|
|
};
|
|
r39.format.lch = lch2rgb_1;
|
|
r39.format.hcl = function hcl2rgb_1() {
|
|
let r9;
|
|
const r5 = [];
|
|
const r7 = +arguments.length;
|
|
let r3 = r7 - 1;
|
|
if (r7) {
|
|
do {
|
|
r5[r3] = arguments[r3];
|
|
r9 = +r3;
|
|
r3 = r9 - 1;
|
|
} while (r9);
|
|
}
|
|
return env12443[114].apply(void 0, (0, env12443[113])(r5, "hcl").reverse());
|
|
};
|
|
["lch", "hcl"].forEach(function(c23826_0) {
|
|
return env12443[118].autodetect.push({
|
|
p: 2,
|
|
test: function test() {
|
|
let r12;
|
|
const r5 = [];
|
|
const r10 = +arguments.length;
|
|
let r3 = r10 - 1;
|
|
if (r10) {
|
|
do {
|
|
r5[r3] = arguments[r3];
|
|
r12 = +r3;
|
|
r3 = r12 - 1;
|
|
} while (r12);
|
|
}
|
|
const r15 = env12443[115];
|
|
const r17 = r15(r5, c23826_0);
|
|
if ((env12443[0][Object.prototype.toString.call(r17)] || "object") === "array" && r17.length === 3) {
|
|
return c23826_0;
|
|
}
|
|
}
|
|
});
|
|
});
|
|
const colors = {
|
|
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",
|
|
cornflower: "#6495ed",
|
|
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"
|
|
};
|
|
env12443[120] = type$p;
|
|
env12443[121] = colors;
|
|
env12443[122] = hex2rgb_1;
|
|
env12443[123] = rgb2hex_1;
|
|
Color.prototype.name = function() {
|
|
const r10 = (0, env12443[123])(this._rgb, "rgb");
|
|
const r14 = Object.keys(env12443[121]);
|
|
const length = r14.length;
|
|
let r0 = 0;
|
|
if (0 < length) {
|
|
do {
|
|
const r17 = r14[r0];
|
|
const r19 = env12443[121][r17];
|
|
const r1 = r0;
|
|
if (r19 === r10) {
|
|
return r17.toLowerCase();
|
|
}
|
|
r0 = r1 + 1;
|
|
} while (r0 < r14.length);
|
|
}
|
|
return r10;
|
|
};
|
|
r39.format.named = function(a0) {
|
|
const r9 = a0.toLowerCase();
|
|
const r10 = env12443[121];
|
|
if (r10[r9]) {
|
|
return (0, env12443[122])(r10[r9]);
|
|
}
|
|
throw new Error("unknown color name: " + r9);
|
|
};
|
|
r39.autodetect.push({
|
|
p: 5,
|
|
test: function test(a0) {
|
|
let r15;
|
|
const r6 = [];
|
|
const r1 = arguments.length - 1;
|
|
let r0 = r1 - 1;
|
|
if (0 < r1) {
|
|
do {
|
|
r6[r0] = arguments[r0 + 1];
|
|
const r3 = r0 - 1;
|
|
r15 = r0;
|
|
r0 = r3;
|
|
} while (0 < r15);
|
|
}
|
|
if (!r6.length) {
|
|
if ((env12443[0][Object.prototype.toString.call(a0)] || "object") === "string" && env12443[121][a0.toLowerCase()]) {
|
|
return "named";
|
|
}
|
|
}
|
|
}
|
|
});
|
|
env12443[124] = unpack;
|
|
env12443[125] = type$p;
|
|
env12443[126] = Color;
|
|
env12443[127] = type$p;
|
|
env12443[128] = function rgb2num_1() {
|
|
let r10;
|
|
const r5 = [];
|
|
const r8 = +arguments.length;
|
|
let r4 = r8 - 1;
|
|
if (r8) {
|
|
do {
|
|
r5[r4] = arguments[r4];
|
|
r10 = +r4;
|
|
r4 = r10 - 1;
|
|
} while (r10);
|
|
}
|
|
const r14 = (0, env12443[124])(r5, "rgb");
|
|
return (r14[0] << 16) + (r14[1] << 8) + r14[2];
|
|
};
|
|
Color.prototype.num = function() {
|
|
return (0, env12443[128])(this._rgb);
|
|
};
|
|
chroma$k.num = function() {
|
|
let r14;
|
|
const r7 = [];
|
|
const r12 = +arguments.length;
|
|
let r2 = r12 - 1;
|
|
if (r12) {
|
|
do {
|
|
r7[r2] = arguments[r2];
|
|
r14 = +r2;
|
|
r2 = r14 - 1;
|
|
} while (r14);
|
|
}
|
|
return new (Function.prototype.bind.apply(env12443[126], [null].concat(r7, ["num"])))();
|
|
};
|
|
r39.format.num = function num2rgb_1(a0) {
|
|
if ((env12443[0][Object.prototype.toString.call(a0)] || "object") == "number" && a0 >= 0 && a0 <= 16777215) {
|
|
return [a0 >> 16, a0 >> 8 & 255, 255 & a0, 1];
|
|
}
|
|
throw new Error("unknown num color: " + a0);
|
|
};
|
|
r39.autodetect.push({
|
|
p: 5,
|
|
test: function test() {
|
|
let r11;
|
|
const r2 = [];
|
|
const r9 = +arguments.length;
|
|
let r4 = r9 - 1;
|
|
if (r9) {
|
|
do {
|
|
r2[r4] = arguments[r4];
|
|
r11 = +r4;
|
|
r4 = r11 - 1;
|
|
} while (r11);
|
|
}
|
|
if (r2.length === 1) {
|
|
const r14 = env12443[127];
|
|
if ((env12443[0][Object.prototype.toString.call(r2[0])] || "object") === "number" && r2[0] >= 0 && r2[0] <= 16777215) {
|
|
return "num";
|
|
}
|
|
}
|
|
}
|
|
});
|
|
env12443[129] = Color;
|
|
env12443[130] = unpack;
|
|
env12443[131] = type$p;
|
|
env12443[132] = Math.round;
|
|
Color.prototype.rgb = function(a0) {
|
|
return (a0 === void 0 ? true : a0) === false ? this._rgb.slice(0, 3) : this._rgb.slice(0, 3).map(env12443[132]);
|
|
};
|
|
Color.prototype.rgba = function(a0) {
|
|
let c23827_0 = a0;
|
|
if (a0 === void 0) {
|
|
c23827_0 = true;
|
|
}
|
|
return this._rgb.slice(0, 4).map(function(item, index) {
|
|
return index < 3 ? c23827_0 !== false ? (0, env12443[132])(item) : item : item;
|
|
});
|
|
};
|
|
chroma$k.rgb = function() {
|
|
let r14;
|
|
const r7 = [];
|
|
const r12 = +arguments.length;
|
|
let r2 = r12 - 1;
|
|
if (r12) {
|
|
do {
|
|
r7[r2] = arguments[r2];
|
|
r14 = +r2;
|
|
r2 = r14 - 1;
|
|
} while (r14);
|
|
}
|
|
return new (Function.prototype.bind.apply(env12443[129], [null].concat(r7, ["rgb"])))();
|
|
};
|
|
r39.format.rgb = function() {
|
|
let r10;
|
|
const r5 = [];
|
|
const r8 = +arguments.length;
|
|
let r4 = r8 - 1;
|
|
if (r8) {
|
|
do {
|
|
r5[r4] = arguments[r4];
|
|
r10 = +r4;
|
|
r4 = r10 - 1;
|
|
} while (r10);
|
|
}
|
|
const r14 = (0, env12443[130])(r5, "rgba");
|
|
if (r14[3] === void 0) {
|
|
r14[3] = 1;
|
|
}
|
|
return r14;
|
|
};
|
|
r39.autodetect.push({
|
|
p: 3,
|
|
test: function test() {
|
|
let r14;
|
|
const r6 = [];
|
|
const r12 = +arguments.length;
|
|
let r4 = r12 - 1;
|
|
if (r12) {
|
|
do {
|
|
r6[r4] = arguments[r4];
|
|
r14 = +r4;
|
|
r4 = r14 - 1;
|
|
} while (r14);
|
|
}
|
|
const r18 = (0, env12443[130])(r6, "rgba");
|
|
const r19 = env12443[131];
|
|
const r21 = env12443[0];
|
|
const r26 = r21[Object.prototype.toString.call(r18)] || "object";
|
|
L22: {
|
|
if (r26 === "array") {
|
|
if (r18.length !== 3) {
|
|
if (r18.length !== 4) {
|
|
break L22;
|
|
}
|
|
if ((r21[Object.prototype.toString.call(r18[3])] || "object") != "number") {
|
|
break L22;
|
|
}
|
|
if (!(r18[3] >= 0)) {
|
|
break L22;
|
|
}
|
|
if (!(r18[3] <= 1)) {
|
|
break L22;
|
|
}
|
|
}
|
|
return "rgb";
|
|
}
|
|
}
|
|
}
|
|
});
|
|
env12443[133] = Math.log;
|
|
const temperature2rgb_1 = function temperature2rgb_1(a0) {
|
|
let r21, r30, r31;
|
|
const r6 = a0 / 100;
|
|
if (r6 < 66) {
|
|
let r33 = 0;
|
|
if (!(r6 < 6)) {
|
|
const r9 = r6 - 2;
|
|
r33 = -155.25485562709179 - 0.44596950469579133 * r9 + 104.49216199393888 * (0, env12443[133])(r9);
|
|
}
|
|
let r4 = 0;
|
|
if (!(r6 < 20)) {
|
|
const r44 = r6 - 10;
|
|
r4 = 0.8274096064007395 * r44 - 254.76935184120902 + 115.67994401066147 * (0, env12443[133])(r44);
|
|
}
|
|
r21 = 255;
|
|
r31 = r4;
|
|
r30 = r33;
|
|
} else {
|
|
const r1 = r6 - 55;
|
|
const r16 = env12443[133];
|
|
r21 = 351.97690566805693 + 0.114206453784165 * r1 - 40.25366309332127 * r16(r1);
|
|
const r2 = r6 - 50;
|
|
r30 = 325.4494125711974 + 0.07943456536662342 * r2 - 28.0852963507957 * r16(r2);
|
|
r31 = 255;
|
|
}
|
|
return [r21, r30, r31, 1];
|
|
};
|
|
env12443[134] = temperature2rgb_1;
|
|
env12443[135] = unpack;
|
|
env12443[136] = Math.round;
|
|
env12443[137] = Color;
|
|
env12443[138] = function rgb2temperature_1() {
|
|
let r6, r48, r66, r67;
|
|
const r41 = [];
|
|
const r46 = +arguments.length;
|
|
let r39 = r46 - 1;
|
|
if (r46) {
|
|
do {
|
|
r41[r39] = arguments[r39];
|
|
r48 = +r39;
|
|
r39 = r48 - 1;
|
|
} while (r48);
|
|
}
|
|
const r52 = (0, env12443[135])(r41, "rgb");
|
|
const r53 = r52[0];
|
|
const r54 = r52[2];
|
|
let r8 = 40000;
|
|
let r9 = 1000;
|
|
while (true) {
|
|
const r55 = env12443[134];
|
|
let r4 = r8;
|
|
const r11 = r9;
|
|
const r57 = 0.5 * (r4 + r11);
|
|
const r2 = r57 / 100;
|
|
if (r2 < 66) {
|
|
let r5 = 0;
|
|
if (!(r2 < 6)) {
|
|
const r1 = r2 - 2;
|
|
r5 = -155.25485562709179 - 0.44596950469579133 * r1 + 104.49216199393888 * (0, env12443[133])(r1);
|
|
}
|
|
let r72 = 0;
|
|
if (!(r2 < 20)) {
|
|
const r73 = r2 - 10;
|
|
r72 = 0.8274096064007395 * r73 - 254.76935184120902 + 115.67994401066147 * (0, env12443[133])(r73);
|
|
}
|
|
r67 = r72;
|
|
r66 = r5;
|
|
r6 = 255;
|
|
} else {
|
|
const r0 = r2 - 55;
|
|
const r58 = env12443[133];
|
|
r6 = 351.97690566805693 + 0.114206453784165 * r0 - 40.25366309332127 * r58(r0);
|
|
const r61 = r2 - 50;
|
|
r66 = 325.4494125711974 + 0.07943456536662342 * r61 - 28.0852963507957 * r58(r61);
|
|
r67 = 255;
|
|
}
|
|
const r79 = [r6, r66, r67, 1];
|
|
const r82 = r79[2] / r79[0];
|
|
const r83 = r54 / r53;
|
|
let r84 = r57;
|
|
if (r82 >= r83) {
|
|
r4 = r57;
|
|
r84 = r11;
|
|
}
|
|
const r85 = r4 - r84;
|
|
r8 = r4;
|
|
r9 = r84;
|
|
if (!(0.4 < r85)) {
|
|
return (0, env12443[136])(r57);
|
|
}
|
|
}
|
|
};
|
|
const { prototype, prototype: prototype2, prototype: prototype3 } = Color;
|
|
const temperature = function() {
|
|
return (0, env12443[138])(this._rgb);
|
|
};
|
|
prototype3.temperature = temperature;
|
|
prototype2.kelvin = temperature;
|
|
prototype.temp = temperature;
|
|
const temperature2 = function() {
|
|
let r14;
|
|
const r7 = [];
|
|
const r12 = +arguments.length;
|
|
let r2 = r12 - 1;
|
|
if (r12) {
|
|
do {
|
|
r7[r2] = arguments[r2];
|
|
r14 = +r2;
|
|
r2 = r14 - 1;
|
|
} while (r14);
|
|
}
|
|
return new (Function.prototype.bind.apply(env12443[137], [null].concat(r7, ["temp"])))();
|
|
};
|
|
chroma$k.temperature = temperature2;
|
|
chroma$k.kelvin = temperature2;
|
|
chroma$k.temp = temperature2;
|
|
const { format, format: format2 } = r39;
|
|
r39.format.temperature = temperature2rgb_1;
|
|
format2.kelvin = temperature2rgb_1;
|
|
format.temp = temperature2rgb_1;
|
|
env12443[139] = unpack;
|
|
env12443[140] = Math.cbrt;
|
|
env12443[141] = Math.pow;
|
|
env12443[142] = Math.sign;
|
|
const rgb2oklab_1 = function rgb2oklab_1() {
|
|
let r16;
|
|
const r9 = [];
|
|
const r14 = +arguments.length;
|
|
let r7 = r14 - 1;
|
|
if (r14) {
|
|
do {
|
|
r9[r7] = arguments[r7];
|
|
r16 = +r7;
|
|
r7 = r16 - 1;
|
|
} while (r16);
|
|
}
|
|
const r20 = (0, env12443[139])(r9, "rgb");
|
|
const r21 = r20[0];
|
|
const r10 = r20[1];
|
|
const r22 = r20[2];
|
|
const r3 = r21 / 255;
|
|
const r12 = Math.abs(r3);
|
|
const r35 = [r12 < 0.04045 ? r3 / 12.92 : ((0, env12443[142])(r3) || 1) * (0, env12443[141])((r12 + 0.055) / 1.055, 2.4), , ,];
|
|
const r36 = r10 / 255;
|
|
const r39 = Math.abs(r36);
|
|
r35[1] = r39 < 0.04045 ? r36 / 12.92 : ((0, env12443[142])(r36) || 1) * (0, env12443[141])((r39 + 0.055) / 1.055, 2.4);
|
|
const r51 = r22 / 255;
|
|
const r54 = Math.abs(r51);
|
|
r35[2] = r54 < 0.04045 ? r51 / 12.92 : ((0, env12443[142])(r51) || 1) * (0, env12443[141])((r54 + 0.055) / 1.055, 2.4);
|
|
const r66 = r35[0];
|
|
const r67 = r35[1];
|
|
const r68 = r35[2];
|
|
const r69 = env12443[140];
|
|
const r78 = r69(0.4122214708 * r66 + 0.5363325363 * r67 + 0.0514459929 * r68);
|
|
const r87 = r69(0.2119034982 * r66 + 0.6806995451 * r67 + 0.1073969566 * r68);
|
|
const r96 = r69(0.0883024619 * r66 + 0.2817188376 * r67 + 0.6299787005 * r68);
|
|
return [0.2104542553 * r78 + 0.793617785 * r87 - 0.0040720468 * r96, 1.9779984951 * r78 - 2.428592205 * r87 + 0.4505937099 * r96, 0.0259040371 * r78 + 0.7827717662 * r87 - 0.808675766 * r96];
|
|
};
|
|
env12443[143] = unpack;
|
|
env12443[144] = Math.pow;
|
|
env12443[145] = Math.sign;
|
|
const oklab2rgb_1 = function oklab2rgb_1() {
|
|
let r20;
|
|
const r10 = [];
|
|
const r18 = +arguments.length;
|
|
let r8 = r18 - 1;
|
|
if (r18) {
|
|
do {
|
|
r10[r8] = arguments[r8];
|
|
r20 = +r8;
|
|
r8 = r20 - 1;
|
|
} while (r20);
|
|
}
|
|
const r24 = (0, env12443[143])(r10, "lab");
|
|
const r25 = r24[0];
|
|
const r12 = r24[1];
|
|
const r26 = r24[2];
|
|
const r11 = env12443[144];
|
|
const r14 = r11(r25 + 0.3963377774 * r12 + 0.2158037573 * r26, 3);
|
|
const r37 = r11(r25 - 0.1055613458 * r12 - 0.0638541728 * r26, 3);
|
|
const r44 = r11(r25 - 0.0894841775 * r12 - 1.291485548 * r26, 3);
|
|
const r51 = 4.0767416621 * r14 - 3.3077115913 * r37 + 0.2309699292 * r44;
|
|
const r54 = Math.abs(r51);
|
|
const r67 = [255 * (r54 > 0.0031308 ? ((0, env12443[145])(r51) || 1) * (1.055 * r11(r54, 0.4166666666666667) - 0.055) : 12.92 * r51), , , ,];
|
|
const r74 = -1.2684380046 * r14 + 2.6097574011 * r37 - 0.3413193965 * r44;
|
|
const r76 = Math.abs(r74);
|
|
r67[1] = 255 * (r76 > 0.0031308 ? ((0, env12443[145])(r74) || 1) * (1.055 * r11(r76, 0.4166666666666667) - 0.055) : 12.92 * r74);
|
|
const r95 = -0.0041960863 * r14 - 0.7034186147 * r37 + 1.707614701 * r44;
|
|
const r98 = Math.abs(r95);
|
|
r67[2] = 255 * (r98 > 0.0031308 ? ((0, env12443[145])(r95) || 1) * (1.055 * r11(r98, 0.4166666666666667) - 0.055) : 12.92 * r95);
|
|
r67[3] = r24.length > 3 ? r24[3] : 1;
|
|
return r67;
|
|
};
|
|
env12443[146] = unpack;
|
|
env12443[147] = type$p;
|
|
env12443[148] = Color;
|
|
env12443[149] = rgb2oklab_1;
|
|
Color.prototype.oklab = function() {
|
|
return (0, env12443[149])(this._rgb);
|
|
};
|
|
chroma$k.oklab = function() {
|
|
let r14;
|
|
const r7 = [];
|
|
const r12 = +arguments.length;
|
|
let r2 = r12 - 1;
|
|
if (r12) {
|
|
do {
|
|
r7[r2] = arguments[r2];
|
|
r14 = +r2;
|
|
r2 = r14 - 1;
|
|
} while (r14);
|
|
}
|
|
return new (Function.prototype.bind.apply(env12443[148], [null].concat(r7, ["oklab"])))();
|
|
};
|
|
r39.format.oklab = oklab2rgb_1;
|
|
r39.autodetect.push({
|
|
p: 3,
|
|
test: function test() {
|
|
let r12;
|
|
const r5 = [];
|
|
const r10 = +arguments.length;
|
|
let r3 = r10 - 1;
|
|
if (r10) {
|
|
do {
|
|
r5[r3] = arguments[r3];
|
|
r12 = +r3;
|
|
r3 = r12 - 1;
|
|
} while (r12);
|
|
}
|
|
const r16 = (0, env12443[146])(r5, "oklab");
|
|
if ((env12443[0][Object.prototype.toString.call(r16)] || "object") === "array" && r16.length === 3) {
|
|
return "oklab";
|
|
}
|
|
}
|
|
});
|
|
env12443[150] = unpack;
|
|
env12443[151] = rgb2oklab_1;
|
|
env12443[152] = lab2lch_1;
|
|
env12443[153] = unpack;
|
|
env12443[154] = lch2lab_1;
|
|
env12443[155] = oklab2rgb_1;
|
|
env12443[156] = unpack;
|
|
env12443[157] = type$p;
|
|
env12443[158] = Color;
|
|
env12443[159] = function rgb2oklch_1() {
|
|
let r10;
|
|
const r5 = [];
|
|
const r8 = +arguments.length;
|
|
let r3 = r8 - 1;
|
|
if (r8) {
|
|
do {
|
|
r5[r3] = arguments[r3];
|
|
r10 = +r3;
|
|
r3 = r10 - 1;
|
|
} while (r10);
|
|
}
|
|
const r14 = (0, env12443[150])(r5, "rgb");
|
|
const r18 = (0, env12443[151])(r14[0], r14[1], r14[2]);
|
|
return (0, env12443[152])(r18[0], r18[1], r18[2]);
|
|
};
|
|
Color.prototype.oklch = function() {
|
|
return (0, env12443[159])(this._rgb);
|
|
};
|
|
chroma$k.oklch = function() {
|
|
let r14;
|
|
const r7 = [];
|
|
const r12 = +arguments.length;
|
|
let r2 = r12 - 1;
|
|
if (r12) {
|
|
do {
|
|
r7[r2] = arguments[r2];
|
|
r14 = +r2;
|
|
r2 = r14 - 1;
|
|
} while (r14);
|
|
}
|
|
return new (Function.prototype.bind.apply(env12443[158], [null].concat(r7, ["oklch"])))();
|
|
};
|
|
r39.format.oklch = function oklch2rgb_1() {
|
|
let r11;
|
|
const r5 = [];
|
|
const r9 = +arguments.length;
|
|
let r3 = r9 - 1;
|
|
if (r9) {
|
|
do {
|
|
r5[r3] = arguments[r3];
|
|
r11 = +r3;
|
|
r3 = r11 - 1;
|
|
} while (r11);
|
|
}
|
|
const r15 = (0, env12443[153])(r5, "lch");
|
|
const r18 = (0, env12443[154])(r15[0], r15[1], r15[2]);
|
|
const r23 = (0, env12443[155])(r18[0], r18[1], r18[2]);
|
|
return [r23[0], r23[1], r23[2], r15.length > 3 ? r15[3] : 1];
|
|
};
|
|
r39.autodetect.push({
|
|
p: 3,
|
|
test: function test() {
|
|
let r12;
|
|
const r5 = [];
|
|
const r10 = +arguments.length;
|
|
let r3 = r10 - 1;
|
|
if (r10) {
|
|
do {
|
|
r5[r3] = arguments[r3];
|
|
r12 = +r3;
|
|
r3 = r12 - 1;
|
|
} while (r12);
|
|
}
|
|
const r16 = (0, env12443[156])(r5, "oklch");
|
|
if ((env12443[0][Object.prototype.toString.call(r16)] || "object") === "array" && r16.length === 3) {
|
|
return "oklch";
|
|
}
|
|
}
|
|
});
|
|
env12443[160] = Color;
|
|
env12443[161] = type$p;
|
|
Color.prototype.alpha = function(a0, a1) {
|
|
let r21, r33;
|
|
const r6 = a1 === void 0 ? false : a1;
|
|
if (a0 !== void 0) {
|
|
if ((env12443[0][Object.prototype.toString.call(a0)] || "object") === "number") {
|
|
if (r6) {
|
|
this._rgb[3] = a0;
|
|
r33 = this;
|
|
} else {
|
|
const r22 = env12443[160];
|
|
const r25 = [this._rgb[0], this._rgb[1], this._rgb[2], a0];
|
|
const r30 = Object.create(r22.prototype);
|
|
const r32 = r22.call(r30, r25, "rgb");
|
|
r33 = r32 instanceof Object ? r32 : r30;
|
|
}
|
|
r21 = r33;
|
|
} else {
|
|
r21 = this._rgb[3];
|
|
}
|
|
} else {
|
|
r21 = this._rgb[3];
|
|
}
|
|
return r21;
|
|
};
|
|
Color.prototype.clipped = function() {
|
|
return this._rgb._clipped || false;
|
|
};
|
|
env12443[162] = Color;
|
|
env12443[163] = r160;
|
|
Color.prototype.darken = function(a0) {
|
|
const r7 = a0 === void 0 ? 1 : a0;
|
|
const r6 = this.lab();
|
|
r6[0] = r6[0] - env12443[163].Kn * r7;
|
|
const r12 = env12443[162];
|
|
const r13 = Object.create(r12.prototype);
|
|
const r15 = r12.call(r13, r6, "lab");
|
|
return (r15 instanceof Object ? r15 : r13).alpha(this.alpha(), true);
|
|
};
|
|
Color.prototype.brighten = function(a0) {
|
|
return this.darken(-(a0 === void 0 ? 1 : a0));
|
|
};
|
|
Color.prototype.darker = Color.prototype.darken;
|
|
Color.prototype.brighter = Color.prototype.brighten;
|
|
Color.prototype.get = function(a0) {
|
|
const r11 = a0.split(".");
|
|
const r12 = r11[0];
|
|
const r6 = r11[1];
|
|
const r14 = this[r12]();
|
|
if (r6) {
|
|
const r19 = r12.indexOf(r6) - (r12.substr(0, 2) === "ok" ? 2 : 0);
|
|
if (-1 < r19) {
|
|
return r14[r19];
|
|
}
|
|
throw new Error("unknown channel " + r6 + " in mode " + r12);
|
|
}
|
|
return r14;
|
|
};
|
|
env12443[164] = Color;
|
|
env12443[165] = type$p;
|
|
env12443[166] = Math.pow;
|
|
Color.prototype.luminance = function(a0) {
|
|
let r54, r64, r82, r109;
|
|
let c23828_1, test2;
|
|
let c23828_0 = a0;
|
|
if (a0 !== void 0) {
|
|
if ((env12443[0][Object.prototype.toString.call(a0)] || "object") === "number") {
|
|
if (a0 === 0) {
|
|
const r145 = env12443[164];
|
|
const r148 = [0, 0, 0, this._rgb[3]];
|
|
const r149 = Object.create(r145.prototype);
|
|
const r151 = r145.call(r149, r148, "rgb");
|
|
return r151 instanceof Object ? r151 : r149;
|
|
}
|
|
if (a0 === 1) {
|
|
const r137 = env12443[164];
|
|
const r140 = [255, 255, 255, this._rgb[3]];
|
|
const r141 = Object.create(r137.prototype);
|
|
const r143 = r137.call(r141, r140, "rgb");
|
|
return r143 instanceof Object ? r143 : r141;
|
|
}
|
|
const r41 = this.luminance();
|
|
c23828_1 = 20;
|
|
test2 = function test(a0, a1) {
|
|
const r4 = a0.interpolate(a1, 0.5, "rgb");
|
|
const r7 = r4.luminance();
|
|
const r9 = Math;
|
|
const r14 = r9.abs(c23828_0 - r7);
|
|
let r16 = r4;
|
|
if (!(r14 < 1e-7)) {
|
|
const r18 = +c23828_1;
|
|
c23828_1 = r18 - 1;
|
|
r16 = r18 ? r7 > c23828_0 ? test2(a0, r4) : test2(r4, a1) : r4;
|
|
}
|
|
return r16;
|
|
};
|
|
if (r41 > a0) {
|
|
const r83 = env12443[164];
|
|
const r84 = Object.create(r83.prototype);
|
|
const r86 = r83.call(r84, [0, 0, 0]);
|
|
const r87 = r86 instanceof Object ? r86 : r84;
|
|
const r91 = r87.interpolate(this, 0.5, "rgb");
|
|
const r93 = r91.luminance();
|
|
const r97 = Math.abs(a0 - r93);
|
|
let r99 = r91;
|
|
if (!(r97 < 1e-7)) {
|
|
const r101 = +c23828_1;
|
|
c23828_1 = r101 - 1;
|
|
r99 = r91;
|
|
if (r101) {
|
|
if (r93 > a0) {
|
|
const r115 = r87.interpolate(r91, 0.5, "rgb");
|
|
const r117 = r115.luminance();
|
|
const r121 = Math.abs(a0 - r117);
|
|
let r122 = r115;
|
|
if (!(r121 < 1e-7)) {
|
|
const r124 = +c23828_1;
|
|
c23828_1 = r124 - 1;
|
|
r122 = r124 ? r117 > a0 ? test2(r87, r115) : test2(r115, r91) : r115;
|
|
}
|
|
r109 = r122;
|
|
} else {
|
|
const r104 = r91.interpolate(this, 0.5, "rgb");
|
|
const r106 = r104.luminance();
|
|
const r108 = Math.abs(a0 - r106);
|
|
r109 = r104;
|
|
if (!(r108 < 1e-7)) {
|
|
const r111 = +c23828_1;
|
|
c23828_1 = r111 - 1;
|
|
r109 = r111 ? r106 > a0 ? test2(r91, r104) : test2(r104, this) : r104;
|
|
}
|
|
}
|
|
r99 = r109;
|
|
}
|
|
}
|
|
r54 = r99;
|
|
r82 = r83;
|
|
} else {
|
|
const r43 = env12443[164];
|
|
const r44 = Object.create(r43.prototype);
|
|
const r46 = r43.call(r44, [255, 255, 255]);
|
|
const r47 = r46 instanceof Object ? r46 : r44;
|
|
const r10 = this.interpolate(r47, 0.5, "rgb");
|
|
const r50 = r10.luminance();
|
|
const r52 = Math.abs(a0 - r50);
|
|
r54 = r10;
|
|
if (!(r52 < 1e-7)) {
|
|
const r56 = +c23828_1;
|
|
c23828_1 = r56 - 1;
|
|
r54 = r10;
|
|
if (r56) {
|
|
if (r50 > a0) {
|
|
const r70 = this.interpolate(r10, 0.5, "rgb");
|
|
const r72 = r70.luminance();
|
|
const r76 = Math.abs(a0 - r72);
|
|
let r77 = r70;
|
|
if (!(r76 < 1e-7)) {
|
|
const r79 = +c23828_1;
|
|
c23828_1 = r79 - 1;
|
|
r77 = r79 ? r72 > a0 ? test2(this, r70) : test2(r70, r10) : r70;
|
|
}
|
|
r64 = r77;
|
|
} else {
|
|
const r59 = r10.interpolate(r47, 0.5, "rgb");
|
|
const r61 = r59.luminance();
|
|
const r63 = Math.abs(a0 - r61);
|
|
r64 = r59;
|
|
if (!(r63 < 1e-7)) {
|
|
const r66 = +c23828_1;
|
|
c23828_1 = r66 - 1;
|
|
r64 = r66 ? r61 > a0 ? test2(r10, r59) : test2(r59, r47) : r59;
|
|
}
|
|
}
|
|
r54 = r64;
|
|
}
|
|
}
|
|
r82 = r43;
|
|
}
|
|
return new r82(r54.rgb().concat([this._rgb[3]]));
|
|
}
|
|
}
|
|
return env12443[167].apply(void 0, this._rgb.slice(0, 3));
|
|
};
|
|
env12443[167] = function rgb2luminance(a0, a1, a2) {
|
|
const r9 = env12443[168];
|
|
const r4 = a0 / 255;
|
|
const r20 = 0.2126 * (r4 <= 0.03928 ? r4 / 12.92 : (0, env12443[166])((r4 + 0.055) / 1.055, 2.4));
|
|
const r24 = a1 / 255;
|
|
const r34 = 0.7152 * (r24 <= 0.03928 ? r24 / 12.92 : (0, env12443[166])((r24 + 0.055) / 1.055, 2.4));
|
|
const r38 = a2 / 255;
|
|
return r20 + r34 + 0.0722 * (r38 <= 0.03928 ? r38 / 12.92 : (0, env12443[166])((r38 + 0.055) / 1.055, 2.4));
|
|
};
|
|
env12443[168] = function luminance_x(a0) {};
|
|
const r310 = {};
|
|
env12443[169] = Color;
|
|
env12443[170] = type$p;
|
|
env12443[171] = r310;
|
|
const mix$1 = function mix$1(a0, a1, a2) {
|
|
let r26;
|
|
const r11 = a2 === void 0 ? 0.5 : a2;
|
|
const r12 = [];
|
|
const r1 = arguments.length - 3;
|
|
let r0 = r1 - 1;
|
|
if (0 < r1) {
|
|
do {
|
|
r12[r0] = arguments[r0 + 3];
|
|
const r2 = r0 - 1;
|
|
r26 = r0;
|
|
r0 = r2;
|
|
} while (0 < r26);
|
|
}
|
|
let r27 = r12[0] || "lrgb";
|
|
const r28 = env12443[171];
|
|
if (!(r28[r27] || r12.length)) {
|
|
r27 = Object.keys(r28)[0];
|
|
}
|
|
if (r28[r27]) {
|
|
const r40 = env12443[170];
|
|
const r43 = env12443[0];
|
|
const r16 = r43[Object.prototype.toString.call(a0)] || "object";
|
|
let r50 = a0;
|
|
if (r16 !== "object") {
|
|
const r51 = env12443[169];
|
|
const r17 = Object.create(r51.prototype);
|
|
const r52 = r51.call(r17, a0);
|
|
r50 = r52 instanceof Object ? r52 : r17;
|
|
}
|
|
const r61 = r43[Object.prototype.toString.call(a1)] || "object";
|
|
let r62 = a1;
|
|
if (r61 !== "object") {
|
|
const r63 = env12443[169];
|
|
const r64 = Object.create(r63.prototype);
|
|
const r65 = r63.call(r64, a1);
|
|
r62 = r65 instanceof Object ? r65 : r64;
|
|
}
|
|
return r28[r27](r50, r62, r11).alpha(r50.alpha() + r11 * (r62.alpha() - r50.alpha()));
|
|
}
|
|
throw new Error("interpolation mode " + r27 + " is not defined");
|
|
};
|
|
env12443[172] = mix$1;
|
|
const { prototype: prototype4, prototype: prototype5 } = Color;
|
|
const interpolate = function(a0, a1) {
|
|
let r17;
|
|
const r7 = a1 === void 0 ? 0.5 : a1;
|
|
const r11 = [];
|
|
const r1 = arguments.length - 2;
|
|
let r0 = r1 - 1;
|
|
if (0 < r1) {
|
|
do {
|
|
r11[r0] = arguments[r0 + 2];
|
|
const r2 = r0 - 1;
|
|
r17 = r0;
|
|
r0 = r2;
|
|
} while (0 < r17);
|
|
}
|
|
return env12443[172].apply(void 0, [this, a0, r7].concat(r11));
|
|
};
|
|
prototype5.interpolate = interpolate;
|
|
prototype4.mix = interpolate;
|
|
env12443[173] = Color;
|
|
Color.prototype.premultiply = function(a0) {
|
|
let r17;
|
|
const r1 = a0 === void 0 ? false : a0;
|
|
const _rgb = this._rgb;
|
|
const r4 = _rgb[3];
|
|
if (r1) {
|
|
this._rgb = [_rgb[0] * r4, _rgb[1] * r4, _rgb[2] * r4, r4];
|
|
r17 = this;
|
|
} else {
|
|
const r7 = env12443[173];
|
|
const r6 = [_rgb[0] * r4, _rgb[1] * r4, _rgb[2] * r4, r4];
|
|
const r3 = Object.create(r7.prototype);
|
|
const r16 = r7.call(r3, r6, "rgb");
|
|
r17 = r16 instanceof Object ? r16 : r3;
|
|
}
|
|
return r17;
|
|
};
|
|
env12443[174] = Color;
|
|
env12443[175] = r160;
|
|
Color.prototype.saturate = function(a0) {
|
|
const r8 = a0 === void 0 ? 1 : a0;
|
|
const r7 = this.lch();
|
|
r7[1] = r7[1] + env12443[175].Kn * r8;
|
|
if (r7[1] < 0) {
|
|
r7[1] = 0;
|
|
}
|
|
const r14 = env12443[174];
|
|
const r15 = Object.create(r14.prototype);
|
|
const r17 = r14.call(r15, r7, "lch");
|
|
return (r17 instanceof Object ? r17 : r15).alpha(this.alpha(), true);
|
|
};
|
|
Color.prototype.desaturate = function(a0) {
|
|
return this.saturate(-(a0 === void 0 ? 1 : a0));
|
|
};
|
|
env12443[176] = Color;
|
|
env12443[177] = type$p;
|
|
Color.prototype.set = function(a0, a1, a2) {
|
|
const r7 = a2 === void 0 ? false : a2;
|
|
const r18 = a0.split(".");
|
|
const r9 = r18[0];
|
|
const r19 = r18[1];
|
|
const r21 = this[r9]();
|
|
if (r19) {
|
|
const r25 = r9.indexOf(r19) - (r9.substr(0, 2) === "ok" ? 2 : 0);
|
|
if (-1 < r25) {
|
|
const r37 = env12443[177];
|
|
const r12 = env12443[0];
|
|
const r45 = r12[Object.prototype.toString.call(a1)] || "object";
|
|
L34: {
|
|
if (r45 == "string") {
|
|
const r63 = a1.charAt(0);
|
|
if (r63 !== "+" && r63 !== "-") {
|
|
if (r63 === "*") {
|
|
r21[r25] = r21[r25] * +a1.substr(1);
|
|
break L34;
|
|
}
|
|
if (r63 === "/") {
|
|
r21[r25] = r21[r25] / +a1.substr(1);
|
|
break L34;
|
|
}
|
|
r21[r25] = +a1;
|
|
break L34;
|
|
}
|
|
r21[r25] = r21[r25] + +a1;
|
|
} else {
|
|
if ((r12[Object.prototype.toString.call(a1)] || "object") !== "number") {
|
|
throw new Error("unsupported value for Color.set");
|
|
}
|
|
r21[r25] = a1;
|
|
}
|
|
}
|
|
const r84 = env12443[176];
|
|
const r85 = Object.create(r84.prototype);
|
|
const r86 = r84.call(r85, r21, r9);
|
|
const r87 = r86 instanceof Object ? r86 : r85;
|
|
let r88 = r87;
|
|
if (r7) {
|
|
this._rgb = r87._rgb;
|
|
r88 = this;
|
|
}
|
|
return r88;
|
|
}
|
|
throw new Error("unknown channel " + r19 + " in mode " + r9);
|
|
}
|
|
return r21;
|
|
};
|
|
env12443[178] = Color;
|
|
r310.rgb = function({ _rgb: _rgb2 }, { _rgb }, a2) {
|
|
const r5 = env12443[178];
|
|
const r11 = _rgb2[0] + a2 * (_rgb[0] - _rgb2[0]);
|
|
const r10 = _rgb2[1] + a2 * (_rgb[1] - _rgb2[1]);
|
|
const r9 = _rgb2[2] + a2 * (_rgb[2] - _rgb2[2]);
|
|
const r27 = Object.create(r5.prototype);
|
|
const r28 = r5.call(r27, r11, r10, r9, "rgb");
|
|
return r28 instanceof Object ? r28 : r27;
|
|
};
|
|
env12443[179] = Color;
|
|
env12443[180] = Math.sqrt;
|
|
env12443[181] = Math.pow;
|
|
r310.lrgb = function({ _rgb }, a1, a2) {
|
|
const r13 = _rgb[0];
|
|
const r12 = _rgb[1];
|
|
const r11 = _rgb[2];
|
|
const _rgb2 = a1._rgb;
|
|
const r8 = _rgb2[0];
|
|
const r7 = _rgb2[1];
|
|
const r10 = _rgb2[2];
|
|
const r9 = env12443[179];
|
|
const r22 = env12443[180];
|
|
const r23 = env12443[181];
|
|
const r29 = r22(r23(r13, 2) * (1 - a2) + r23(r8, 2) * a2);
|
|
const r36 = r22(r23(r12, 2) * (1 - a2) + r23(r7, 2) * a2);
|
|
const r15 = r22(r23(r11, 2) * (1 - a2) + r23(r10, 2) * a2);
|
|
const r43 = Object.create(r9.prototype);
|
|
const r44 = r9.call(r43, r29, r36, r15, "rgb");
|
|
return r44 instanceof Object ? r44 : r43;
|
|
};
|
|
env12443[182] = Color;
|
|
r310.lab = function(a0, a1, a2) {
|
|
const r13 = a0.lab();
|
|
const r6 = a1.lab();
|
|
const r5 = env12443[182];
|
|
const r11 = r13[0] + a2 * (r6[0] - r13[0]);
|
|
const r10 = r13[1] + a2 * (r6[1] - r13[1]);
|
|
const r9 = r13[2] + a2 * (r6[2] - r13[2]);
|
|
const r29 = Object.create(r5.prototype);
|
|
const r30 = r5.call(r29, r11, r10, r9, "lab");
|
|
return r30 instanceof Object ? r30 : r29;
|
|
};
|
|
env12443[183] = Color;
|
|
const _hsx = function _hsx(a0, a1, a2, a3) {
|
|
let r12, r18, r24, r63, r64;
|
|
L13: {
|
|
if (a3 === "hsl") {
|
|
r12 = a0.hsl();
|
|
r18 = a1.hsl();
|
|
r24 = a3;
|
|
} else if (a3 === "hsv") {
|
|
r12 = a0.hsv();
|
|
r18 = a1.hsv();
|
|
r24 = a3;
|
|
} else if (a3 === "hcg") {
|
|
r12 = a0.hcg();
|
|
r18 = a1.hcg();
|
|
r24 = a3;
|
|
} else if (a3 === "hsi") {
|
|
r12 = a0.hsi();
|
|
r18 = a1.hsi();
|
|
r24 = a3;
|
|
} else {
|
|
if (a3 !== "lch" && a3 !== "hcl") {
|
|
r18 = void 0;
|
|
r12 = void 0;
|
|
r24 = a3;
|
|
if (a3 !== "oklch") {
|
|
break L13;
|
|
}
|
|
r12 = a0.oklch().reverse();
|
|
r18 = a1.oklch().reverse();
|
|
r24 = a3;
|
|
break L13;
|
|
}
|
|
r12 = a0.hcl();
|
|
r18 = a1.hcl();
|
|
r24 = "hcl";
|
|
}
|
|
}
|
|
let r3 = r24.substr(0, 1) !== "h";
|
|
const r42 = r24;
|
|
if (r3) {
|
|
r3 = r42 !== "oklch";
|
|
}
|
|
let r44 = void 0;
|
|
let r45 = void 0;
|
|
let r46 = void 0;
|
|
let r47 = void 0;
|
|
let r15 = void 0;
|
|
let r48 = void 0;
|
|
if (!r3) {
|
|
r48 = r12[0];
|
|
r47 = r12[1];
|
|
r45 = r12[2];
|
|
r15 = r18[0];
|
|
r46 = r18[1];
|
|
r44 = r18[2];
|
|
}
|
|
const isNaN2 = isNaN(r48);
|
|
const r16 = r48;
|
|
if (!isNaN2 && !isNaN(r15)) {
|
|
r63 = r16 + a2 * (r15 > r16 && r15 - r16 > 180 ? r15 - (r16 + 360) : r15 < r16 && r16 - r15 > 180 ? r15 + 360 - r16 : r15 - r16);
|
|
r64 = void 0;
|
|
} else if (isNaN(r16)) {
|
|
if (isNaN(r15)) {
|
|
r63 = Number.NaN;
|
|
r64 = void 0;
|
|
} else {
|
|
const r70 = r45 != 1 && r45 != 0 || r42 === "hsv";
|
|
r63 = r15;
|
|
r64 = void 0;
|
|
if (!r70) {
|
|
r63 = r15;
|
|
r64 = r46;
|
|
}
|
|
}
|
|
} else {
|
|
const r66 = r44 != 1 && r44 != 0 || r42 === "hsv";
|
|
r63 = r16;
|
|
r64 = void 0;
|
|
if (!r66) {
|
|
r63 = r16;
|
|
r64 = r47;
|
|
}
|
|
}
|
|
if (r64 === void 0) {
|
|
r64 = r47 + a2 * (r46 - r47);
|
|
}
|
|
const r78 = r45 + a2 * (r44 - r45);
|
|
const r79 = env12443[183];
|
|
const r81 = r42 === "oklch" ? [r78, r64, r63] : [r63, r64, r78];
|
|
const r83 = Object.create(r79.prototype);
|
|
const r84 = r79.call(r83, r81, r42);
|
|
return r84 instanceof Object ? r84 : r83;
|
|
};
|
|
env12443[184] = _hsx;
|
|
const lch = function lch(a0, a1, a2) {
|
|
return (0, env12443[184])(a0, a1, a2, "lch");
|
|
};
|
|
r310.lch = lch;
|
|
r310.hcl = lch;
|
|
env12443[185] = Color;
|
|
r310.num = function(a0, a1, a2) {
|
|
const r4 = a0.num();
|
|
const r6 = a1.num();
|
|
const r3 = env12443[185];
|
|
const r11 = r4 + a2 * (r6 - r4);
|
|
const r12 = Object.create(r3.prototype);
|
|
const r14 = r3.call(r12, r11, "num");
|
|
return r14 instanceof Object ? r14 : r12;
|
|
};
|
|
env12443[186] = _hsx;
|
|
r310.hcg = function(a0, a1, a2) {
|
|
return (0, env12443[186])(a0, a1, a2, "hcg");
|
|
};
|
|
env12443[187] = _hsx;
|
|
r310.hsi = function(a0, a1, a2) {
|
|
return (0, env12443[187])(a0, a1, a2, "hsi");
|
|
};
|
|
env12443[188] = _hsx;
|
|
r310.hsl = function(a0, a1, a2) {
|
|
return (0, env12443[188])(a0, a1, a2, "hsl");
|
|
};
|
|
env12443[189] = _hsx;
|
|
r310.hsv = function(a0, a1, a2) {
|
|
return (0, env12443[189])(a0, a1, a2, "hsv");
|
|
};
|
|
env12443[190] = Color;
|
|
r310.oklab = function(a0, a1, a2) {
|
|
const r13 = a0.oklab();
|
|
const r6 = a1.oklab();
|
|
const r5 = env12443[190];
|
|
const r11 = r13[0] + a2 * (r6[0] - r13[0]);
|
|
const r10 = r13[1] + a2 * (r6[1] - r13[1]);
|
|
const r9 = r13[2] + a2 * (r6[2] - r13[2]);
|
|
const r29 = Object.create(r5.prototype);
|
|
const r30 = r5.call(r29, r11, r10, r9, "oklab");
|
|
return r30 instanceof Object ? r30 : r29;
|
|
};
|
|
env12443[191] = _hsx;
|
|
r310.oklch = function(a0, a1, a2) {
|
|
return (0, env12443[191])(a0, a1, a2, "oklch");
|
|
};
|
|
env12443[192] = Color;
|
|
env12443[193] = clip_rgb;
|
|
env12443[194] = Math.pow;
|
|
env12443[195] = Math.sqrt;
|
|
env12443[196] = Math.PI;
|
|
env12443[197] = Math.cos;
|
|
env12443[198] = Math.sin;
|
|
env12443[199] = Math.atan2;
|
|
env12443[200] = function _average_lrgb(a0, a1) {};
|
|
env12443[201] = chroma$k;
|
|
env12443[202] = type$p;
|
|
env12443[203] = Math.pow;
|
|
const scale$2 = function scale$2(c23829_0) {
|
|
let tMapLightness2, tMapDomain2, getColor2, resetCache2, c23829_21;
|
|
let c23829_1 = "rgb";
|
|
let c23829_2 = (0, env12443[201])("#ccc");
|
|
let c23829_3 = 0;
|
|
let c23829_4 = [0, 1];
|
|
let c23829_5 = [];
|
|
let c23829_6 = [0, 0];
|
|
let c23829_7 = false;
|
|
let c23829_8 = [];
|
|
let c23829_9 = false;
|
|
let c23829_10 = 0;
|
|
let c23829_11 = 1;
|
|
let c23829_12 = false;
|
|
let c23829_13 = {};
|
|
let c23829_14 = true;
|
|
let c23829_15 = 1;
|
|
const setColors2 = function setColors(a0) {
|
|
let length;
|
|
const r8 = a0 ? a0 : ["#fff", "#000"];
|
|
const r11 = (r8 ? (env12443[0][Object.prototype.toString.call(r8)] || "object") === "string" : r8) && env12443[201].brewer && env12443[201].brewer[r8.toLowerCase()] ? env12443[201].brewer[r8.toLowerCase()] : r8;
|
|
const r46 = env12443[0][Object.prototype.toString.call(r11)] || "object";
|
|
let r49 = r11;
|
|
if (r46 === "array") {
|
|
const r55 = (r11.length === 1 ? [r11[0], r11[0]] : r11).slice(0);
|
|
const r5 = 0 < r55.length;
|
|
let r0 = 0;
|
|
if (r5) {
|
|
do {
|
|
r55[r0] = (0, env12443[201])(r55[r0]);
|
|
r0 = r0 + 1;
|
|
} while (r0 < r55.length);
|
|
}
|
|
c23829_5.length = 0;
|
|
const r63 = 0 < r55.length;
|
|
let r64 = 0;
|
|
r49 = r55;
|
|
if (r63) {
|
|
do {
|
|
c23829_5.push(r64 / (r55.length - 1));
|
|
r64 = r64 + 1;
|
|
length = r55.length;
|
|
r49 = r55;
|
|
} while (r64 < length);
|
|
}
|
|
}
|
|
c23829_13 = {};
|
|
c23829_8 = r49;
|
|
return r49;
|
|
};
|
|
tMapLightness2 = function tMapLightness(a0) {
|
|
return a0;
|
|
};
|
|
tMapDomain2 = function tMapDomain(a0) {
|
|
return a0;
|
|
};
|
|
getColor2 = function getColor(a0, a1) {
|
|
let r13, r41, r99, r117, r130;
|
|
const r7 = a1 == null ? false : a1;
|
|
if (!isNaN(a0) && a0 !== null) {
|
|
L17: {
|
|
r13 = a0;
|
|
if (!r7) {
|
|
if (c23829_7 && c23829_7.length > 2) {
|
|
const r33 = c23829_7 != null;
|
|
let r5 = 0;
|
|
if (r33) {
|
|
const r6 = c23829_7.length - 1;
|
|
let r1 = 0;
|
|
if (0 < r6) {
|
|
const r38 = a0 >= c23829_7[0];
|
|
let r0 = 0;
|
|
r1 = 0;
|
|
if (r38) {
|
|
do {
|
|
const r39 = r0 + 1;
|
|
r1 = r39;
|
|
if (!(r39 < r6)) {
|
|
break;
|
|
}
|
|
r41 = c23829_7[r39];
|
|
r0 = r39;
|
|
r1 = r0;
|
|
} while (a0 >= r41);
|
|
}
|
|
}
|
|
r5 = r1 - 1;
|
|
}
|
|
r13 = r5 / (c23829_7.length - 2);
|
|
break L17;
|
|
}
|
|
r13 = c23829_11 !== c23829_10 ? (a0 - c23829_10) / (c23829_11 - c23829_10) : 1;
|
|
}
|
|
}
|
|
const r46 = tMapDomain2(r13);
|
|
const r47 = r7 ? r46 : tMapLightness2(r46);
|
|
const r70 = Math.min(1, Math.max(0, c23829_6[0] + (c23829_15 !== 1 ? (0, env12443[203])(r47, c23829_15) : r47) * (1 - c23829_6[0] - c23829_6[1])));
|
|
const r75 = Math.floor(10000 * r70);
|
|
if (c23829_14 && c23829_13[r75]) {
|
|
r130 = c23829_13[r75];
|
|
} else {
|
|
const r80 = env12443[202];
|
|
const r82 = env12443[0];
|
|
if ((r82[Object.prototype.toString.call(c23829_8)] || "object") === "array") {
|
|
const r103 = 0 < c23829_5.length;
|
|
let r104 = 0;
|
|
r99 = void 0;
|
|
if (r103) {
|
|
do {
|
|
const r106 = c23829_5[r104];
|
|
const r107 = r104;
|
|
if (r70 <= r106) {
|
|
r99 = c23829_8[r107];
|
|
break;
|
|
}
|
|
if (r70 >= r106 && r107 === c23829_5.length - 1) {
|
|
r99 = c23829_8[r107];
|
|
break;
|
|
}
|
|
if (r70 > r106) {
|
|
const r112 = r107 + 1;
|
|
if (r70 < c23829_5[r112]) {
|
|
r99 = env12443[201].interpolate(c23829_8[r107], c23829_8[r112], (r70 - r106) / (c23829_5[r112] - r106), c23829_1);
|
|
break;
|
|
}
|
|
}
|
|
const r114 = r107 + 1;
|
|
r117 = r114 < c23829_5.length;
|
|
r104 = r114;
|
|
r99 = void 0;
|
|
} while (r117);
|
|
}
|
|
} else {
|
|
r99 = (r82[Object.prototype.toString.call(c23829_8)] || "object") === "function" ? c23829_8(r70) : void 0;
|
|
}
|
|
r130 = r99;
|
|
if (c23829_14) {
|
|
c23829_13[r75] = r99;
|
|
r130 = r99;
|
|
}
|
|
}
|
|
return r130;
|
|
}
|
|
return c23829_2;
|
|
};
|
|
resetCache2 = function resetCache() {};
|
|
setColors2(c23829_0);
|
|
const r24 = function f(a0) {
|
|
const r8 = (0, env12443[201])(getColor2(a0));
|
|
return c23829_9 ? r8[c23829_9] ? r8[c23829_9]() : r8 : r8;
|
|
};
|
|
c23829_21 = r24;
|
|
r24.classes = function(a0) {
|
|
if (a0 != null) {
|
|
if ((env12443[0][Object.prototype.toString.call(a0)] || "object") === "array") {
|
|
c23829_7 = a0;
|
|
c23829_4 = [a0[0], a0[a0.length - 1]];
|
|
} else {
|
|
const r20 = env12443[201];
|
|
const r23 = r20.analyze(c23829_4);
|
|
c23829_7 = a0 === 0 ? [r23.min, r23.max] : r20.limits(r23, "e", a0);
|
|
}
|
|
return c23829_21;
|
|
}
|
|
return c23829_7;
|
|
};
|
|
r24.domain = function(a0) {
|
|
let c28668_1, c28668_2;
|
|
let c28668_0 = a0;
|
|
if (arguments.length) {
|
|
L11: {
|
|
c23829_10 = a0[0];
|
|
c23829_11 = a0[a0.length - 1];
|
|
c23829_5 = [];
|
|
const length = c23829_8.length;
|
|
if (a0.length === length && c23829_10 !== c23829_11) {
|
|
const r40 = Array.from(a0);
|
|
const length2 = r40.length;
|
|
let r42 = 0;
|
|
if (!(0 < length2)) {
|
|
break L11;
|
|
}
|
|
while (true) {
|
|
c23829_5.push((r40[r42] - c23829_10) / (c23829_11 - c23829_10));
|
|
r42 = r42 + 1;
|
|
if (!(r42 < r40.length)) {
|
|
break L11;
|
|
}
|
|
}
|
|
}
|
|
let r20 = 0;
|
|
while (r20 < length) {
|
|
c23829_5.push(r20 / (length - 1));
|
|
r20 = r20 + 1;
|
|
}
|
|
if (a0.length > 2) {
|
|
c28668_1 = a0.map(function(item, index) {
|
|
return index / (c28668_0.length - 1);
|
|
});
|
|
const r32 = a0.map(function(item) {
|
|
return (item - c23829_10) / (c23829_11 - c23829_10);
|
|
});
|
|
c28668_2 = r32;
|
|
if (!r32.every(function(item, index) {
|
|
return c28668_1[index] === item;
|
|
})) {
|
|
tMapDomain2 = function tMapDomain(a0) {
|
|
let r12;
|
|
if (!(a0 <= 0) && !(a0 >= 1)) {
|
|
let r8 = c28668_2;
|
|
const r5 = a0 >= r8[1];
|
|
let r0 = 0;
|
|
let r11 = 0;
|
|
if (r5) {
|
|
do {
|
|
const r1 = r0 + 1;
|
|
r12 = c28668_2[r1 + 1];
|
|
r0 = r1;
|
|
r11 = r0;
|
|
r8 = c28668_2;
|
|
} while (a0 >= r12);
|
|
}
|
|
const r14 = a0 - r8[r11];
|
|
const r15 = r11 + 1;
|
|
const r19 = r14 / (r8[r15] - r8[r11]);
|
|
return c28668_1[r11] + r19 * (c28668_1[r15] - c28668_1[r11]);
|
|
}
|
|
return a0;
|
|
};
|
|
}
|
|
}
|
|
}
|
|
c23829_4 = [c23829_10, c23829_11];
|
|
return c23829_21;
|
|
}
|
|
return c23829_4;
|
|
};
|
|
r24.mode = function(a0) {
|
|
let r6;
|
|
if (arguments.length) {
|
|
c23829_1 = a0;
|
|
c23829_13 = {};
|
|
r6 = c23829_21;
|
|
} else {
|
|
r6 = c23829_1;
|
|
}
|
|
return r6;
|
|
};
|
|
r24.range = function(a0, a1) {
|
|
setColors2(a0);
|
|
return c23829_21;
|
|
};
|
|
r24.out = function(a0) {
|
|
c23829_9 = a0;
|
|
return c23829_21;
|
|
};
|
|
r24.spread = function(a0) {
|
|
let r5;
|
|
if (arguments.length) {
|
|
c23829_3 = a0;
|
|
r5 = c23829_21;
|
|
} else {
|
|
r5 = c23829_3;
|
|
}
|
|
return r5;
|
|
};
|
|
r24.correctLightness = function(a0) {
|
|
const r2 = a0 == null ? true : a0;
|
|
c23829_12 = r2;
|
|
c23829_13 = {};
|
|
tMapLightness2 = r2 ? function(a0) {
|
|
let r3, r22, r46;
|
|
const r26 = getColor2(0, true).lab()[0];
|
|
const r29 = getColor2(1, true).lab()[0];
|
|
const r10 = r26 > r29;
|
|
const r33 = getColor2(a0, true).lab()[0];
|
|
const r17 = r26 + (r29 - r26) * a0;
|
|
const r36 = r33 - r17;
|
|
const r9 = Math.abs(r36) > 0.01;
|
|
let r0 = 19;
|
|
let r40 = 1;
|
|
let r41 = 0;
|
|
let r42 = r36;
|
|
let r43 = a0;
|
|
let r44 = a0;
|
|
if (r9) {
|
|
do {
|
|
r3 = r0;
|
|
const r24 = r40;
|
|
let r21 = r41;
|
|
const r20 = r42;
|
|
const r23 = r43;
|
|
if ((r10 ? r20 * -1 : r20) < 0) {
|
|
r46 = r23 + 0.5 * (r24 - r23);
|
|
r22 = r24;
|
|
r21 = r23;
|
|
} else {
|
|
r46 = r23 + 0.5 * (r21 - r23);
|
|
r22 = r23;
|
|
}
|
|
const r54 = getColor2(r46, true).lab()[0] - r17;
|
|
const r57 = Math.abs(r54);
|
|
r44 = r46;
|
|
if (!(r57 > 0.01)) {
|
|
break;
|
|
}
|
|
r0 = r3 - 1;
|
|
r40 = r22;
|
|
r41 = r21;
|
|
r42 = r54;
|
|
r43 = r46;
|
|
r44 = r43;
|
|
} while (0 < r3);
|
|
}
|
|
return r44;
|
|
} : function(a0) {
|
|
return a0;
|
|
};
|
|
return c23829_21;
|
|
};
|
|
r24.padding = function(a0) {
|
|
let r1;
|
|
if (a0 != null) {
|
|
c23829_6 = (env12443[0][Object.prototype.toString.call(a0)] || "object") === "number" ? [a0, a0] : a0;
|
|
r1 = c23829_21;
|
|
} else {
|
|
r1 = c23829_6;
|
|
}
|
|
return r1;
|
|
};
|
|
r24.colors = function(a0, a1) {
|
|
let r16, r39, r53;
|
|
let c28669_2, c28669_3;
|
|
let r12 = a1;
|
|
let c28669_1 = a1;
|
|
if (arguments.length < 2) {
|
|
c28669_1 = "hex";
|
|
r12 = "hex";
|
|
}
|
|
if (arguments.length === 0) {
|
|
r39 = c23829_8.slice(0);
|
|
} else if (a0 === 1) {
|
|
const r63 = (0, env12443[201])(getColor2(0.5));
|
|
r39 = [c23829_9 ? r63[c23829_9] ? r63[c23829_9]() : r63 : r63];
|
|
} else if (a0 > 1) {
|
|
const r41 = c23829_4[0];
|
|
c28669_2 = r41;
|
|
c28669_3 = c23829_4[1] - r41;
|
|
const r45 = 0 < a0;
|
|
const r46 = r45 ? 0 < a0 : 0 > a0;
|
|
const r47 = [];
|
|
let r48 = 0;
|
|
if (r46) {
|
|
do {
|
|
r47.push(r48);
|
|
const r51 = r48;
|
|
const r52 = r45 ? r51 + 1 : r51 - 1;
|
|
r53 = r45 ? r52 < a0 : r52 > a0;
|
|
r48 = r52;
|
|
} while (r53);
|
|
}
|
|
r39 = r47.map(function(item) {
|
|
const r20 = (0, env12443[201])(getColor2(c28669_2 + item / (a0 - 1) * c28669_3));
|
|
return c23829_9 ? r20[c23829_9] ? r20[c23829_9]() : r20 : r20;
|
|
});
|
|
} else {
|
|
L18: {
|
|
c23829_0 = [];
|
|
if (c23829_7 && c23829_7.length > 2) {
|
|
const length = c23829_7.length;
|
|
const r7 = 1 <= length;
|
|
const r6 = r7 ? 1 < length : 1 > length;
|
|
const r29 = [];
|
|
let r30 = 1;
|
|
r16 = r29;
|
|
if (!r6) {
|
|
break L18;
|
|
}
|
|
while (true) {
|
|
let r0 = r30 - 1;
|
|
r29.push(0.5 * (c23829_7[r0] + c23829_7[r30]));
|
|
const r35 = r30;
|
|
if (r7) {
|
|
r0 = r35 + 1;
|
|
}
|
|
const r36 = r7 ? r0 < length : r0 > length;
|
|
r30 = r0;
|
|
r16 = r29;
|
|
if (!r36) {
|
|
break L18;
|
|
}
|
|
}
|
|
}
|
|
r16 = c23829_4;
|
|
}
|
|
r39 = r16.map(function(item) {
|
|
const r11 = (0, env12443[201])(getColor2(item));
|
|
return c23829_9 ? r11[c23829_9] ? r11[c23829_9]() : r11 : r11;
|
|
});
|
|
}
|
|
return env12443[201][r12] ? r39.map(function(item) {
|
|
return item[c28669_1]();
|
|
}) : r39;
|
|
};
|
|
r24.cache = function(a0) {
|
|
let r1;
|
|
if (a0 != null) {
|
|
c23829_14 = a0;
|
|
r1 = c23829_21;
|
|
} else {
|
|
r1 = c23829_14;
|
|
}
|
|
return r1;
|
|
};
|
|
r24.gamma = function(a0) {
|
|
let r1;
|
|
if (a0 != null) {
|
|
c23829_15 = a0;
|
|
r1 = c23829_21;
|
|
} else {
|
|
r1 = c23829_15;
|
|
}
|
|
return r1;
|
|
};
|
|
r24.nodata = function(a0) {
|
|
let r1;
|
|
if (a0 != null) {
|
|
c23829_2 = (0, env12443[201])(a0);
|
|
r1 = c23829_21;
|
|
} else {
|
|
r1 = c23829_2;
|
|
}
|
|
return r1;
|
|
};
|
|
return r24;
|
|
};
|
|
env12443[204] = Color;
|
|
env12443[205] = scale$2;
|
|
env12443[206] = chroma$k;
|
|
const blend = function blend(a0, a1, a2) {
|
|
const r3 = env12443[207];
|
|
if (r3[a2]) {
|
|
return r3[a2](a0, a1);
|
|
}
|
|
throw new Error("unknown blend mode " + a2);
|
|
};
|
|
env12443[207] = blend;
|
|
const r356 = env12444 = {};
|
|
env12444[0] = function(a0) {
|
|
return a0;
|
|
};
|
|
const r358 = env12445 = {
|
|
$parent: r11
|
|
};
|
|
env12445[0] = $mk101374(r356);
|
|
blend.normal = $mk101373(r358);
|
|
const r361 = env12446 = {};
|
|
env12446[0] = function(a0, a1) {
|
|
return a0 * a1 / 255;
|
|
};
|
|
const r363 = env12447 = {
|
|
$parent: r11
|
|
};
|
|
env12447[0] = $mk101374(r361);
|
|
blend.multiply = $mk101373(r363);
|
|
const r366 = env12448 = {};
|
|
env12448[0] = function(a0, a1) {
|
|
return 255 * (1 - (1 - a0 / 255) * (1 - a1 / 255));
|
|
};
|
|
const r368 = env12449 = {
|
|
$parent: r11
|
|
};
|
|
env12449[0] = $mk101374(r366);
|
|
blend.screen = $mk101373(r368);
|
|
const r371 = env12450 = {};
|
|
env12450[0] = function(a0, a1) {
|
|
return a1 < 128 ? 2 * a0 * a1 / 255 : 255 * (1 - 2 * (1 - a0 / 255) * (1 - a1 / 255));
|
|
};
|
|
const r373 = env12451 = {
|
|
$parent: r11
|
|
};
|
|
env12451[0] = $mk101374(r371);
|
|
blend.overlay = $mk101373(r373);
|
|
const r376 = env12452 = {};
|
|
env12452[0] = function(a0, a1) {
|
|
return a0 > a1 ? a1 : a0;
|
|
};
|
|
const r378 = env12453 = {
|
|
$parent: r11
|
|
};
|
|
env12453[0] = $mk101374(r376);
|
|
blend.darken = $mk101373(r378);
|
|
const r381 = env12454 = {};
|
|
env12454[0] = function(a0, a1) {
|
|
return a0 > a1 ? a0 : a1;
|
|
};
|
|
const r383 = env12455 = {
|
|
$parent: r11
|
|
};
|
|
env12455[0] = $mk101374(r381);
|
|
blend.lighten = $mk101373(r383);
|
|
const r386 = env12456 = {};
|
|
env12456[0] = function(a0, a1) {
|
|
let r0 = 255;
|
|
if (a0 !== 255) {
|
|
const r9 = a1 / 255 * 255 / (1 - a0 / 255);
|
|
r0 = 255 < r9 ? 255 : r9;
|
|
}
|
|
return r0;
|
|
};
|
|
const r388 = env12457 = {
|
|
$parent: r11
|
|
};
|
|
env12457[0] = $mk101374(r386);
|
|
blend.dodge = $mk101373(r388);
|
|
const r391 = env12458 = {};
|
|
env12458[0] = function(a0, a1) {
|
|
return 255 * (1 - (1 - a1 / 255) / (a0 / 255));
|
|
};
|
|
const r393 = env12459 = {
|
|
$parent: r11
|
|
};
|
|
env12459[0] = $mk101374(r391);
|
|
blend.burn = $mk101373(r393);
|
|
env12443[208] = type$p;
|
|
env12443[209] = clip_rgb;
|
|
env12443[210] = r35;
|
|
env12443[211] = Math.pow;
|
|
env12443[212] = Math.sin;
|
|
env12443[213] = Math.cos;
|
|
env12443[214] = chroma$k;
|
|
env12443[215] = Color;
|
|
env12443[216] = Math.floor;
|
|
env12443[217] = Math.random;
|
|
env12443[218] = type$p;
|
|
env12443[219] = Math.log;
|
|
env12443[220] = Math.pow;
|
|
env12443[221] = Math.floor;
|
|
env12443[222] = Math.abs;
|
|
const analyze = function analyze(a0, a1) {
|
|
let c23830_0 = a1;
|
|
if (a1 === void 0) {
|
|
c23830_0 = null;
|
|
}
|
|
const r12 = {
|
|
min: Number.MAX_VALUE,
|
|
max: -1 * Number.MAX_VALUE,
|
|
sum: 0,
|
|
values: [],
|
|
count: 0
|
|
};
|
|
let c23830_1 = r12;
|
|
((env12443[0][Object.prototype.toString.call(a0)] || "object") === "object" ? Object.values(a0) : a0).forEach(function(item) {
|
|
const min = c23830_0 && (env12443[0][Object.prototype.toString.call(item)] || "object") === "object" ? item[c23830_0] : item;
|
|
if (!(min == null || isNaN(min))) {
|
|
c23830_1.values.push(min);
|
|
c23830_1.sum = c23830_1.sum + min;
|
|
if (min < c23830_1.min) {
|
|
c23830_1.min = min;
|
|
}
|
|
if (min > c23830_1.max) {
|
|
c23830_1.max = min;
|
|
}
|
|
c23830_1.count = c23830_1.count + 1;
|
|
}
|
|
});
|
|
r12.domain = [r12.min, r12.max];
|
|
r12.limits = function(a0, a1) {
|
|
return (0, env12443[224])(c23830_1, a0, a1);
|
|
};
|
|
return r12;
|
|
};
|
|
env12443[223] = analyze;
|
|
const limits = function limits(a0, a1, a2) {
|
|
let r131;
|
|
const r23 = a1 === void 0 ? "equal" : a1;
|
|
const r18 = a2 === void 0 ? 7 : a2;
|
|
const r41 = (env12443[0][Object.prototype.toString.call(a0)] || "object") == "array" ? (0, env12443[223])(a0) : a0;
|
|
const { min, max } = r41;
|
|
const r47 = r41.values.sort(function(a, b) {
|
|
return a - b;
|
|
});
|
|
if (r18 === 1) {
|
|
return [min, max];
|
|
}
|
|
const r48 = [];
|
|
if (r23.substr(0, 1) === "c") {
|
|
r48.push(min);
|
|
r48.push(max);
|
|
}
|
|
L73: {
|
|
if (r23.substr(0, 1) === "e") {
|
|
r48.push(min);
|
|
const r236 = 1 < r18;
|
|
let r237 = 1;
|
|
if (r236) {
|
|
do {
|
|
r48.push(min + r237 / r18 * (max - min));
|
|
r237 = r237 + 1;
|
|
} while (r237 < r18);
|
|
}
|
|
r48.push(max);
|
|
} else if (r23.substr(0, 1) === "l") {
|
|
if (min <= 0) {
|
|
throw new Error("Logarithmic scales are only possible for values > 0");
|
|
}
|
|
const LOG10E = Math.LOG10E;
|
|
const r206 = env12443[219];
|
|
const r208 = LOG10E * r206(min);
|
|
const r212 = Math.LOG10E * r206(max);
|
|
r48.push(min);
|
|
const r215 = 1 < r18;
|
|
let r217 = 1;
|
|
if (r215) {
|
|
do {
|
|
r48.push((0, env12443[220])(10, r208 + r217 / r18 * (r212 - r208)));
|
|
r217 = r217 + 1;
|
|
} while (r217 < r18);
|
|
}
|
|
r48.push(max);
|
|
} else if (r23.substr(0, 1) === "q") {
|
|
r48.push(min);
|
|
const r180 = 1 < r18;
|
|
let r181 = 1;
|
|
if (r180) {
|
|
do {
|
|
const r185 = (r47.length - 1) * r181 / r18;
|
|
const r187 = (0, env12443[221])(r185);
|
|
const r188 = r181;
|
|
if (r187 === r185) {
|
|
r48.push(r47[r187]);
|
|
} else {
|
|
const r189 = r185 - r187;
|
|
r48.push(r47[r187] * (1 - r189) + r47[r187 + 1] * r189);
|
|
}
|
|
r181 = r188 + 1;
|
|
} while (r181 < r18);
|
|
}
|
|
r48.push(max);
|
|
} else if (r23.substr(0, 1) === "k") {
|
|
const length = r47.length;
|
|
const array = new Array(length);
|
|
const array2 = new Array(r18);
|
|
let r78 = [];
|
|
r78.push(min);
|
|
const r10 = 1 < r18;
|
|
let r5 = 1;
|
|
if (r10) {
|
|
do {
|
|
r78.push(min + r5 / r18 * (max - min));
|
|
r5 = r5 + 1;
|
|
} while (r5 < r18);
|
|
}
|
|
r78.push(max);
|
|
let r87 = 0;
|
|
while (true) {
|
|
const r88 = 0 < r18;
|
|
const r89 = r78;
|
|
const r8 = r87;
|
|
let r1 = 0;
|
|
if (r88) {
|
|
do {
|
|
array2[r1] = 0;
|
|
r1 = r1 + 1;
|
|
} while (r1 < r18);
|
|
}
|
|
const r90 = 0 < length;
|
|
let r91 = 0;
|
|
if (r90) {
|
|
do {
|
|
const r28 = r47[r91];
|
|
let MAX_VALUE = Number.MAX_VALUE;
|
|
const r9 = 0 < r18;
|
|
const r4 = r91;
|
|
let r0 = 0;
|
|
let r94 = void 0;
|
|
if (r9) {
|
|
do {
|
|
const r96 = (0, env12443[222])(r89[r0] - r28);
|
|
const r2 = r0;
|
|
let r97 = r94;
|
|
let r98 = MAX_VALUE;
|
|
if (r96 < r98) {
|
|
r97 = r2;
|
|
r98 = r96;
|
|
}
|
|
array2[r97] = array2[r97] + 1;
|
|
array[r4] = r97;
|
|
r0 = r2 + 1;
|
|
r94 = r97;
|
|
MAX_VALUE = r98;
|
|
} while (r0 < r18);
|
|
}
|
|
r91 = r4 + 1;
|
|
} while (r91 < length);
|
|
}
|
|
const array3 = new Array(r18);
|
|
const r107 = 0 < r18;
|
|
let r108 = 0;
|
|
if (r107) {
|
|
do {
|
|
array3[r108] = null;
|
|
r108 = r108 + 1;
|
|
} while (r108 < r18);
|
|
}
|
|
const r109 = 0 < length;
|
|
let r110 = 0;
|
|
if (r109) {
|
|
do {
|
|
const r111 = array[r110];
|
|
const r112 = array3[r111];
|
|
const r113 = r110;
|
|
if (r112 === null) {
|
|
array3[r111] = r47[r113];
|
|
} else {
|
|
array3[r111] = array3[r111] + r47[r113];
|
|
}
|
|
r110 = r113 + 1;
|
|
} while (r110 < length);
|
|
}
|
|
const r118 = 0 < r18;
|
|
let r119 = 0;
|
|
if (r118) {
|
|
do {
|
|
array3[r119] = array3[r119] * (1 / array2[r119]);
|
|
r119 = r119 + 1;
|
|
} while (r119 < r18);
|
|
}
|
|
const r124 = 0 < r18;
|
|
let r125 = 0;
|
|
let r126 = false;
|
|
if (r124) {
|
|
do {
|
|
const r127 = array3[r125];
|
|
const r128 = r89[r125];
|
|
const r129 = r125;
|
|
r126 = true;
|
|
if (r127 !== r128) {
|
|
break;
|
|
}
|
|
const r130 = r129 + 1;
|
|
r131 = r130 < r18;
|
|
r125 = r130;
|
|
r126 = false;
|
|
} while (r131);
|
|
}
|
|
const r132 = r8 + 1;
|
|
if (200 < r132) {
|
|
r126 = false;
|
|
}
|
|
r78 = array3;
|
|
r87 = r132;
|
|
if (!r126) {
|
|
const r133 = {};
|
|
const r134 = 0 < r18;
|
|
let r135 = 0;
|
|
if (r134) {
|
|
do {
|
|
r133[r135] = [];
|
|
r135 = r135 + 1;
|
|
} while (r135 < r18);
|
|
}
|
|
const r137 = 0 < length;
|
|
let r138 = 0;
|
|
if (r137) {
|
|
do {
|
|
r133[array[r138]].push(r47[r138]);
|
|
r138 = r138 + 1;
|
|
} while (r138 < length);
|
|
}
|
|
const r144 = [];
|
|
const r145 = 0 < r18;
|
|
let r146 = 0;
|
|
if (r145) {
|
|
do {
|
|
r144.push(r133[r146][0]);
|
|
r144.push(r133[r146][r133[r146].length - 1]);
|
|
r146 = r146 + 1;
|
|
} while (r146 < r18);
|
|
}
|
|
const r160 = r144.sort(function(a, b) {
|
|
return a - b;
|
|
});
|
|
r48.push(r160[0]);
|
|
const r165 = 1 < r160.length;
|
|
let r168 = 1;
|
|
if (!r165) {
|
|
break;
|
|
}
|
|
while (true) {
|
|
const r169 = r160[r168];
|
|
let r171 = isNaN(r169);
|
|
const r172 = r168;
|
|
if (!r171) {
|
|
r171 = r48.indexOf(r169) !== -1;
|
|
}
|
|
if (!r171) {
|
|
r48.push(r169);
|
|
}
|
|
r168 = r172 + 2;
|
|
if (!(r168 < r160.length)) {
|
|
break L73;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return r48;
|
|
};
|
|
env12443[224] = limits;
|
|
env12443[225] = Color;
|
|
env12443[226] = Color;
|
|
env12443[227] = Math.sqrt;
|
|
env12443[228] = Math.pow;
|
|
env12443[229] = Math.min;
|
|
env12443[230] = Math.max;
|
|
env12443[231] = Math.atan2;
|
|
env12443[232] = Math.abs;
|
|
env12443[233] = Math.cos;
|
|
env12443[234] = Math.sin;
|
|
env12443[235] = Math.exp;
|
|
env12443[236] = Math.PI;
|
|
env12443[237] = Color;
|
|
env12443[238] = Color;
|
|
env12443[239] = chroma$k;
|
|
env12443[240] = scale$2;
|
|
const scales = {
|
|
cool: function cool() {
|
|
const r5 = env12443[240];
|
|
const r7 = env12443[239];
|
|
return r5([r7.hsl(180, 1, 0.9), r7.hsl(250, 0.7, 0.4)]);
|
|
},
|
|
hot: function hot() {
|
|
return (0, env12443[240])(["#000", "#f00", "#ff0", "#fff"]).mode("rgb");
|
|
}
|
|
};
|
|
const brewer = {
|
|
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"],
|
|
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"],
|
|
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 r478 = Object.keys(brewer);
|
|
const r480 = 0 < r478.length;
|
|
let r481 = 0;
|
|
if (r480) {
|
|
do {
|
|
const r482 = r478[r481];
|
|
brewer[r482.toLowerCase()] = brewer[r482];
|
|
r481 = r481 + 1;
|
|
} while (r481 < r478.length);
|
|
}
|
|
chroma$k.average = function(a0, a1, a2) {
|
|
let c23831_2, c23831_3, c23831_4, c23831_5, c23831_6, c23831_7;
|
|
let r18 = a1;
|
|
let c23831_0 = a1;
|
|
let r13 = a2;
|
|
let c23831_1 = a2;
|
|
if (a1 === void 0) {
|
|
c23831_0 = "lrgb";
|
|
r18 = "lrgb";
|
|
}
|
|
if (a2 === void 0) {
|
|
c23831_1 = null;
|
|
r13 = null;
|
|
}
|
|
const length = a0.length;
|
|
if (!r13) {
|
|
const r35 = Array.from(new Array(length)).map(function() {
|
|
return 1;
|
|
});
|
|
c23831_1 = r35;
|
|
r13 = r35;
|
|
}
|
|
c23831_2 = length / r13.reduce(function(acc, item) {
|
|
return acc + item;
|
|
});
|
|
r13.forEach(function(item, index) {
|
|
c23831_1[index] = c23831_1[index] * c23831_2;
|
|
});
|
|
const r46 = a0.map(function(item) {
|
|
const r2 = env12443[192];
|
|
const r1 = Object.create(r2.prototype);
|
|
const r4 = r2.call(r1, item);
|
|
return r4 instanceof Object ? r4 : r1;
|
|
});
|
|
const r48 = r13;
|
|
if (r18 === "lrgb") {
|
|
const length2 = r46.length;
|
|
const r128 = [0, 0, 0, 0];
|
|
const r131 = 0 < r46.length;
|
|
let r135 = 0;
|
|
if (r131) {
|
|
do {
|
|
const r136 = r46[r135];
|
|
const r138 = r48[r135] / length2;
|
|
const _rgb = r136._rgb;
|
|
const r140 = r128[0];
|
|
const r141 = env12443[194];
|
|
r128[0] = r140 + r141(_rgb[0], 2) * r138;
|
|
r128[1] = r128[1] + r141(_rgb[1], 2) * r138;
|
|
r128[2] = r128[2] + r141(_rgb[2], 2) * r138;
|
|
r128[3] = r128[3] + _rgb[3] * r138;
|
|
r135 = r135 + 1;
|
|
} while (r135 < r46.length);
|
|
}
|
|
const r161 = env12443[195];
|
|
r128[0] = r161(r128[0]);
|
|
r128[1] = r161(r128[1]);
|
|
r128[2] = r161(r128[2]);
|
|
if (r128[3] > 0.9999999) {
|
|
r128[3] = 1;
|
|
}
|
|
const r170 = env12443[192];
|
|
(0, env12443[193])(r128);
|
|
const r173 = Object.create(r170.prototype);
|
|
const r174 = r170.call(r173, r128);
|
|
return r174 instanceof Object ? r174 : r173;
|
|
}
|
|
const r21 = r46.shift();
|
|
const r51 = r21.get(r18);
|
|
c23831_3 = r51;
|
|
const r20 = [];
|
|
c23831_4 = r20;
|
|
c23831_5 = 0;
|
|
c23831_6 = 0;
|
|
const r53 = 0 < r51.length;
|
|
let r54 = 1;
|
|
let r4 = 0;
|
|
if (r53) {
|
|
do {
|
|
let r23 = r51[r4];
|
|
const r2 = r4;
|
|
if (!r23) {
|
|
r23 = 0;
|
|
}
|
|
r51[r2] = r23 * r48[0];
|
|
r20.push(isNaN(r51[r2]) ? 0 : r48[0]);
|
|
if (r18.charAt(r2) === "h" && !isNaN(r51[r2])) {
|
|
const r69 = r51[r2] / 180 * env12443[196];
|
|
c23831_5 = c23831_5 + (0, env12443[197])(r69) * r48[0];
|
|
c23831_6 = c23831_6 + (0, env12443[198])(r69) * r48[0];
|
|
}
|
|
r4 = r2 + 1;
|
|
} while (r4 < r51.length);
|
|
}
|
|
c23831_7 = r21.alpha() * r48[0];
|
|
r46.forEach(function(item, index) {
|
|
const r12 = item.get(c23831_0);
|
|
c23831_7 = c23831_7 + item.alpha() * c23831_1[index + 1];
|
|
const length = c23831_3.length;
|
|
let r1 = 0;
|
|
if (0 < length) {
|
|
do {
|
|
const isNaN2 = isNaN(r12[r1]);
|
|
const r0 = r1;
|
|
if (!isNaN2) {
|
|
const r17 = c23831_4[r0];
|
|
c23831_4[r0] = r17 + c23831_1[index + 1];
|
|
if (c23831_0.charAt(r0) === "h") {
|
|
const r48 = r12[r0] / 180 * env12443[196];
|
|
c23831_5 = c23831_5 + (0, env12443[197])(r48) * c23831_1[index + 1];
|
|
c23831_6 = c23831_6 + (0, env12443[198])(r48) * c23831_1[index + 1];
|
|
} else {
|
|
c23831_3[r0] = c23831_3[r0] + r12[r0] * c23831_1[index + 1];
|
|
}
|
|
}
|
|
r1 = r0 + 1;
|
|
} while (r1 < c23831_3.length);
|
|
}
|
|
});
|
|
const r90 = 0 < r51.length;
|
|
let r92 = 0;
|
|
if (r90) {
|
|
do {
|
|
const r94 = r18.charAt(r92);
|
|
const r95 = r92;
|
|
if (r94 === "h") {
|
|
let r108 = (0, env12443[199])(c23831_6 / r20[r95], c23831_5 / r20[r95]) / env12443[196] * 180;
|
|
let r109 = r108;
|
|
while (r109 < 0) {
|
|
r108 = r108 + 360;
|
|
r109 = r108;
|
|
}
|
|
let r110 = r109;
|
|
let r111 = r110;
|
|
while (360 <= r111) {
|
|
r110 = r110 - 360;
|
|
r111 = r110;
|
|
}
|
|
r51[r95] = r111;
|
|
} else {
|
|
r51[r95] = r51[r95] / r20[r95];
|
|
}
|
|
r92 = r95 + 1;
|
|
} while (r92 < r51.length);
|
|
}
|
|
c23831_7 = c23831_7 / length;
|
|
const r115 = env12443[192];
|
|
const r116 = Object.create(r115.prototype);
|
|
const r117 = r115.call(r116, r51, r18);
|
|
const r118 = r117 instanceof Object ? r117 : r116;
|
|
const r120 = c23831_7;
|
|
if (!(r120 > 0.99999)) {
|
|
r54 = r120;
|
|
}
|
|
return r118.alpha(r54, true);
|
|
};
|
|
chroma$k.bezier = function(a0) {
|
|
let r44;
|
|
let c23832_0, c23832_1, c23832_2, c23832_3, c23832_4, c23832_5, c23832_6;
|
|
const r13 = a0.map(function(item) {
|
|
const r2 = env12443[204];
|
|
const r1 = Object.create(r2.prototype);
|
|
const r4 = r2.call(r1, item);
|
|
return r4 instanceof Object ? r4 : r1;
|
|
});
|
|
if (r13.length === 2) {
|
|
const r63 = r13.map(function(item) {
|
|
return item.lab();
|
|
});
|
|
c23832_0 = r63[0];
|
|
c23832_1 = r63[1];
|
|
r44 = function a(c31161_0) {
|
|
const r3 = [0, 1, 2].map(function(item) {
|
|
return c23832_0[item] + c31161_0 * (c23832_1[item] - c23832_0[item]);
|
|
});
|
|
const r7 = env12443[204];
|
|
const r8 = Object.create(r7.prototype);
|
|
const r10 = r7.call(r8, r3, "lab");
|
|
return r10 instanceof Object ? r10 : r8;
|
|
};
|
|
} else if (r13.length === 3) {
|
|
const r56 = r13.map(function(item) {
|
|
return item.lab();
|
|
});
|
|
c23832_0 = r56[0];
|
|
c23832_1 = r56[1];
|
|
c23832_2 = r56[2];
|
|
r44 = function a(c31162_0) {
|
|
const r3 = [0, 1, 2].map(function(item) {
|
|
return (1 - c31162_0) * (1 - c31162_0) * c23832_0[item] + 2 * (1 - c31162_0) * c31162_0 * c23832_1[item] + c31162_0 * c31162_0 * c23832_2[item];
|
|
});
|
|
const r7 = env12443[204];
|
|
const r8 = Object.create(r7.prototype);
|
|
const r10 = r7.call(r8, r3, "lab");
|
|
return r10 instanceof Object ? r10 : r8;
|
|
};
|
|
} else if (r13.length === 4) {
|
|
const r48 = r13.map(function(item) {
|
|
return item.lab();
|
|
});
|
|
c23832_0 = r48[0];
|
|
c23832_1 = r48[1];
|
|
c23832_2 = r48[2];
|
|
c23832_3 = r48[3];
|
|
r44 = function a(c31163_0) {
|
|
const r3 = [0, 1, 2].map(function(item) {
|
|
return (1 - c31163_0) * (1 - c31163_0) * (1 - c31163_0) * c23832_0[item] + 3 * (1 - c31163_0) * (1 - c31163_0) * c31163_0 * c23832_1[item] + 3 * (1 - c31163_0) * c31163_0 * c31163_0 * c23832_2[item] + c31163_0 * c31163_0 * c31163_0 * c23832_3[item];
|
|
});
|
|
const r7 = env12443[204];
|
|
const r8 = Object.create(r7.prototype);
|
|
const r10 = r7.call(r8, r3, "lab");
|
|
return r10 instanceof Object ? r10 : r8;
|
|
};
|
|
} else {
|
|
if (!(r13.length >= 5)) {
|
|
throw new RangeError("No point in running bezier with only one color.");
|
|
}
|
|
c23832_4 = r13.map(function(item) {
|
|
return item.lab();
|
|
});
|
|
const r7 = r13.length - 1;
|
|
c23832_6 = r7;
|
|
let r36 = [1, 1];
|
|
let r37 = 1;
|
|
let r38 = r36;
|
|
while (r37 < r7) {
|
|
const r39 = [1];
|
|
const r40 = 1 <= r36.length;
|
|
const r6 = r37;
|
|
const r15 = r36;
|
|
let r0 = 1;
|
|
if (r40) {
|
|
do {
|
|
let r16 = r15[r0];
|
|
const r1 = r0;
|
|
if (!r16) {
|
|
r16 = 0;
|
|
}
|
|
r39[r1] = r16 + r15[r1 - 1];
|
|
r0 = r1 + 1;
|
|
} while (r0 <= r15.length);
|
|
}
|
|
r37 = r6 + 1;
|
|
r36 = r39;
|
|
r38 = r36;
|
|
}
|
|
c23832_5 = r38;
|
|
r44 = function a(a0) {
|
|
let c31164_1 = 1 - a0;
|
|
const r4 = [0, 1, 2].map(function(c31851_0) {
|
|
return c23832_4.reduce(function(acc, item, index) {
|
|
return acc + c23832_5[index] * Math.pow(c31164_1, c23832_6 - index) * Math.pow(a0, index) * item[c31851_0];
|
|
}, 0);
|
|
});
|
|
const r9 = env12443[204];
|
|
const r10 = Object.create(r9.prototype);
|
|
const r12 = r9.call(r10, r4, "lab");
|
|
return r12 instanceof Object ? r12 : r10;
|
|
};
|
|
}
|
|
let c23833_0 = r44;
|
|
r44.scale = function() {
|
|
return (0, env12443[205])(c23833_0);
|
|
};
|
|
return r44;
|
|
};
|
|
chroma$k.blend = blend;
|
|
chroma$k.cubehelix = function(a0, a1, a2, a3, a4) {
|
|
let c23834_5, c23834_7;
|
|
let c23834_0 = a0;
|
|
let c23834_1 = a1;
|
|
let c23834_2 = a2;
|
|
let c23834_3 = a3;
|
|
let r6 = a4;
|
|
let c23834_4 = a4;
|
|
if (a0 === void 0) {
|
|
c23834_0 = 300;
|
|
}
|
|
if (a1 === void 0) {
|
|
c23834_1 = -1.5;
|
|
}
|
|
if (a2 === void 0) {
|
|
c23834_2 = 1;
|
|
}
|
|
if (a3 === void 0) {
|
|
c23834_3 = 1;
|
|
}
|
|
if (a4 === void 0) {
|
|
const r12 = [0, 1];
|
|
c23834_4 = r12;
|
|
r6 = r12;
|
|
}
|
|
let c23834_6 = 0;
|
|
if ((env12443[0][Object.prototype.toString.call(r6)] || "object") === "array") {
|
|
c23834_5 = c23834_4[1] - c23834_4[0];
|
|
} else {
|
|
c23834_5 = 0;
|
|
const r26 = c23834_4;
|
|
c23834_4 = [r26, r26];
|
|
}
|
|
const r33 = function f(a0) {
|
|
const r7 = env12443[210];
|
|
const r4 = (c23834_0 + 120) / 360 + c23834_1 * a0;
|
|
const r25 = (0, env12443[211])(c23834_4[0] + c23834_5 * a0, c23834_3);
|
|
const r28 = c23834_6 !== 0 ? c23834_2[0] + a0 * c23834_6 : c23834_2;
|
|
const r1 = r7 * r4;
|
|
const r36 = r28 * r25 * (1 - r25) / 2;
|
|
const r38 = (0, env12443[213])(r1);
|
|
const r40 = (0, env12443[212])(r1);
|
|
const r41 = env12443[214];
|
|
const r42 = env12443[209];
|
|
const r51 = [255 * (r25 + r36 * (-0.14861 * r38 + 1.78277 * r40)), 255 * (r25 + r36 * (-0.29227 * r38 - 0.90649 * r40)), 255 * (r25 + r36 * (1.97294 * r38)), 1];
|
|
r42(r51);
|
|
return r41(r51);
|
|
};
|
|
c23834_7 = r33;
|
|
r33.start = function(a0) {
|
|
let r3;
|
|
if (a0 == null) {
|
|
r3 = c23834_0;
|
|
} else {
|
|
c23834_0 = a0;
|
|
r3 = c23834_7;
|
|
}
|
|
return r3;
|
|
};
|
|
r33.rotations = function(a0) {
|
|
let r3;
|
|
if (a0 == null) {
|
|
r3 = c23834_1;
|
|
} else {
|
|
c23834_1 = a0;
|
|
r3 = c23834_7;
|
|
}
|
|
return r3;
|
|
};
|
|
r33.gamma = function(a0) {
|
|
let r3;
|
|
if (a0 == null) {
|
|
r3 = c23834_3;
|
|
} else {
|
|
c23834_3 = a0;
|
|
r3 = c23834_7;
|
|
}
|
|
return r3;
|
|
};
|
|
r33.hue = function(a0) {
|
|
let r25;
|
|
if (a0 == null) {
|
|
r25 = c23834_2;
|
|
} else {
|
|
const r4 = env12443[208];
|
|
c23834_2 = a0;
|
|
if ((env12443[0][Object.prototype.toString.call(a0)] || "object") === "array") {
|
|
const r21 = c23834_2[1] - c23834_2[0];
|
|
c23834_6 = r21;
|
|
if (r21 == 0) {
|
|
c23834_2 = c23834_2[1];
|
|
}
|
|
} else {
|
|
c23834_6 = 0;
|
|
}
|
|
r25 = c23834_7;
|
|
}
|
|
return r25;
|
|
};
|
|
r33.lightness = function(a0) {
|
|
let r21;
|
|
if (a0 == null) {
|
|
r21 = c23834_4;
|
|
} else {
|
|
if ((env12443[0][Object.prototype.toString.call(a0)] || "object") === "array") {
|
|
c23834_4 = a0;
|
|
c23834_5 = a0[1] - a0[0];
|
|
} else {
|
|
c23834_4 = [a0, a0];
|
|
c23834_5 = 0;
|
|
}
|
|
r21 = c23834_7;
|
|
}
|
|
return r21;
|
|
};
|
|
r33.scale = function() {
|
|
return env12443[214].scale(c23834_7);
|
|
};
|
|
r33.hue(c23834_2);
|
|
return r33;
|
|
};
|
|
chroma$k.interpolate = mix$1;
|
|
chroma$k.mix = mix$1;
|
|
chroma$k.random = function() {
|
|
let r8 = "#";
|
|
let r0 = 0;
|
|
while (true) {
|
|
const r15 = r8 + "0123456789abcdef".charAt((0, env12443[216])(16 * (0, env12443[217])()));
|
|
r0 = r0 + 1;
|
|
r8 = r15;
|
|
if (!(r0 < 6)) {
|
|
const r16 = env12443[215];
|
|
const r17 = Object.create(r16.prototype);
|
|
const r19 = r16.call(r17, r15, "hex");
|
|
return r19 instanceof Object ? r19 : r17;
|
|
}
|
|
}
|
|
};
|
|
chroma$k.scale = scale$2;
|
|
chroma$k.analyze = analyze;
|
|
chroma$k.contrast = function(a0, a1) {
|
|
const r5 = env12443[225];
|
|
const r3 = Object.create(r5.prototype);
|
|
const r7 = r5.call(r3, a0);
|
|
const r8 = r7 instanceof Object ? r7 : r3;
|
|
const r4 = Object.create(r5.prototype);
|
|
const r10 = r5.call(r4, a1);
|
|
const r11 = r10 instanceof Object ? r10 : r4;
|
|
const r13 = r8.luminance();
|
|
const r15 = r11.luminance();
|
|
return r13 > r15 ? (r13 + 0.05) / (r15 + 0.05) : (r15 + 0.05) / (r13 + 0.05);
|
|
};
|
|
chroma$k.deltaE = function(a0, a1, a2, a3, a4) {
|
|
const r27 = a2 === void 0 ? 1 : a2;
|
|
const r25 = a3 === void 0 ? 1 : a3;
|
|
const r23 = a4 === void 0 ? 1 : a4;
|
|
const r21 = env12443[226];
|
|
const r26 = Object.create(r21.prototype);
|
|
const r35 = r21.call(r26, a0);
|
|
const r29 = r35 instanceof Object ? r35 : r26;
|
|
const r36 = Object.create(r21.prototype);
|
|
const r37 = r21.call(r36, a1);
|
|
const r38 = r37 instanceof Object ? r37 : r36;
|
|
const r43 = Array.from(r29.lab());
|
|
const r31 = r43[0];
|
|
const r44 = r43[1];
|
|
const r45 = r43[2];
|
|
const r50 = Array.from(r38.lab());
|
|
const r51 = r50[0];
|
|
const r52 = r50[1];
|
|
const r32 = r50[2];
|
|
const r5 = (r31 + r51) / 2;
|
|
const r54 = env12443[227];
|
|
const r55 = env12443[228];
|
|
const r7 = (r54(r55(r44, 2) + r55(r45, 2)) + r54(r55(r52, 2) + r55(r32, 2))) / 2;
|
|
const r70 = 1 + 0.5 * (1 - r54(r55(r7, 7) / (r55(r7, 7) + r55(25, 7))));
|
|
const r71 = r44 * r70;
|
|
const r72 = r52 * r70;
|
|
const r76 = r54(r55(r71, 2) + r55(r45, 2));
|
|
const r80 = r54(r55(r72, 2) + r55(r32, 2));
|
|
const r15 = (r76 + r80) / 2;
|
|
const r82 = env12443[231];
|
|
const r1 = 360 * r82(r45, r71);
|
|
const r84 = env12443[236];
|
|
const r2 = r1 / (2 * r84);
|
|
const r87 = 360 * r82(r32, r72);
|
|
const r88 = 2 * r84;
|
|
let r11 = r2;
|
|
if (!(0 <= r11)) {
|
|
r11 = r2 + 360;
|
|
}
|
|
const r90 = r87 / r88;
|
|
let r4 = r90;
|
|
if (!(0 <= r4)) {
|
|
r4 = r90 + 360;
|
|
}
|
|
const r91 = env12443[232];
|
|
const r8 = r91(r11 - r4) > 180 ? (r11 + r4 + 360) / 2 : (r11 + r4) / 2;
|
|
const r97 = env12443[233];
|
|
const r104 = 0.17 * r97(2 * r84 * (r8 - 30) / 360);
|
|
const r17 = 0.24 * r97(2 * r84 * (2 * r8) / 360);
|
|
const r119 = 0.32 * r97(2 * r84 * (3 * r8 + 6) / 360);
|
|
const r128 = 0.2 * r97(2 * r84 * (4 * r8 - 63) / 360);
|
|
const r129 = r4 - r11;
|
|
const r131 = r91(r129) <= 180 ? r129 : r4 <= r11 ? r129 + 360 : r129 - 360;
|
|
const r136 = 1 - r104 + r17 + r119 - r128;
|
|
const r139 = 2 * r54(r76 * r80);
|
|
const r140 = env12443[234];
|
|
const r146 = r139 * r140(2 * r84 * r131 / 360 / 2);
|
|
const r147 = r51 - r31;
|
|
const r148 = r80 - r76;
|
|
const r150 = r5 - 50;
|
|
const r158 = 0.015 * r55(r150, 2) / r54(20 + r55(r150, 2));
|
|
const r161 = 1 + 0.045 * r15;
|
|
const r164 = 1 + 0.015 * r15 * r136;
|
|
const r172 = 30 * (0, env12443[235])(-r55((r8 - 275) / 25, 2));
|
|
const r186 = -2 * r54(r55(r15, 7) / (r55(r15, 7) + r55(25, 7))) * r140(2 * (2 * r84 * r172 / 360));
|
|
return (0, env12443[230])(0, (0, env12443[229])(100, r54(r55(r147 / (r27 * (1 + r158)), 2) + r55(r148 / (r25 * r161), 2) + r55(r146 / (r23 * r164), 2) + r186 * (r148 / (r25 * r161)) * (r146 / (r23 * r164)))));
|
|
};
|
|
chroma$k.distance = function(a0, a1, a2) {
|
|
let r1;
|
|
const r9 = a2 === void 0 ? "lab" : a2;
|
|
const r14 = env12443[237];
|
|
const r10 = Object.create(r14.prototype);
|
|
const r15 = r14.call(r10, a0);
|
|
const r16 = r15 instanceof Object ? r15 : r10;
|
|
const r17 = Object.create(r14.prototype);
|
|
const r18 = r14.call(r17, a1);
|
|
const r19 = r18 instanceof Object ? r18 : r17;
|
|
const r21 = r16.get(r9);
|
|
const r23 = r19.get(r9);
|
|
let r0 = 0;
|
|
let r3 = 0;
|
|
for (const key in r21) {
|
|
r1 = r0;
|
|
r3 = r1;
|
|
const r28 = (r21[key] || 0) - (r23[key] || 0);
|
|
r0 = r1 + r28 * r28;
|
|
}
|
|
r1 = r0;
|
|
r3 = r1;
|
|
return Math.sqrt(r3);
|
|
};
|
|
chroma$k.limits = limits;
|
|
chroma$k.valid = function() {
|
|
let r12;
|
|
const r5 = [];
|
|
const r10 = +arguments.length;
|
|
let r1 = r10 - 1;
|
|
if (r10) {
|
|
do {
|
|
r5[r1] = arguments[r1];
|
|
r12 = +r1;
|
|
r1 = r12 - 1;
|
|
} while (r12);
|
|
}
|
|
try {
|
|
new (Function.prototype.bind.apply(env12443[238], [null].concat(r5)))();
|
|
} catch ($e) {
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
chroma$k.scales = scales;
|
|
chroma$k.colors = colors;
|
|
chroma$k.brewer = brewer;
|
|
return chroma$k;
|
|
};
|
|
if (typeof exports === "object" && module !== void 0) {
|
|
module.exports = n();
|
|
} else if (typeof globalThis.define === "function" && define.amd) {
|
|
define(n);
|
|
} else {
|
|
(typeof globalThis.globalThis !== "undefined" ? globalThis.globalThis : this).chroma = n();
|
|
}
|