@likec4/core 1.47.0 → 1.48.0

package/dist/_chunks/libs/@mantine/colors-generator.mjs

@@ -0,0 +1,3416 @@
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/utils/limit.js
+const { min: min$4, max: max$4 } = Math;
+var limit_default = (x, low = 0, high = 1) => {
+	return min$4(max$4(low, x), high);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/utils/clip_rgb.js
+var clip_rgb_default = (rgb) => {
+	rgb._clipped = false;
+	rgb._unclipped = rgb.slice(0);
+	for (let i = 0; i <= 3; i++) if (i < 3) {
+		if (rgb[i] < 0 || rgb[i] > 255) rgb._clipped = true;
+		rgb[i] = limit_default(rgb[i], 0, 255);
+	} else if (i === 3) rgb[i] = limit_default(rgb[i], 0, 1);
+	return rgb;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/utils/type.js
+const classToType = {};
+for (let name of [
+	"Boolean",
+	"Number",
+	"String",
+	"Function",
+	"Array",
+	"Date",
+	"RegExp",
+	"Undefined",
+	"Null"
+]) classToType[`[object ${name}]`] = name.toLowerCase();
+function type_default(obj) {
+	return classToType[Object.prototype.toString.call(obj)] || "object";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/utils/unpack.js
+var unpack_default = (args, keyOrder = null) => {
+	if (args.length >= 3) return Array.prototype.slice.call(args);
+	if (type_default(args[0]) == "object" && keyOrder) return keyOrder.split("").filter((k) => args[0][k] !== void 0).map((k) => args[0][k]);
+	return args[0].slice(0);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/utils/last.js
+var last_default = (args) => {
+	if (args.length < 2) return null;
+	const l = args.length - 1;
+	if (type_default(args[l]) == "string") return args[l].toLowerCase();
+	return null;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/utils/index.js
+const { PI: PI$2, min: min$3, max: max$3 } = Math;
+const rnd2 = (a) => Math.round(a * 100) / 100;
+const rnd3 = (a) => Math.round(a * 100) / 100;
+const TWOPI = PI$2 * 2;
+const PITHIRD = PI$2 / 3;
+const DEG2RAD = PI$2 / 180;
+const RAD2DEG = 180 / PI$2;
+/**
+* Reverse the first three elements of an array
+*
+* @param {any[]} arr
+* @returns {any[]}
+*/
+function reverse3(arr) {
+	return [...arr.slice(0, 3).reverse(), ...arr.slice(3)];
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/input.js
+var input_default = {
+	format: {},
+	autodetect: []
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/Color.js
+var Color = class {
+	constructor(...args) {
+		const me = this;
+		if (type_default(args[0]) === "object" && args[0].constructor && args[0].constructor === this.constructor) return args[0];
+		let mode = last_default(args);
+		let autodetect = false;
+		if (!mode) {
+			autodetect = true;
+			if (!input_default.sorted) {
+				input_default.autodetect = input_default.autodetect.sort((a, b) => b.p - a.p);
+				input_default.sorted = true;
+			}
+			for (let chk of input_default.autodetect) {
+				mode = chk.test(...args);
+				if (mode) break;
+			}
+		}
+		if (input_default.format[mode]) me._rgb = clip_rgb_default(input_default.format[mode].apply(null, autodetect ? args : args.slice(0, -1)));
+		else throw new Error("unknown format: " + args);
+		if (me._rgb.length === 3) me._rgb.push(1);
+	}
+	toString() {
+		if (type_default(this.hex) == "function") return this.hex();
+		return `[${this._rgb.join(",")}]`;
+	}
+};
+var Color_default = Color;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/version.js
+const version = "3.2.0";
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/chroma.js
+const chroma = (...args) => {
+	return new Color_default(...args);
+};
+chroma.version = version;
+var chroma_default = chroma;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/colors/w3cx11.js
+/**
+X11 color names
+
+http://www.w3.org/TR/css3-color/#svg-color
+*/
+const w3cx11 = {
+	aliceblue: "#f0f8ff",
+	antiquewhite: "#faebd7",
+	aqua: "#00ffff",
+	aquamarine: "#7fffd4",
+	azure: "#f0ffff",
+	beige: "#f5f5dc",
+	bisque: "#ffe4c4",
+	black: "#000000",
+	blanchedalmond: "#ffebcd",
+	blue: "#0000ff",
+	blueviolet: "#8a2be2",
+	brown: "#a52a2a",
+	burlywood: "#deb887",
+	cadetblue: "#5f9ea0",
+	chartreuse: "#7fff00",
+	chocolate: "#d2691e",
+	coral: "#ff7f50",
+	cornflowerblue: "#6495ed",
+	cornsilk: "#fff8dc",
+	crimson: "#dc143c",
+	cyan: "#00ffff",
+	darkblue: "#00008b",
+	darkcyan: "#008b8b",
+	darkgoldenrod: "#b8860b",
+	darkgray: "#a9a9a9",
+	darkgreen: "#006400",
+	darkgrey: "#a9a9a9",
+	darkkhaki: "#bdb76b",
+	darkmagenta: "#8b008b",
+	darkolivegreen: "#556b2f",
+	darkorange: "#ff8c00",
+	darkorchid: "#9932cc",
+	darkred: "#8b0000",
+	darksalmon: "#e9967a",
+	darkseagreen: "#8fbc8f",
+	darkslateblue: "#483d8b",
+	darkslategray: "#2f4f4f",
+	darkslategrey: "#2f4f4f",
+	darkturquoise: "#00ced1",
+	darkviolet: "#9400d3",
+	deeppink: "#ff1493",
+	deepskyblue: "#00bfff",
+	dimgray: "#696969",
+	dimgrey: "#696969",
+	dodgerblue: "#1e90ff",
+	firebrick: "#b22222",
+	floralwhite: "#fffaf0",
+	forestgreen: "#228b22",
+	fuchsia: "#ff00ff",
+	gainsboro: "#dcdcdc",
+	ghostwhite: "#f8f8ff",
+	gold: "#ffd700",
+	goldenrod: "#daa520",
+	gray: "#808080",
+	green: "#008000",
+	greenyellow: "#adff2f",
+	grey: "#808080",
+	honeydew: "#f0fff0",
+	hotpink: "#ff69b4",
+	indianred: "#cd5c5c",
+	indigo: "#4b0082",
+	ivory: "#fffff0",
+	khaki: "#f0e68c",
+	laserlemon: "#ffff54",
+	lavender: "#e6e6fa",
+	lavenderblush: "#fff0f5",
+	lawngreen: "#7cfc00",
+	lemonchiffon: "#fffacd",
+	lightblue: "#add8e6",
+	lightcoral: "#f08080",
+	lightcyan: "#e0ffff",
+	lightgoldenrod: "#fafad2",
+	lightgoldenrodyellow: "#fafad2",
+	lightgray: "#d3d3d3",
+	lightgreen: "#90ee90",
+	lightgrey: "#d3d3d3",
+	lightpink: "#ffb6c1",
+	lightsalmon: "#ffa07a",
+	lightseagreen: "#20b2aa",
+	lightskyblue: "#87cefa",
+	lightslategray: "#778899",
+	lightslategrey: "#778899",
+	lightsteelblue: "#b0c4de",
+	lightyellow: "#ffffe0",
+	lime: "#00ff00",
+	limegreen: "#32cd32",
+	linen: "#faf0e6",
+	magenta: "#ff00ff",
+	maroon: "#800000",
+	maroon2: "#7f0000",
+	maroon3: "#b03060",
+	mediumaquamarine: "#66cdaa",
+	mediumblue: "#0000cd",
+	mediumorchid: "#ba55d3",
+	mediumpurple: "#9370db",
+	mediumseagreen: "#3cb371",
+	mediumslateblue: "#7b68ee",
+	mediumspringgreen: "#00fa9a",
+	mediumturquoise: "#48d1cc",
+	mediumvioletred: "#c71585",
+	midnightblue: "#191970",
+	mintcream: "#f5fffa",
+	mistyrose: "#ffe4e1",
+	moccasin: "#ffe4b5",
+	navajowhite: "#ffdead",
+	navy: "#000080",
+	oldlace: "#fdf5e6",
+	olive: "#808000",
+	olivedrab: "#6b8e23",
+	orange: "#ffa500",
+	orangered: "#ff4500",
+	orchid: "#da70d6",
+	palegoldenrod: "#eee8aa",
+	palegreen: "#98fb98",
+	paleturquoise: "#afeeee",
+	palevioletred: "#db7093",
+	papayawhip: "#ffefd5",
+	peachpuff: "#ffdab9",
+	peru: "#cd853f",
+	pink: "#ffc0cb",
+	plum: "#dda0dd",
+	powderblue: "#b0e0e6",
+	purple: "#800080",
+	purple2: "#7f007f",
+	purple3: "#a020f0",
+	rebeccapurple: "#663399",
+	red: "#ff0000",
+	rosybrown: "#bc8f8f",
+	royalblue: "#4169e1",
+	saddlebrown: "#8b4513",
+	salmon: "#fa8072",
+	sandybrown: "#f4a460",
+	seagreen: "#2e8b57",
+	seashell: "#fff5ee",
+	sienna: "#a0522d",
+	silver: "#c0c0c0",
+	skyblue: "#87ceeb",
+	slateblue: "#6a5acd",
+	slategray: "#708090",
+	slategrey: "#708090",
+	snow: "#fffafa",
+	springgreen: "#00ff7f",
+	steelblue: "#4682b4",
+	tan: "#d2b48c",
+	teal: "#008080",
+	thistle: "#d8bfd8",
+	tomato: "#ff6347",
+	turquoise: "#40e0d0",
+	violet: "#ee82ee",
+	wheat: "#f5deb3",
+	white: "#ffffff",
+	whitesmoke: "#f5f5f5",
+	yellow: "#ffff00",
+	yellowgreen: "#9acd32"
+};
+var w3cx11_default = w3cx11;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/hex/hex2rgb.js
+const RE_HEX = /^#?([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/;
+const RE_HEXA = /^#?([A-Fa-f0-9]{8}|[A-Fa-f0-9]{4})$/;
+const hex2rgb = (hex) => {
+	if (hex.match(RE_HEX)) {
+		if (hex.length === 4 || hex.length === 7) hex = hex.substr(1);
+		if (hex.length === 3) {
+			hex = hex.split("");
+			hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+		}
+		const u = parseInt(hex, 16);
+		return [
+			u >> 16,
+			u >> 8 & 255,
+			u & 255,
+			1
+		];
+	}
+	if (hex.match(RE_HEXA)) {
+		if (hex.length === 5 || hex.length === 9) hex = hex.substr(1);
+		if (hex.length === 4) {
+			hex = hex.split("");
+			hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2] + hex[3] + hex[3];
+		}
+		const u = parseInt(hex, 16);
+		return [
+			u >> 24 & 255,
+			u >> 16 & 255,
+			u >> 8 & 255,
+			Math.round((u & 255) / 255 * 100) / 100
+		];
+	}
+	throw new Error(`unknown hex color: ${hex}`);
+};
+var hex2rgb_default = hex2rgb;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/hex/rgb2hex.js
+const { round: round$5 } = Math;
+const rgb2hex = (...args) => {
+	let [r, g, b, a] = unpack_default(args, "rgba");
+	let mode = last_default(args) || "auto";
+	if (a === void 0) a = 1;
+	if (mode === "auto") mode = a < 1 ? "rgba" : "rgb";
+	r = round$5(r);
+	g = round$5(g);
+	b = round$5(b);
+	let str = "000000" + (r << 16 | g << 8 | b).toString(16);
+	str = str.substr(str.length - 6);
+	let hxa = "0" + round$5(a * 255).toString(16);
+	hxa = hxa.substr(hxa.length - 2);
+	switch (mode.toLowerCase()) {
+		case "rgba": return `#${str}${hxa}`;
+		case "argb": return `#${hxa}${str}`;
+		default: return `#${str}`;
+	}
+};
+var rgb2hex_default = rgb2hex;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/named/index.js
+Color_default.prototype.name = function() {
+	const hex = rgb2hex_default(this._rgb, "rgb");
+	for (let n of Object.keys(w3cx11_default)) if (w3cx11_default[n] === hex) return n.toLowerCase();
+	return hex;
+};
+input_default.format.named = (name) => {
+	name = name.toLowerCase();
+	if (w3cx11_default[name]) return hex2rgb_default(w3cx11_default[name]);
+	throw new Error("unknown color name: " + name);
+};
+input_default.autodetect.push({
+	p: 5,
+	test: (h, ...rest) => {
+		if (!rest.length && type_default(h) === "string" && w3cx11_default[h.toLowerCase()]) return "named";
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/ops/alpha.js
+Color_default.prototype.alpha = function(a, mutate = false) {
+	if (a !== void 0 && type_default(a) === "number") {
+		if (mutate) {
+			this._rgb[3] = a;
+			return this;
+		}
+		return new Color_default([
+			this._rgb[0],
+			this._rgb[1],
+			this._rgb[2],
+			a
+		], "rgb");
+	}
+	return this._rgb[3];
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/ops/clipped.js
+Color_default.prototype.clipped = function() {
+	return this._rgb._clipped || false;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/lab/lab-constants.js
+const labConstants = {
+	Kn: 18,
+	labWhitePoint: "d65",
+	Xn: .95047,
+	Yn: 1,
+	Zn: 1.08883,
+	t0: .137931034,
+	t1: .206896552,
+	t2: .12841855,
+	t3: .008856452,
+	kE: 216 / 24389,
+	kKE: 8,
+	kK: 24389 / 27,
+	RefWhiteRGB: {
+		X: .95047,
+		Y: 1,
+		Z: 1.08883
+	},
+	MtxRGB2XYZ: {
+		m00: .4124564390896922,
+		m01: .21267285140562253,
+		m02: .0193338955823293,
+		m10: .357576077643909,
+		m11: .715152155287818,
+		m12: .11919202588130297,
+		m20: .18043748326639894,
+		m21: .07217499330655958,
+		m22: .9503040785363679
+	},
+	MtxXYZ2RGB: {
+		m00: 3.2404541621141045,
+		m01: -.9692660305051868,
+		m02: .055643430959114726,
+		m10: -1.5371385127977166,
+		m11: 1.8760108454466942,
+		m12: -.2040259135167538,
+		m20: -.498531409556016,
+		m21: .041556017530349834,
+		m22: 1.0572251882231791
+	},
+	As: .9414285350000001,
+	Bs: 1.040417467,
+	Cs: 1.089532651,
+	MtxAdaptMa: {
+		m00: .8951,
+		m01: -.7502,
+		m02: .0389,
+		m10: .2664,
+		m11: 1.7135,
+		m12: -.0685,
+		m20: -.1614,
+		m21: .0367,
+		m22: 1.0296
+	},
+	MtxAdaptMaI: {
+		m00: .9869929054667123,
+		m01: .43230526972339456,
+		m02: -.008528664575177328,
+		m10: -.14705425642099013,
+		m11: .5183602715367776,
+		m12: .04004282165408487,
+		m20: .15996265166373125,
+		m21: .0492912282128556,
+		m22: .9684866957875502
+	}
+};
+var lab_constants_default = labConstants;
+const ILLUMINANTS = new Map([
+	["a", [1.0985, .35585]],
+	["b", [1.0985, .35585]],
+	["c", [.98074, 1.18232]],
+	["d50", [.96422, .82521]],
+	["d55", [.95682, .92149]],
+	["d65", [.95047, 1.08883]],
+	["e", [
+		1,
+		1,
+		1
+	]],
+	["f2", [.99186, .67393]],
+	["f7", [.95041, 1.08747]],
+	["f11", [1.00962, .6435]],
+	["icc", [.96422, .82521]]
+]);
+function setLabWhitePoint(name) {
+	const ill = ILLUMINANTS.get(String(name).toLowerCase());
+	if (!ill) throw new Error("unknown Lab illuminant " + name);
+	labConstants.labWhitePoint = name;
+	labConstants.Xn = ill[0];
+	labConstants.Zn = ill[1];
+}
+function getLabWhitePoint() {
+	return labConstants.labWhitePoint;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/lab/lab2rgb.js
+const lab2rgb = (...args) => {
+	args = unpack_default(args, "lab");
+	const [L, a, b] = args;
+	const [x, y, z] = lab2xyz(L, a, b);
+	const [r, g, b_] = xyz2rgb(x, y, z);
+	return [
+		r,
+		g,
+		b_,
+		args.length > 3 ? args[3] : 1
+	];
+};
+const lab2xyz = (L, a, b) => {
+	const { kE, kK, kKE, Xn, Yn, Zn } = lab_constants_default;
+	const fy = (L + 16) / 116;
+	const fx = .002 * a + fy;
+	const fz = fy - .005 * b;
+	const fx3 = fx * fx * fx;
+	const fz3 = fz * fz * fz;
+	const xr = fx3 > kE ? fx3 : (116 * fx - 16) / kK;
+	const yr = L > kKE ? Math.pow((L + 16) / 116, 3) : L / kK;
+	const zr = fz3 > kE ? fz3 : (116 * fz - 16) / kK;
+	return [
+		xr * Xn,
+		yr * Yn,
+		zr * Zn
+	];
+};
+const compand = (linear) => {
+	const sign = Math.sign(linear);
+	linear = Math.abs(linear);
+	return (linear <= .0031308 ? linear * 12.92 : 1.055 * Math.pow(linear, 1 / 2.4) - .055) * sign;
+};
+const xyz2rgb = (x, y, z) => {
+	const { MtxAdaptMa, MtxAdaptMaI, MtxXYZ2RGB, RefWhiteRGB, Xn, Yn, Zn } = lab_constants_default;
+	const As = Xn * MtxAdaptMa.m00 + Yn * MtxAdaptMa.m10 + Zn * MtxAdaptMa.m20;
+	const Bs = Xn * MtxAdaptMa.m01 + Yn * MtxAdaptMa.m11 + Zn * MtxAdaptMa.m21;
+	const Cs = Xn * MtxAdaptMa.m02 + Yn * MtxAdaptMa.m12 + Zn * MtxAdaptMa.m22;
+	const Ad = RefWhiteRGB.X * MtxAdaptMa.m00 + RefWhiteRGB.Y * MtxAdaptMa.m10 + RefWhiteRGB.Z * MtxAdaptMa.m20;
+	const Bd = RefWhiteRGB.X * MtxAdaptMa.m01 + RefWhiteRGB.Y * MtxAdaptMa.m11 + RefWhiteRGB.Z * MtxAdaptMa.m21;
+	const Cd = RefWhiteRGB.X * MtxAdaptMa.m02 + RefWhiteRGB.Y * MtxAdaptMa.m12 + RefWhiteRGB.Z * MtxAdaptMa.m22;
+	const X1 = (x * MtxAdaptMa.m00 + y * MtxAdaptMa.m10 + z * MtxAdaptMa.m20) * (Ad / As);
+	const Y1 = (x * MtxAdaptMa.m01 + y * MtxAdaptMa.m11 + z * MtxAdaptMa.m21) * (Bd / Bs);
+	const Z1 = (x * MtxAdaptMa.m02 + y * MtxAdaptMa.m12 + z * MtxAdaptMa.m22) * (Cd / Cs);
+	const X2 = X1 * MtxAdaptMaI.m00 + Y1 * MtxAdaptMaI.m10 + Z1 * MtxAdaptMaI.m20;
+	const Y2 = X1 * MtxAdaptMaI.m01 + Y1 * MtxAdaptMaI.m11 + Z1 * MtxAdaptMaI.m21;
+	const Z2 = X1 * MtxAdaptMaI.m02 + Y1 * MtxAdaptMaI.m12 + Z1 * MtxAdaptMaI.m22;
+	const r = compand(X2 * MtxXYZ2RGB.m00 + Y2 * MtxXYZ2RGB.m10 + Z2 * MtxXYZ2RGB.m20);
+	const g = compand(X2 * MtxXYZ2RGB.m01 + Y2 * MtxXYZ2RGB.m11 + Z2 * MtxXYZ2RGB.m21);
+	const b = compand(X2 * MtxXYZ2RGB.m02 + Y2 * MtxXYZ2RGB.m12 + Z2 * MtxXYZ2RGB.m22);
+	return [
+		r * 255,
+		g * 255,
+		b * 255
+	];
+};
+var lab2rgb_default = lab2rgb;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/lab/rgb2lab.js
+const rgb2lab = (...args) => {
+	const [r, g, b, ...rest] = unpack_default(args, "rgb");
+	const [x, y, z] = rgb2xyz(r, g, b);
+	const [L, a, b_] = xyz2lab(x, y, z);
+	return [
+		L,
+		a,
+		b_,
+		...rest.length > 0 && rest[0] < 1 ? [rest[0]] : []
+	];
+};
+function xyz2lab(x, y, z) {
+	const { Xn, Yn, Zn, kE, kK } = lab_constants_default;
+	const xr = x / Xn;
+	const yr = y / Yn;
+	const zr = z / Zn;
+	const fx = xr > kE ? Math.pow(xr, 1 / 3) : (kK * xr + 16) / 116;
+	const fy = yr > kE ? Math.pow(yr, 1 / 3) : (kK * yr + 16) / 116;
+	const fz = zr > kE ? Math.pow(zr, 1 / 3) : (kK * zr + 16) / 116;
+	return [
+		116 * fy - 16,
+		500 * (fx - fy),
+		200 * (fy - fz)
+	];
+}
+function gammaAdjustSRGB(companded) {
+	const sign = Math.sign(companded);
+	companded = Math.abs(companded);
+	return (companded <= .04045 ? companded / 12.92 : Math.pow((companded + .055) / 1.055, 2.4)) * sign;
+}
+const rgb2xyz = (r, g, b) => {
+	r = gammaAdjustSRGB(r / 255);
+	g = gammaAdjustSRGB(g / 255);
+	b = gammaAdjustSRGB(b / 255);
+	const { MtxRGB2XYZ, MtxAdaptMa, MtxAdaptMaI, Xn, Yn, Zn, As, Bs, Cs } = lab_constants_default;
+	let x = r * MtxRGB2XYZ.m00 + g * MtxRGB2XYZ.m10 + b * MtxRGB2XYZ.m20;
+	let y = r * MtxRGB2XYZ.m01 + g * MtxRGB2XYZ.m11 + b * MtxRGB2XYZ.m21;
+	let z = r * MtxRGB2XYZ.m02 + g * MtxRGB2XYZ.m12 + b * MtxRGB2XYZ.m22;
+	const Ad = Xn * MtxAdaptMa.m00 + Yn * MtxAdaptMa.m10 + Zn * MtxAdaptMa.m20;
+	const Bd = Xn * MtxAdaptMa.m01 + Yn * MtxAdaptMa.m11 + Zn * MtxAdaptMa.m21;
+	const Cd = Xn * MtxAdaptMa.m02 + Yn * MtxAdaptMa.m12 + Zn * MtxAdaptMa.m22;
+	let X = x * MtxAdaptMa.m00 + y * MtxAdaptMa.m10 + z * MtxAdaptMa.m20;
+	let Y = x * MtxAdaptMa.m01 + y * MtxAdaptMa.m11 + z * MtxAdaptMa.m21;
+	let Z = x * MtxAdaptMa.m02 + y * MtxAdaptMa.m12 + z * MtxAdaptMa.m22;
+	X *= Ad / As;
+	Y *= Bd / Bs;
+	Z *= Cd / Cs;
+	x = X * MtxAdaptMaI.m00 + Y * MtxAdaptMaI.m10 + Z * MtxAdaptMaI.m20;
+	y = X * MtxAdaptMaI.m01 + Y * MtxAdaptMaI.m11 + Z * MtxAdaptMaI.m21;
+	z = X * MtxAdaptMaI.m02 + Y * MtxAdaptMaI.m12 + Z * MtxAdaptMaI.m22;
+	return [
+		x,
+		y,
+		z
+	];
+};
+var rgb2lab_default = rgb2lab;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/lab/index.js
+Color_default.prototype.lab = function() {
+	return rgb2lab_default(this._rgb);
+};
+const lab$1 = (...args) => new Color_default(...args, "lab");
+Object.assign(chroma_default, {
+	lab: lab$1,
+	getLabWhitePoint,
+	setLabWhitePoint
+});
+input_default.format.lab = lab2rgb_default;
+input_default.autodetect.push({
+	p: 2,
+	test: (...args) => {
+		args = unpack_default(args, "lab");
+		if (type_default(args) === "array" && args.length === 3) return "lab";
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/ops/darken.js
+Color_default.prototype.darken = function(amount = 1) {
+	const me = this;
+	const lab = me.lab();
+	lab[0] -= lab_constants_default.Kn * amount;
+	return new Color_default(lab, "lab").alpha(me.alpha(), true);
+};
+Color_default.prototype.brighten = function(amount = 1) {
+	return this.darken(-amount);
+};
+Color_default.prototype.darker = Color_default.prototype.darken;
+Color_default.prototype.brighter = Color_default.prototype.brighten;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/ops/get.js
+Color_default.prototype.get = function(mc) {
+	const [mode, channel] = mc.split(".");
+	const src = this[mode]();
+	if (channel) {
+		const i = mode.indexOf(channel) - (mode.substr(0, 2) === "ok" ? 2 : 0);
+		if (i > -1) return src[i];
+		throw new Error(`unknown channel ${channel} in mode ${mode}`);
+	} else return src;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/ops/luminance.js
+const { pow: pow$6 } = Math;
+const EPS = 1e-7;
+const MAX_ITER = 20;
+Color_default.prototype.luminance = function(lum, mode = "rgb") {
+	if (lum !== void 0 && type_default(lum) === "number") {
+		if (lum === 0) return new Color_default([
+			0,
+			0,
+			0,
+			this._rgb[3]
+		], "rgb");
+		if (lum === 1) return new Color_default([
+			255,
+			255,
+			255,
+			this._rgb[3]
+		], "rgb");
+		let cur_lum = this.luminance();
+		let max_iter = MAX_ITER;
+		const test = (low, high) => {
+			const mid = low.interpolate(high, .5, mode);
+			const lm = mid.luminance();
+			if (Math.abs(lum - lm) < EPS || !max_iter--) return mid;
+			return lm > lum ? test(low, mid) : test(mid, high);
+		};
+		return new Color_default([...(cur_lum > lum ? test(new Color_default([
+			0,
+			0,
+			0
+		]), this) : test(this, new Color_default([
+			255,
+			255,
+			255
+		]))).rgb(), this._rgb[3]]);
+	}
+	return rgb2luminance(...this._rgb.slice(0, 3));
+};
+const rgb2luminance = (r, g, b) => {
+	r = luminance_x(r);
+	g = luminance_x(g);
+	b = luminance_x(b);
+	return .2126 * r + .7152 * g + .0722 * b;
+};
+const luminance_x = (x) => {
+	x /= 255;
+	return x <= .03928 ? x / 12.92 : pow$6((x + .055) / 1.055, 2.4);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/interpolator/index.js
+var interpolator_default = {};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/generator/mix.js
+var mix_default = (col1, col2, f = .5, ...rest) => {
+	let mode = rest[0] || "lrgb";
+	if (!interpolator_default[mode] && !rest.length) mode = Object.keys(interpolator_default)[0];
+	if (!interpolator_default[mode]) throw new Error(`interpolation mode ${mode} is not defined`);
+	if (type_default(col1) !== "object") col1 = new Color_default(col1);
+	if (type_default(col2) !== "object") col2 = new Color_default(col2);
+	return interpolator_default[mode](col1, col2, f).alpha(col1.alpha() + f * (col2.alpha() - col1.alpha()));
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/ops/mix.js
+Color_default.prototype.mix = Color_default.prototype.interpolate = function(col2, f = .5, ...rest) {
+	return mix_default(this, col2, f, ...rest);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/ops/premultiply.js
+Color_default.prototype.premultiply = function(mutate = false) {
+	const rgb = this._rgb;
+	const a = rgb[3];
+	if (mutate) {
+		this._rgb = [
+			rgb[0] * a,
+			rgb[1] * a,
+			rgb[2] * a,
+			a
+		];
+		return this;
+	} else return new Color_default([
+		rgb[0] * a,
+		rgb[1] * a,
+		rgb[2] * a,
+		a
+	], "rgb");
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/lch/lch2lab.js
+const { sin: sin$3, cos: cos$4 } = Math;
+const lch2lab = (...args) => {
+	let [l, c, h] = unpack_default(args, "lch");
+	if (isNaN(h)) h = 0;
+	h = h * DEG2RAD;
+	return [
+		l,
+		cos$4(h) * c,
+		sin$3(h) * c
+	];
+};
+var lch2lab_default = lch2lab;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/lch/lch2rgb.js
+const lch2rgb = (...args) => {
+	args = unpack_default(args, "lch");
+	const [l, c, h] = args;
+	const [L, a, b_] = lch2lab_default(l, c, h);
+	const [r, g, b] = lab2rgb_default(L, a, b_);
+	return [
+		r,
+		g,
+		b,
+		args.length > 3 ? args[3] : 1
+	];
+};
+var lch2rgb_default = lch2rgb;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/lch/hcl2rgb.js
+const hcl2rgb = (...args) => {
+	return lch2rgb_default(...reverse3(unpack_default(args, "hcl")));
+};
+var hcl2rgb_default = hcl2rgb;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/lch/lab2lch.js
+const { sqrt: sqrt$4, atan2: atan2$2, round: round$4 } = Math;
+const lab2lch = (...args) => {
+	const [l, a, b] = unpack_default(args, "lab");
+	const c = sqrt$4(a * a + b * b);
+	let h = (atan2$2(b, a) * RAD2DEG + 360) % 360;
+	if (round$4(c * 1e4) === 0) h = NaN;
+	return [
+		l,
+		c,
+		h
+	];
+};
+var lab2lch_default = lab2lch;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/lch/rgb2lch.js
+const rgb2lch = (...args) => {
+	const [r, g, b, ...rest] = unpack_default(args, "rgb");
+	const [l, a, b_] = rgb2lab_default(r, g, b);
+	const [L, c, h] = lab2lch_default(l, a, b_);
+	return [
+		L,
+		c,
+		h,
+		...rest.length > 0 && rest[0] < 1 ? [rest[0]] : []
+	];
+};
+var rgb2lch_default = rgb2lch;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/lch/index.js
+Color_default.prototype.lch = function() {
+	return rgb2lch_default(this._rgb);
+};
+Color_default.prototype.hcl = function() {
+	return reverse3(rgb2lch_default(this._rgb));
+};
+const lch$1 = (...args) => new Color_default(...args, "lch");
+const hcl = (...args) => new Color_default(...args, "hcl");
+Object.assign(chroma_default, {
+	lch: lch$1,
+	hcl
+});
+input_default.format.lch = lch2rgb_default;
+input_default.format.hcl = hcl2rgb_default;
+["lch", "hcl"].forEach((m) => input_default.autodetect.push({
+	p: 2,
+	test: (...args) => {
+		args = unpack_default(args, m);
+		if (type_default(args) === "array" && args.length === 3) return m;
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/ops/saturate.js
+Color_default.prototype.saturate = function(amount = 1) {
+	const me = this;
+	const lch = me.lch();
+	lch[1] += lab_constants_default.Kn * amount;
+	if (lch[1] < 0) lch[1] = 0;
+	return new Color_default(lch, "lch").alpha(me.alpha(), true);
+};
+Color_default.prototype.desaturate = function(amount = 1) {
+	return this.saturate(-amount);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/ops/set.js
+Color_default.prototype.set = function(mc, value, mutate = false) {
+	const [mode, channel] = mc.split(".");
+	const src = this[mode]();
+	if (channel) {
+		const i = mode.indexOf(channel) - (mode.substr(0, 2) === "ok" ? 2 : 0);
+		if (i > -1) {
+			if (type_default(value) == "string") switch (value.charAt(0)) {
+				case "+":
+					src[i] += +value;
+					break;
+				case "-":
+					src[i] += +value;
+					break;
+				case "*":
+					src[i] *= +value.substr(1);
+					break;
+				case "/":
+					src[i] /= +value.substr(1);
+					break;
+				default: src[i] = +value;
+			}
+			else if (type_default(value) === "number") src[i] = value;
+			else throw new Error(`unsupported value for Color.set`);
+			const out = new Color_default(src, mode);
+			if (mutate) {
+				this._rgb = out._rgb;
+				return this;
+			}
+			return out;
+		}
+		throw new Error(`unknown channel ${channel} in mode ${mode}`);
+	} else return src;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/ops/shade.js
+Color_default.prototype.tint = function(f = .5, ...rest) {
+	return mix_default(this, "white", f, ...rest);
+};
+Color_default.prototype.shade = function(f = .5, ...rest) {
+	return mix_default(this, "black", f, ...rest);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/interpolator/rgb.js
+const rgb$1 = (col1, col2, f) => {
+	const xyz0 = col1._rgb;
+	const xyz1 = col2._rgb;
+	return new Color_default(xyz0[0] + f * (xyz1[0] - xyz0[0]), xyz0[1] + f * (xyz1[1] - xyz0[1]), xyz0[2] + f * (xyz1[2] - xyz0[2]), "rgb");
+};
+interpolator_default.rgb = rgb$1;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/interpolator/lrgb.js
+const { sqrt: sqrt$3, pow: pow$5 } = Math;
+const lrgb = (col1, col2, f) => {
+	const [x1, y1, z1] = col1._rgb;
+	const [x2, y2, z2] = col2._rgb;
+	return new Color_default(sqrt$3(pow$5(x1, 2) * (1 - f) + pow$5(x2, 2) * f), sqrt$3(pow$5(y1, 2) * (1 - f) + pow$5(y2, 2) * f), sqrt$3(pow$5(z1, 2) * (1 - f) + pow$5(z2, 2) * f), "rgb");
+};
+interpolator_default.lrgb = lrgb;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/interpolator/lab.js
+const lab = (col1, col2, f) => {
+	const xyz0 = col1.lab();
+	const xyz1 = col2.lab();
+	return new Color_default(xyz0[0] + f * (xyz1[0] - xyz0[0]), xyz0[1] + f * (xyz1[1] - xyz0[1]), xyz0[2] + f * (xyz1[2] - xyz0[2]), "lab");
+};
+interpolator_default.lab = lab;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/interpolator/_hsx.js
+var _hsx_default = (col1, col2, f, m) => {
+	let xyz0, xyz1;
+	if (m === "hsl") {
+		xyz0 = col1.hsl();
+		xyz1 = col2.hsl();
+	} else if (m === "hsv") {
+		xyz0 = col1.hsv();
+		xyz1 = col2.hsv();
+	} else if (m === "hcg") {
+		xyz0 = col1.hcg();
+		xyz1 = col2.hcg();
+	} else if (m === "hsi") {
+		xyz0 = col1.hsi();
+		xyz1 = col2.hsi();
+	} else if (m === "lch" || m === "hcl") {
+		m = "hcl";
+		xyz0 = col1.hcl();
+		xyz1 = col2.hcl();
+	} else if (m === "oklch") {
+		xyz0 = col1.oklch().reverse();
+		xyz1 = col2.oklch().reverse();
+	}
+	let hue0, hue1, sat0, sat1, lbv0, lbv1;
+	if (m.substr(0, 1) === "h" || m === "oklch") {
+		[hue0, sat0, lbv0] = xyz0;
+		[hue1, sat1, lbv1] = xyz1;
+	}
+	let sat, hue, lbv, dh;
+	if (!isNaN(hue0) && !isNaN(hue1)) {
+		if (hue1 > hue0 && hue1 - hue0 > 180) dh = hue1 - (hue0 + 360);
+		else if (hue1 < hue0 && hue0 - hue1 > 180) dh = hue1 + 360 - hue0;
+		else dh = hue1 - hue0;
+		hue = hue0 + f * dh;
+	} else if (!isNaN(hue0)) {
+		hue = hue0;
+		if ((lbv1 == 1 || lbv1 == 0) && m != "hsv") sat = sat0;
+	} else if (!isNaN(hue1)) {
+		hue = hue1;
+		if ((lbv0 == 1 || lbv0 == 0) && m != "hsv") sat = sat1;
+	} else hue = NaN;
+	if (sat === void 0) sat = sat0 + f * (sat1 - sat0);
+	lbv = lbv0 + f * (lbv1 - lbv0);
+	return m === "oklch" ? new Color_default([
+		lbv,
+		sat,
+		hue
+	], m) : new Color_default([
+		hue,
+		sat,
+		lbv
+	], m);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/interpolator/lch.js
+const lch = (col1, col2, f) => {
+	return _hsx_default(col1, col2, f, "lch");
+};
+interpolator_default.lch = lch;
+interpolator_default.hcl = lch;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/num/num2rgb.js
+const num2rgb = (num) => {
+	if (type_default(num) == "number" && num >= 0 && num <= 16777215) return [
+		num >> 16,
+		num >> 8 & 255,
+		num & 255,
+		1
+	];
+	throw new Error("unknown num color: " + num);
+};
+var num2rgb_default = num2rgb;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/num/rgb2num.js
+const rgb2num = (...args) => {
+	const [r, g, b] = unpack_default(args, "rgb");
+	return (r << 16) + (g << 8) + b;
+};
+var rgb2num_default = rgb2num;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/num/index.js
+Color_default.prototype.num = function() {
+	return rgb2num_default(this._rgb);
+};
+const num$1 = (...args) => new Color_default(...args, "num");
+Object.assign(chroma_default, { num: num$1 });
+input_default.format.num = num2rgb_default;
+input_default.autodetect.push({
+	p: 5,
+	test: (...args) => {
+		if (args.length === 1 && type_default(args[0]) === "number" && args[0] >= 0 && args[0] <= 16777215) return "num";
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/interpolator/num.js
+const num = (col1, col2, f) => {
+	const c1 = col1.num();
+	return new Color_default(c1 + f * (col2.num() - c1), "num");
+};
+interpolator_default.num = num;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/hcg/hcg2rgb.js
+const { floor: floor$3 } = Math;
+const hcg2rgb = (...args) => {
+	args = unpack_default(args, "hcg");
+	let [h, c, _g] = args;
+	let r, g, b;
+	_g = _g * 255;
+	const _c = c * 255;
+	if (c === 0) r = g = b = _g;
+	else {
+		if (h === 360) h = 0;
+		if (h > 360) h -= 360;
+		if (h < 0) h += 360;
+		h /= 60;
+		const i = floor$3(h);
+		const f = h - i;
+		const p = _g * (1 - c);
+		const q = p + _c * (1 - f);
+		const t = p + _c * f;
+		const v = p + _c;
+		switch (i) {
+			case 0:
+				[r, g, b] = [
+					v,
+					t,
+					p
+				];
+				break;
+			case 1:
+				[r, g, b] = [
+					q,
+					v,
+					p
+				];
+				break;
+			case 2:
+				[r, g, b] = [
+					p,
+					v,
+					t
+				];
+				break;
+			case 3:
+				[r, g, b] = [
+					p,
+					q,
+					v
+				];
+				break;
+			case 4:
+				[r, g, b] = [
+					t,
+					p,
+					v
+				];
+				break;
+			case 5:
+				[r, g, b] = [
+					v,
+					p,
+					q
+				];
+				break;
+		}
+	}
+	return [
+		r,
+		g,
+		b,
+		args.length > 3 ? args[3] : 1
+	];
+};
+var hcg2rgb_default = hcg2rgb;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/hcg/rgb2hcg.js
+const rgb2hcg = (...args) => {
+	const [r, g, b] = unpack_default(args, "rgb");
+	const minRgb = min$3(r, g, b);
+	const maxRgb = max$3(r, g, b);
+	const delta = maxRgb - minRgb;
+	const c = delta * 100 / 255;
+	const _g = minRgb / (255 - delta) * 100;
+	let h;
+	if (delta === 0) h = NaN;
+	else {
+		if (r === maxRgb) h = (g - b) / delta;
+		if (g === maxRgb) h = 2 + (b - r) / delta;
+		if (b === maxRgb) h = 4 + (r - g) / delta;
+		h *= 60;
+		if (h < 0) h += 360;
+	}
+	return [
+		h,
+		c,
+		_g
+	];
+};
+var rgb2hcg_default = rgb2hcg;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/hcg/index.js
+Color_default.prototype.hcg = function() {
+	return rgb2hcg_default(this._rgb);
+};
+const hcg$1 = (...args) => new Color_default(...args, "hcg");
+chroma_default.hcg = hcg$1;
+input_default.format.hcg = hcg2rgb_default;
+input_default.autodetect.push({
+	p: 1,
+	test: (...args) => {
+		args = unpack_default(args, "hcg");
+		if (type_default(args) === "array" && args.length === 3) return "hcg";
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/interpolator/hcg.js
+const hcg = (col1, col2, f) => {
+	return _hsx_default(col1, col2, f, "hcg");
+};
+interpolator_default.hcg = hcg;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/hsi/hsi2rgb.js
+const { cos: cos$3 } = Math;
+const hsi2rgb = (...args) => {
+	args = unpack_default(args, "hsi");
+	let [h, s, i] = args;
+	let r, g, b;
+	if (isNaN(h)) h = 0;
+	if (isNaN(s)) s = 0;
+	if (h > 360) h -= 360;
+	if (h < 0) h += 360;
+	h /= 360;
+	if (h < 1 / 3) {
+		b = (1 - s) / 3;
+		r = (1 + s * cos$3(TWOPI * h) / cos$3(PITHIRD - TWOPI * h)) / 3;
+		g = 1 - (b + r);
+	} else if (h < 2 / 3) {
+		h -= 1 / 3;
+		r = (1 - s) / 3;
+		g = (1 + s * cos$3(TWOPI * h) / cos$3(PITHIRD - TWOPI * h)) / 3;
+		b = 1 - (r + g);
+	} else {
+		h -= 2 / 3;
+		g = (1 - s) / 3;
+		b = (1 + s * cos$3(TWOPI * h) / cos$3(PITHIRD - TWOPI * h)) / 3;
+		r = 1 - (g + b);
+	}
+	r = limit_default(i * r * 3);
+	g = limit_default(i * g * 3);
+	b = limit_default(i * b * 3);
+	return [
+		r * 255,
+		g * 255,
+		b * 255,
+		args.length > 3 ? args[3] : 1
+	];
+};
+var hsi2rgb_default = hsi2rgb;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/hsi/rgb2hsi.js
+const { min: min$2, sqrt: sqrt$2, acos } = Math;
+const rgb2hsi = (...args) => {
+	let [r, g, b] = unpack_default(args, "rgb");
+	r /= 255;
+	g /= 255;
+	b /= 255;
+	let h;
+	const min_ = min$2(r, g, b);
+	const i = (r + g + b) / 3;
+	const s = i > 0 ? 1 - min_ / i : 0;
+	if (s === 0) h = NaN;
+	else {
+		h = (r - g + (r - b)) / 2;
+		h /= sqrt$2((r - g) * (r - g) + (r - b) * (g - b));
+		h = acos(h);
+		if (b > g) h = TWOPI - h;
+		h /= TWOPI;
+	}
+	return [
+		h * 360,
+		s,
+		i
+	];
+};
+var rgb2hsi_default = rgb2hsi;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/hsi/index.js
+Color_default.prototype.hsi = function() {
+	return rgb2hsi_default(this._rgb);
+};
+const hsi$1 = (...args) => new Color_default(...args, "hsi");
+chroma_default.hsi = hsi$1;
+input_default.format.hsi = hsi2rgb_default;
+input_default.autodetect.push({
+	p: 2,
+	test: (...args) => {
+		args = unpack_default(args, "hsi");
+		if (type_default(args) === "array" && args.length === 3) return "hsi";
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/interpolator/hsi.js
+const hsi = (col1, col2, f) => {
+	return _hsx_default(col1, col2, f, "hsi");
+};
+interpolator_default.hsi = hsi;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/hsl/hsl2rgb.js
+const hsl2rgb = (...args) => {
+	args = unpack_default(args, "hsl");
+	const [h, s, l] = args;
+	let r, g, b;
+	if (s === 0) r = g = b = l * 255;
+	else {
+		const t3 = [
+			0,
+			0,
+			0
+		];
+		const c = [
+			0,
+			0,
+			0
+		];
+		const t2 = l < .5 ? l * (1 + s) : l + s - l * s;
+		const t1 = 2 * l - t2;
+		const h_ = h / 360;
+		t3[0] = h_ + 1 / 3;
+		t3[1] = h_;
+		t3[2] = h_ - 1 / 3;
+		for (let i = 0; i < 3; i++) {
+			if (t3[i] < 0) t3[i] += 1;
+			if (t3[i] > 1) t3[i] -= 1;
+			if (6 * t3[i] < 1) c[i] = t1 + (t2 - t1) * 6 * t3[i];
+			else if (2 * t3[i] < 1) c[i] = t2;
+			else if (3 * t3[i] < 2) c[i] = t1 + (t2 - t1) * (2 / 3 - t3[i]) * 6;
+			else c[i] = t1;
+		}
+		[r, g, b] = [
+			c[0] * 255,
+			c[1] * 255,
+			c[2] * 255
+		];
+	}
+	if (args.length > 3) return [
+		r,
+		g,
+		b,
+		args[3]
+	];
+	return [
+		r,
+		g,
+		b,
+		1
+	];
+};
+var hsl2rgb_default = hsl2rgb;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/hsl/rgb2hsl.js
+const rgb2hsl$1 = (...args) => {
+	args = unpack_default(args, "rgba");
+	let [r, g, b] = args;
+	r /= 255;
+	g /= 255;
+	b /= 255;
+	const minRgb = min$3(r, g, b);
+	const maxRgb = max$3(r, g, b);
+	const l = (maxRgb + minRgb) / 2;
+	let s, h;
+	if (maxRgb === minRgb) {
+		s = 0;
+		h = NaN;
+	} else s = l < .5 ? (maxRgb - minRgb) / (maxRgb + minRgb) : (maxRgb - minRgb) / (2 - maxRgb - minRgb);
+	if (r == maxRgb) h = (g - b) / (maxRgb - minRgb);
+	else if (g == maxRgb) h = 2 + (b - r) / (maxRgb - minRgb);
+	else if (b == maxRgb) h = 4 + (r - g) / (maxRgb - minRgb);
+	h *= 60;
+	if (h < 0) h += 360;
+	if (args.length > 3 && args[3] !== void 0) return [
+		h,
+		s,
+		l,
+		args[3]
+	];
+	return [
+		h,
+		s,
+		l
+	];
+};
+var rgb2hsl_default = rgb2hsl$1;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/hsl/index.js
+Color_default.prototype.hsl = function() {
+	return rgb2hsl_default(this._rgb);
+};
+const hsl$1 = (...args) => new Color_default(...args, "hsl");
+chroma_default.hsl = hsl$1;
+input_default.format.hsl = hsl2rgb_default;
+input_default.autodetect.push({
+	p: 2,
+	test: (...args) => {
+		args = unpack_default(args, "hsl");
+		if (type_default(args) === "array" && args.length === 3) return "hsl";
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/interpolator/hsl.js
+const hsl = (col1, col2, f) => {
+	return _hsx_default(col1, col2, f, "hsl");
+};
+interpolator_default.hsl = hsl;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/hsv/hsv2rgb.js
+const { floor: floor$2 } = Math;
+const hsv2rgb = (...args) => {
+	args = unpack_default(args, "hsv");
+	let [h, s, v] = args;
+	let r, g, b;
+	v *= 255;
+	if (s === 0) r = g = b = v;
+	else {
+		if (h === 360) h = 0;
+		if (h > 360) h -= 360;
+		if (h < 0) h += 360;
+		h /= 60;
+		const i = floor$2(h);
+		const f = h - i;
+		const p = v * (1 - s);
+		const q = v * (1 - s * f);
+		const t = v * (1 - s * (1 - f));
+		switch (i) {
+			case 0:
+				[r, g, b] = [
+					v,
+					t,
+					p
+				];
+				break;
+			case 1:
+				[r, g, b] = [
+					q,
+					v,
+					p
+				];
+				break;
+			case 2:
+				[r, g, b] = [
+					p,
+					v,
+					t
+				];
+				break;
+			case 3:
+				[r, g, b] = [
+					p,
+					q,
+					v
+				];
+				break;
+			case 4:
+				[r, g, b] = [
+					t,
+					p,
+					v
+				];
+				break;
+			case 5:
+				[r, g, b] = [
+					v,
+					p,
+					q
+				];
+				break;
+		}
+	}
+	return [
+		r,
+		g,
+		b,
+		args.length > 3 ? args[3] : 1
+	];
+};
+var hsv2rgb_default = hsv2rgb;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/hsv/rgb2hsv.js
+const { min: min$1, max: max$2 } = Math;
+const rgb2hsl = (...args) => {
+	args = unpack_default(args, "rgb");
+	let [r, g, b] = args;
+	const min_ = min$1(r, g, b);
+	const max_ = max$2(r, g, b);
+	const delta = max_ - min_;
+	let h, s, v;
+	v = max_ / 255;
+	if (max_ === 0) {
+		h = NaN;
+		s = 0;
+	} else {
+		s = delta / max_;
+		if (r === max_) h = (g - b) / delta;
+		if (g === max_) h = 2 + (b - r) / delta;
+		if (b === max_) h = 4 + (r - g) / delta;
+		h *= 60;
+		if (h < 0) h += 360;
+	}
+	return [
+		h,
+		s,
+		v
+	];
+};
+var rgb2hsv_default = rgb2hsl;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/hsv/index.js
+Color_default.prototype.hsv = function() {
+	return rgb2hsv_default(this._rgb);
+};
+const hsv$1 = (...args) => new Color_default(...args, "hsv");
+chroma_default.hsv = hsv$1;
+input_default.format.hsv = hsv2rgb_default;
+input_default.autodetect.push({
+	p: 2,
+	test: (...args) => {
+		args = unpack_default(args, "hsv");
+		if (type_default(args) === "array" && args.length === 3) return "hsv";
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/interpolator/hsv.js
+const hsv = (col1, col2, f) => {
+	return _hsx_default(col1, col2, f, "hsv");
+};
+interpolator_default.hsv = hsv;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/utils/multiply-matrices.js
+function multiplyMatrices(A, B) {
+	let m = A.length;
+	if (!Array.isArray(A[0])) A = [A];
+	if (!Array.isArray(B[0])) B = B.map((x) => [x]);
+	let p = B[0].length;
+	let B_cols = B[0].map((_, i) => B.map((x) => x[i]));
+	let product = A.map((row) => B_cols.map((col) => {
+		if (!Array.isArray(row)) return col.reduce((a, c) => a + c * row, 0);
+		return row.reduce((a, c, i) => a + c * (col[i] || 0), 0);
+	}));
+	if (m === 1) product = product[0];
+	if (p === 1) return product.map((x) => x[0]);
+	return product;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/oklab/oklab2rgb.js
+const oklab2rgb = (...args) => {
+	args = unpack_default(args, "lab");
+	const [L, a, b, ...rest] = args;
+	const [X, Y, Z] = OKLab_to_XYZ([
+		L,
+		a,
+		b
+	]);
+	const [r, g, b_] = xyz2rgb(X, Y, Z);
+	return [
+		r,
+		g,
+		b_,
+		...rest.length > 0 && rest[0] < 1 ? [rest[0]] : []
+	];
+};
+function OKLab_to_XYZ(OKLab) {
+	return multiplyMatrices([
+		[
+			1.2268798758459243,
+			-.5578149944602171,
+			.2813910456659647
+		],
+		[
+			-.0405757452148008,
+			1.112286803280317,
+			-.0717110580655164
+		],
+		[
+			-.0763729366746601,
+			-.4214933324022432,
+			1.5869240198367816
+		]
+	], multiplyMatrices([
+		[
+			1,
+			.3963377773761749,
+			.2158037573099136
+		],
+		[
+			1,
+			-.1055613458156586,
+			-.0638541728258133
+		],
+		[
+			1,
+			-.0894841775298119,
+			-1.2914855480194092
+		]
+	], OKLab).map((c) => c ** 3));
+}
+var oklab2rgb_default = oklab2rgb;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/oklab/rgb2oklab.js
+const rgb2oklab = (...args) => {
+	const [r, g, b, ...rest] = unpack_default(args, "rgb");
+	return [...XYZ_to_OKLab(rgb2xyz(r, g, b)), ...rest.length > 0 && rest[0] < 1 ? [rest[0]] : []];
+};
+function XYZ_to_OKLab(XYZ) {
+	return multiplyMatrices([
+		[
+			.210454268309314,
+			.7936177747023054,
+			-.0040720430116193
+		],
+		[
+			1.9779985324311684,
+			-2.42859224204858,
+			.450593709617411
+		],
+		[
+			.0259040424655478,
+			.7827717124575296,
+			-.8086757549230774
+		]
+	], multiplyMatrices([
+		[
+			.819022437996703,
+			.3619062600528904,
+			-.1288737815209879
+		],
+		[
+			.0329836539323885,
+			.9292868615863434,
+			.0361446663506424
+		],
+		[
+			.0481771893596242,
+			.2642395317527308,
+			.6335478284694309
+		]
+	], XYZ).map((c) => Math.cbrt(c)));
+}
+var rgb2oklab_default = rgb2oklab;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/oklab/index.js
+Color_default.prototype.oklab = function() {
+	return rgb2oklab_default(this._rgb);
+};
+const oklab$1 = (...args) => new Color_default(...args, "oklab");
+Object.assign(chroma_default, { oklab: oklab$1 });
+input_default.format.oklab = oklab2rgb_default;
+input_default.autodetect.push({
+	p: 2,
+	test: (...args) => {
+		args = unpack_default(args, "oklab");
+		if (type_default(args) === "array" && args.length === 3) return "oklab";
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/interpolator/oklab.js
+const oklab = (col1, col2, f) => {
+	const xyz0 = col1.oklab();
+	const xyz1 = col2.oklab();
+	return new Color_default(xyz0[0] + f * (xyz1[0] - xyz0[0]), xyz0[1] + f * (xyz1[1] - xyz0[1]), xyz0[2] + f * (xyz1[2] - xyz0[2]), "oklab");
+};
+interpolator_default.oklab = oklab;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/interpolator/oklch.js
+const oklch$1 = (col1, col2, f) => {
+	return _hsx_default(col1, col2, f, "oklch");
+};
+interpolator_default.oklch = oklch$1;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/generator/average.js
+const { pow: pow$4, sqrt: sqrt$1, PI: PI$1, cos: cos$2, sin: sin$2, atan2: atan2$1 } = Math;
+var average_default = (colors, mode = "lrgb", weights = null) => {
+	const l = colors.length;
+	if (!weights) weights = Array.from(new Array(l)).map(() => 1);
+	const k = l / weights.reduce(function(a, b) {
+		return a + b;
+	});
+	weights.forEach((w, i) => {
+		weights[i] *= k;
+	});
+	colors = colors.map((c) => new Color_default(c));
+	if (mode === "lrgb") return _average_lrgb(colors, weights);
+	const first = colors.shift();
+	const xyz = first.get(mode);
+	const cnt = [];
+	let dx = 0;
+	let dy = 0;
+	for (let i = 0; i < xyz.length; i++) {
+		xyz[i] = (xyz[i] || 0) * weights[0];
+		cnt.push(isNaN(xyz[i]) ? 0 : weights[0]);
+		if (mode.charAt(i) === "h" && !isNaN(xyz[i])) {
+			const A = xyz[i] / 180 * PI$1;
+			dx += cos$2(A) * weights[0];
+			dy += sin$2(A) * weights[0];
+		}
+	}
+	let alpha = first.alpha() * weights[0];
+	colors.forEach((c, ci) => {
+		const xyz2 = c.get(mode);
+		alpha += c.alpha() * weights[ci + 1];
+		for (let i = 0; i < xyz.length; i++) if (!isNaN(xyz2[i])) {
+			cnt[i] += weights[ci + 1];
+			if (mode.charAt(i) === "h") {
+				const A = xyz2[i] / 180 * PI$1;
+				dx += cos$2(A) * weights[ci + 1];
+				dy += sin$2(A) * weights[ci + 1];
+			} else xyz[i] += xyz2[i] * weights[ci + 1];
+		}
+	});
+	for (let i = 0; i < xyz.length; i++) if (mode.charAt(i) === "h") {
+		let A = atan2$1(dy / cnt[i], dx / cnt[i]) / PI$1 * 180;
+		while (A < 0) A += 360;
+		while (A >= 360) A -= 360;
+		xyz[i] = A;
+	} else xyz[i] = xyz[i] / cnt[i];
+	alpha /= l;
+	return new Color_default(xyz, mode).alpha(alpha > .99999 ? 1 : alpha, true);
+};
+const _average_lrgb = (colors, weights) => {
+	const l = colors.length;
+	const xyz = [
+		0,
+		0,
+		0,
+		0
+	];
+	for (let i = 0; i < colors.length; i++) {
+		const col = colors[i];
+		const f = weights[i] / l;
+		const rgb = col._rgb;
+		xyz[0] += pow$4(rgb[0], 2) * f;
+		xyz[1] += pow$4(rgb[1], 2) * f;
+		xyz[2] += pow$4(rgb[2], 2) * f;
+		xyz[3] += rgb[3] * f;
+	}
+	xyz[0] = sqrt$1(xyz[0]);
+	xyz[1] = sqrt$1(xyz[1]);
+	xyz[2] = sqrt$1(xyz[2]);
+	if (xyz[3] > .9999999) xyz[3] = 1;
+	return new Color_default(clip_rgb_default(xyz));
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/generator/scale.js
+const { pow: pow$3 } = Math;
+function scale_default(colors) {
+	let _mode = "rgb";
+	let _nacol = chroma_default("#ccc");
+	let _spread = 0;
+	let _positions = [0, 1];
+	let _domain = [0, 1];
+	let _pos = [];
+	let _padding = [0, 0];
+	let _classes = false;
+	let _colors = [];
+	let _out = false;
+	let _min = 0;
+	let _max = 1;
+	let _correctLightness = false;
+	let _colorCache = {};
+	let _useCache = true;
+	let _gamma = 1;
+	const setColors = function(colors) {
+		colors = colors || ["#fff", "#000"];
+		if (colors && type_default(colors) === "string" && chroma_default.brewer && chroma_default.brewer[colors.toLowerCase()]) colors = chroma_default.brewer[colors.toLowerCase()];
+		if (type_default(colors) === "array") {
+			if (colors.length === 1) colors = [colors[0], colors[0]];
+			colors = colors.slice(0);
+			for (let c = 0; c < colors.length; c++) colors[c] = chroma_default(colors[c]);
+			_pos.length = 0;
+			for (let c = 0; c < colors.length; c++) _pos.push(c / (colors.length - 1));
+		}
+		resetCache();
+		return _colors = colors;
+	};
+	const getClass = function(value) {
+		if (_classes != null) {
+			const n = _classes.length - 1;
+			let i = 0;
+			while (i < n && value >= _classes[i]) i++;
+			return i - 1;
+		}
+		return 0;
+	};
+	let tMapLightness = (t) => t;
+	let tMapDomain = (t) => t;
+	const getColor = function(val, bypassMap) {
+		let col, t;
+		if (bypassMap == null) bypassMap = false;
+		if (isNaN(val) || val === null) return _nacol;
+		if (!bypassMap) if (_classes && _classes.length > 2) t = getClass(val) / (_classes.length - 2);
+		else if (_max !== _min) t = (val - _min) / (_max - _min);
+		else t = 1;
+		else t = val;
+		t = tMapDomain(t);
+		if (!bypassMap) t = tMapLightness(t);
+		if (_gamma !== 1) t = pow$3(t, _gamma);
+		t = _padding[0] + t * (1 - _padding[0] - _padding[1]);
+		t = limit_default(t, 0, 1);
+		const k = Math.floor(t * 1e4);
+		if (_useCache && _colorCache[k]) col = _colorCache[k];
+		else {
+			if (type_default(_colors) === "array") for (let i = 0; i < _pos.length; i++) {
+				const p = _pos[i];
+				if (t <= p) {
+					col = _colors[i];
+					break;
+				}
+				if (t >= p && i === _pos.length - 1) {
+					col = _colors[i];
+					break;
+				}
+				if (t > p && t < _pos[i + 1]) {
+					t = (t - p) / (_pos[i + 1] - p);
+					col = chroma_default.interpolate(_colors[i], _colors[i + 1], t, _mode);
+					break;
+				}
+			}
+			else if (type_default(_colors) === "function") col = _colors(t);
+			if (_useCache) _colorCache[k] = col;
+		}
+		return col;
+	};
+	var resetCache = () => _colorCache = {};
+	setColors(colors);
+	const f = function(v) {
+		const c = chroma_default(getColor(v));
+		if (_out && c[_out]) return c[_out]();
+		else return c;
+	};
+	f.classes = function(classes) {
+		if (classes != null) {
+			if (type_default(classes) === "array") {
+				_classes = classes;
+				_positions = [classes[0], classes[classes.length - 1]];
+			} else {
+				const d = chroma_default.analyze(_positions);
+				if (classes === 0) _classes = [d.min, d.max];
+				else _classes = chroma_default.limits(d, "e", classes);
+			}
+			return f;
+		}
+		return _classes;
+	};
+	f.domain = function(domain) {
+		if (!arguments.length) return _domain;
+		_domain = domain.slice(0);
+		_min = domain[0];
+		_max = domain[domain.length - 1];
+		_pos = [];
+		const k = _colors.length;
+		if (domain.length === k && _min !== _max) for (let d of Array.from(domain)) _pos.push((d - _min) / (_max - _min));
+		else {
+			for (let c = 0; c < k; c++) _pos.push(c / (k - 1));
+			if (domain.length > 2) {
+				const tOut = domain.map((d, i) => i / (domain.length - 1));
+				const tBreaks = domain.map((d) => (d - _min) / (_max - _min));
+				if (!tBreaks.every((val, i) => tOut[i] === val)) tMapDomain = (t) => {
+					if (t <= 0 || t >= 1) return t;
+					let i = 0;
+					while (t >= tBreaks[i + 1]) i++;
+					const f = (t - tBreaks[i]) / (tBreaks[i + 1] - tBreaks[i]);
+					return tOut[i] + f * (tOut[i + 1] - tOut[i]);
+				};
+			}
+		}
+		_positions = [_min, _max];
+		return f;
+	};
+	f.mode = function(_m) {
+		if (!arguments.length) return _mode;
+		_mode = _m;
+		resetCache();
+		return f;
+	};
+	f.range = function(colors, _pos) {
+		setColors(colors, _pos);
+		return f;
+	};
+	f.out = function(_o) {
+		_out = _o;
+		return f;
+	};
+	f.spread = function(val) {
+		if (!arguments.length) return _spread;
+		_spread = val;
+		return f;
+	};
+	f.correctLightness = function(v) {
+		if (v == null) v = true;
+		_correctLightness = v;
+		resetCache();
+		if (_correctLightness) tMapLightness = function(t) {
+			const L0 = getColor(0, true).lab()[0];
+			const L1 = getColor(1, true).lab()[0];
+			const pol = L0 > L1;
+			let L_actual = getColor(t, true).lab()[0];
+			const L_ideal = L0 + (L1 - L0) * t;
+			let L_diff = L_actual - L_ideal;
+			let t0 = 0;
+			let t1 = 1;
+			let max_iter = 20;
+			while (Math.abs(L_diff) > .01 && max_iter-- > 0) (function() {
+				if (pol) L_diff *= -1;
+				if (L_diff < 0) {
+					t0 = t;
+					t += (t1 - t) * .5;
+				} else {
+					t1 = t;
+					t += (t0 - t) * .5;
+				}
+				L_actual = getColor(t, true).lab()[0];
+				return L_diff = L_actual - L_ideal;
+			})();
+			return t;
+		};
+		else tMapLightness = (t) => t;
+		return f;
+	};
+	f.padding = function(p) {
+		if (p != null) {
+			if (type_default(p) === "number") p = [p, p];
+			_padding = p;
+			return f;
+		} else return _padding;
+	};
+	f.colors = function(numColors, out) {
+		if (arguments.length < 2) out = "hex";
+		let result = [];
+		if (arguments.length === 0) result = _colors.slice(0);
+		else if (numColors === 1) result = [f(.5)];
+		else if (numColors > 1) {
+			const dm = _positions[0];
+			const dd = _positions[1] - dm;
+			result = __range__(0, numColors, false).map((i) => f(dm + i / (numColors - 1) * dd));
+		} else {
+			colors = [];
+			let samples = [];
+			if (_classes && _classes.length > 2) for (let i = 1, end = _classes.length, asc = 1 <= end; asc ? i < end : i > end; asc ? i++ : i--) samples.push((_classes[i - 1] + _classes[i]) * .5);
+			else samples = _positions;
+			result = samples.map((v) => f(v));
+		}
+		if (chroma_default[out]) result = result.map((c) => c[out]());
+		return result;
+	};
+	f.cache = function(c) {
+		if (c != null) {
+			_useCache = c;
+			return f;
+		} else return _useCache;
+	};
+	f.gamma = function(g) {
+		if (g != null) {
+			_gamma = g;
+			return f;
+		} else return _gamma;
+	};
+	f.nodata = function(d) {
+		if (d != null) {
+			_nacol = chroma_default(d);
+			return f;
+		} else return _nacol;
+	};
+	return f;
+}
+function __range__(left, right, inclusive) {
+	let range = [];
+	let ascending = left < right;
+	let end = !inclusive ? right : ascending ? right + 1 : right - 1;
+	for (let i = left; ascending ? i < end : i > end; ascending ? i++ : i--) range.push(i);
+	return range;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/generator/bezier.js
+const binom_row = function(n) {
+	let row = [1, 1];
+	for (let i = 1; i < n; i++) {
+		let newrow = [1];
+		for (let j = 1; j <= row.length; j++) newrow[j] = (row[j] || 0) + row[j - 1];
+		row = newrow;
+	}
+	return row;
+};
+const bezier = function(colors) {
+	let I, lab0, lab1, lab2;
+	colors = colors.map((c) => new Color_default(c));
+	if (colors.length === 2) {
+		[lab0, lab1] = colors.map((c) => c.lab());
+		I = function(t) {
+			return new Color_default([
+				0,
+				1,
+				2
+			].map((i) => lab0[i] + t * (lab1[i] - lab0[i])), "lab");
+		};
+	} else if (colors.length === 3) {
+		[lab0, lab1, lab2] = colors.map((c) => c.lab());
+		I = function(t) {
+			return new Color_default([
+				0,
+				1,
+				2
+			].map((i) => (1 - t) * (1 - t) * lab0[i] + 2 * (1 - t) * t * lab1[i] + t * t * lab2[i]), "lab");
+		};
+	} else if (colors.length === 4) {
+		let lab3;
+		[lab0, lab1, lab2, lab3] = colors.map((c) => c.lab());
+		I = function(t) {
+			return new Color_default([
+				0,
+				1,
+				2
+			].map((i) => (1 - t) * (1 - t) * (1 - t) * lab0[i] + 3 * (1 - t) * (1 - t) * t * lab1[i] + 3 * (1 - t) * t * t * lab2[i] + t * t * t * lab3[i]), "lab");
+		};
+	} else if (colors.length >= 5) {
+		let labs, row, n;
+		labs = colors.map((c) => c.lab());
+		n = colors.length - 1;
+		row = binom_row(n);
+		I = function(t) {
+			const u = 1 - t;
+			return new Color_default([
+				0,
+				1,
+				2
+			].map((i) => labs.reduce((sum, el, j) => sum + row[j] * u ** (n - j) * t ** j * el[i], 0)), "lab");
+		};
+	} else throw new RangeError("No point in running bezier with only one color.");
+	return I;
+};
+var bezier_default = (colors) => {
+	const f = bezier(colors);
+	f.scale = () => scale_default(f);
+	return f;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/rgb/index.js
+const { round: round$3 } = Math;
+Color_default.prototype.rgb = function(rnd = true) {
+	if (rnd === false) return this._rgb.slice(0, 3);
+	return this._rgb.slice(0, 3).map(round$3);
+};
+Color_default.prototype.rgba = function(rnd = true) {
+	return this._rgb.slice(0, 4).map((v, i) => {
+		return i < 3 ? rnd === false ? v : round$3(v) : v;
+	});
+};
+const rgb = (...args) => new Color_default(...args, "rgb");
+Object.assign(chroma_default, { rgb });
+input_default.format.rgb = (...args) => {
+	const rgba = unpack_default(args, "rgba");
+	if (rgba[3] === void 0) rgba[3] = 1;
+	return rgba;
+};
+input_default.autodetect.push({
+	p: 3,
+	test: (...args) => {
+		args = unpack_default(args, "rgba");
+		if (type_default(args) === "array" && (args.length === 3 || args.length === 4 && type_default(args[3]) == "number" && args[3] >= 0 && args[3] <= 1)) return "rgb";
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/generator/blend.js
+const blend = (bottom, top, mode) => {
+	if (!blend[mode]) throw new Error("unknown blend mode " + mode);
+	return blend[mode](bottom, top);
+};
+const blend_f = (f) => (bottom, top) => {
+	const c0 = chroma_default(top).rgb();
+	const c1 = chroma_default(bottom).rgb();
+	return chroma_default.rgb(f(c0, c1));
+};
+const each = (f) => (c0, c1) => {
+	const out = [];
+	out[0] = f(c0[0], c1[0]);
+	out[1] = f(c0[1], c1[1]);
+	out[2] = f(c0[2], c1[2]);
+	return out;
+};
+const normal = (a) => a;
+const multiply = (a, b) => a * b / 255;
+const darken = (a, b) => a > b ? b : a;
+const lighten = (a, b) => a > b ? a : b;
+const screen = (a, b) => 255 * (1 - (1 - a / 255) * (1 - b / 255));
+const overlay = (a, b) => b < 128 ? 2 * a * b / 255 : 255 * (1 - 2 * (1 - a / 255) * (1 - b / 255));
+const burn = (a, b) => 255 * (1 - (1 - b / 255) / (a / 255));
+const dodge = (a, b) => {
+	if (a === 255) return 255;
+	a = 255 * (b / 255) / (1 - a / 255);
+	return a > 255 ? 255 : a;
+};
+blend.normal = blend_f(each(normal));
+blend.multiply = blend_f(each(multiply));
+blend.screen = blend_f(each(screen));
+blend.overlay = blend_f(each(overlay));
+blend.darken = blend_f(each(darken));
+blend.lighten = blend_f(each(lighten));
+blend.dodge = blend_f(each(dodge));
+blend.burn = blend_f(each(burn));
+var blend_default = blend;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/generator/cubehelix.js
+const { pow: pow$2, sin: sin$1, cos: cos$1 } = Math;
+function cubehelix_default(start = 300, rotations = -1.5, hue = 1, gamma = 1, lightness = [0, 1]) {
+	let dh = 0, dl;
+	if (type_default(lightness) === "array") dl = lightness[1] - lightness[0];
+	else {
+		dl = 0;
+		lightness = [lightness, lightness];
+	}
+	const f = function(fract) {
+		const a = TWOPI * ((start + 120) / 360 + rotations * fract);
+		const l = pow$2(lightness[0] + dl * fract, gamma);
+		const amp = (dh !== 0 ? hue[0] + fract * dh : hue) * l * (1 - l) / 2;
+		const cos_a = cos$1(a);
+		const sin_a = sin$1(a);
+		const r = l + amp * (-.14861 * cos_a + 1.78277 * sin_a);
+		const g = l + amp * (-.29227 * cos_a - .90649 * sin_a);
+		const b = l + amp * (1.97294 * cos_a);
+		return chroma_default(clip_rgb_default([
+			r * 255,
+			g * 255,
+			b * 255,
+			1
+		]));
+	};
+	f.start = function(s) {
+		if (s == null) return start;
+		start = s;
+		return f;
+	};
+	f.rotations = function(r) {
+		if (r == null) return rotations;
+		rotations = r;
+		return f;
+	};
+	f.gamma = function(g) {
+		if (g == null) return gamma;
+		gamma = g;
+		return f;
+	};
+	f.hue = function(h) {
+		if (h == null) return hue;
+		hue = h;
+		if (type_default(hue) === "array") {
+			dh = hue[1] - hue[0];
+			if (dh === 0) hue = hue[1];
+		} else dh = 0;
+		return f;
+	};
+	f.lightness = function(h) {
+		if (h == null) return lightness;
+		if (type_default(h) === "array") {
+			lightness = h;
+			dl = h[1] - h[0];
+		} else {
+			lightness = [h, h];
+			dl = 0;
+		}
+		return f;
+	};
+	f.scale = () => chroma_default.scale(f);
+	f.hue(hue);
+	return f;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/generator/random.js
+const digits = "0123456789abcdef";
+const { floor: floor$1, random } = Math;
+/**
+* Generates a random color.
+* @param {() => number} rng - A random number generator function.
+*/
+var random_default = (rng = random) => {
+	let code = "#";
+	for (let i = 0; i < 6; i++) code += digits.charAt(floor$1(rng() * 16));
+	return new Color_default(code, "hex");
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/utils/analyze.js
+const { log: log$1, pow: pow$1, floor, abs: abs$1 } = Math;
+function analyze(data, key = null) {
+	const r = {
+		min: Number.MAX_VALUE,
+		max: Number.MAX_VALUE * -1,
+		sum: 0,
+		values: [],
+		count: 0
+	};
+	if (type_default(data) === "object") data = Object.values(data);
+	data.forEach((val) => {
+		if (key && type_default(val) === "object") val = val[key];
+		if (val !== void 0 && val !== null && !isNaN(val)) {
+			r.values.push(val);
+			r.sum += val;
+			if (val < r.min) r.min = val;
+			if (val > r.max) r.max = val;
+			r.count += 1;
+		}
+	});
+	r.domain = [r.min, r.max];
+	r.limits = (mode, num) => limits(r, mode, num);
+	return r;
+}
+function limits(data, mode = "equal", num = 7) {
+	if (type_default(data) == "array") data = analyze(data);
+	const { min, max } = data;
+	const values = data.values.sort((a, b) => a - b);
+	if (num === 1) return [min, max];
+	const limits = [];
+	if (mode.substr(0, 1) === "c") {
+		limits.push(min);
+		limits.push(max);
+	}
+	if (mode.substr(0, 1) === "e") {
+		limits.push(min);
+		for (let i = 1; i < num; i++) limits.push(min + i / num * (max - min));
+		limits.push(max);
+	} else if (mode.substr(0, 1) === "l") {
+		if (min <= 0) throw new Error("Logarithmic scales are only possible for values > 0");
+		const min_log = Math.LOG10E * log$1(min);
+		const max_log = Math.LOG10E * log$1(max);
+		limits.push(min);
+		for (let i = 1; i < num; i++) limits.push(pow$1(10, min_log + i / num * (max_log - min_log)));
+		limits.push(max);
+	} else if (mode.substr(0, 1) === "q") {
+		limits.push(min);
+		for (let i = 1; i < num; i++) {
+			const p = (values.length - 1) * i / num;
+			const pb = floor(p);
+			if (pb === p) limits.push(values[pb]);
+			else {
+				const pr = p - pb;
+				limits.push(values[pb] * (1 - pr) + values[pb + 1] * pr);
+			}
+		}
+		limits.push(max);
+	} else if (mode.substr(0, 1) === "k") {
+		let cluster;
+		const n = values.length;
+		const assignments = new Array(n);
+		const clusterSizes = new Array(num);
+		let repeat = true;
+		let nb_iters = 0;
+		let centroids = null;
+		centroids = [];
+		centroids.push(min);
+		for (let i = 1; i < num; i++) centroids.push(min + i / num * (max - min));
+		centroids.push(max);
+		while (repeat) {
+			for (let j = 0; j < num; j++) clusterSizes[j] = 0;
+			for (let i = 0; i < n; i++) {
+				const value = values[i];
+				let mindist = Number.MAX_VALUE;
+				let best;
+				for (let j = 0; j < num; j++) {
+					const dist = abs$1(centroids[j] - value);
+					if (dist < mindist) {
+						mindist = dist;
+						best = j;
+					}
+					clusterSizes[best]++;
+					assignments[i] = best;
+				}
+			}
+			const newCentroids = new Array(num);
+			for (let j = 0; j < num; j++) newCentroids[j] = null;
+			for (let i = 0; i < n; i++) {
+				cluster = assignments[i];
+				if (newCentroids[cluster] === null) newCentroids[cluster] = values[i];
+				else newCentroids[cluster] += values[i];
+			}
+			for (let j = 0; j < num; j++) newCentroids[j] *= 1 / clusterSizes[j];
+			repeat = false;
+			for (let j = 0; j < num; j++) if (newCentroids[j] !== centroids[j]) {
+				repeat = true;
+				break;
+			}
+			centroids = newCentroids;
+			nb_iters++;
+			if (nb_iters > 200) repeat = false;
+		}
+		const kClusters = {};
+		for (let j = 0; j < num; j++) kClusters[j] = [];
+		for (let i = 0; i < n; i++) {
+			cluster = assignments[i];
+			kClusters[cluster].push(values[i]);
+		}
+		let tmpKMeansBreaks = [];
+		for (let j = 0; j < num; j++) {
+			tmpKMeansBreaks.push(kClusters[j][0]);
+			tmpKMeansBreaks.push(kClusters[j][kClusters[j].length - 1]);
+		}
+		tmpKMeansBreaks = tmpKMeansBreaks.sort((a, b) => a - b);
+		limits.push(tmpKMeansBreaks[0]);
+		for (let i = 1; i < tmpKMeansBreaks.length; i += 2) {
+			const v = tmpKMeansBreaks[i];
+			if (!isNaN(v) && limits.indexOf(v) === -1) limits.push(v);
+		}
+	}
+	return limits;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/utils/contrast.js
+var contrast_default = (a, b) => {
+	a = new Color_default(a);
+	b = new Color_default(b);
+	const l1 = a.luminance();
+	const l2 = b.luminance();
+	return l1 > l2 ? (l1 + .05) / (l2 + .05) : (l2 + .05) / (l1 + .05);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/utils/contrastAPCA.js
+/**
+* @license
+*
+* The APCA contrast prediction algorithm is based of the formulas published
+* in the APCA-1.0.98G specification by Myndex. The specification is available at:
+* https://raw.githubusercontent.com/Myndex/apca-w3/master/images/APCAw3_0.1.17_APCA0.0.98G.svg
+*
+* Note that the APCA implementation is still beta, so please update to
+* future versions of chroma.js when they become available.
+*
+* You can read more about the APCA Readability Criterion at
+* https://readtech.org/ARC/
+*/
+const W_offset = .027;
+const P_in = 5e-4;
+const P_out = .1;
+const R_scale = 1.14;
+const B_threshold = .022;
+const B_exp = 1.414;
+var contrastAPCA_default = (text, bg) => {
+	text = new Color_default(text);
+	bg = new Color_default(bg);
+	if (text.alpha() < 1) text = mix_default(bg, text, text.alpha(), "rgb");
+	const l_text = lum(...text.rgb());
+	const l_bg = lum(...bg.rgb());
+	const Y_text = l_text >= B_threshold ? l_text : l_text + Math.pow(B_threshold - l_text, B_exp);
+	const Y_bg = l_bg >= B_threshold ? l_bg : l_bg + Math.pow(B_threshold - l_bg, B_exp);
+	const S_norm = Math.pow(Y_bg, .56) - Math.pow(Y_text, .57);
+	const S_rev = Math.pow(Y_bg, .65) - Math.pow(Y_text, .62);
+	const C = Math.abs(Y_bg - Y_text) < P_in ? 0 : Y_text < Y_bg ? S_norm * R_scale : S_rev * R_scale;
+	return (Math.abs(C) < P_out ? 0 : C > 0 ? C - W_offset : C + W_offset) * 100;
+};
+function lum(r, g, b) {
+	return .2126729 * Math.pow(r / 255, 2.4) + .7151522 * Math.pow(g / 255, 2.4) + .072175 * Math.pow(b / 255, 2.4);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/utils/delta-e.js
+const { sqrt, pow, min, max: max$1, atan2, abs, cos, sin, exp, PI } = Math;
+function delta_e_default(a, b, Kl = 1, Kc = 1, Kh = 1) {
+	var rad2deg = function(rad) {
+		return 360 * rad / (2 * PI);
+	};
+	var deg2rad = function(deg) {
+		return 2 * PI * deg / 360;
+	};
+	a = new Color_default(a);
+	b = new Color_default(b);
+	const [L1, a1, b1] = Array.from(a.lab());
+	const [L2, a2, b2] = Array.from(b.lab());
+	const avgL = (L1 + L2) / 2;
+	const avgC = (sqrt(pow(a1, 2) + pow(b1, 2)) + sqrt(pow(a2, 2) + pow(b2, 2))) / 2;
+	const G = .5 * (1 - sqrt(pow(avgC, 7) / (pow(avgC, 7) + pow(25, 7))));
+	const a1p = a1 * (1 + G);
+	const a2p = a2 * (1 + G);
+	const C1p = sqrt(pow(a1p, 2) + pow(b1, 2));
+	const C2p = sqrt(pow(a2p, 2) + pow(b2, 2));
+	const avgCp = (C1p + C2p) / 2;
+	const arctan1 = rad2deg(atan2(b1, a1p));
+	const arctan2 = rad2deg(atan2(b2, a2p));
+	const h1p = arctan1 >= 0 ? arctan1 : arctan1 + 360;
+	const h2p = arctan2 >= 0 ? arctan2 : arctan2 + 360;
+	const avgHp = abs(h1p - h2p) > 180 ? (h1p + h2p + 360) / 2 : (h1p + h2p) / 2;
+	const T = 1 - .17 * cos(deg2rad(avgHp - 30)) + .24 * cos(deg2rad(2 * avgHp)) + .32 * cos(deg2rad(3 * avgHp + 6)) - .2 * cos(deg2rad(4 * avgHp - 63));
+	let deltaHp = h2p - h1p;
+	deltaHp = abs(deltaHp) <= 180 ? deltaHp : h2p <= h1p ? deltaHp + 360 : deltaHp - 360;
+	deltaHp = 2 * sqrt(C1p * C2p) * sin(deg2rad(deltaHp) / 2);
+	const deltaL = L2 - L1;
+	const deltaCp = C2p - C1p;
+	const sl = 1 + .015 * pow(avgL - 50, 2) / sqrt(20 + pow(avgL - 50, 2));
+	const sc = 1 + .045 * avgCp;
+	const sh = 1 + .015 * avgCp * T;
+	const deltaTheta = 30 * exp(-pow((avgHp - 275) / 25, 2));
+	const Rt = -(2 * sqrt(pow(avgCp, 7) / (pow(avgCp, 7) + pow(25, 7)))) * sin(2 * deg2rad(deltaTheta));
+	return max$1(0, min(100, sqrt(pow(deltaL / (Kl * sl), 2) + pow(deltaCp / (Kc * sc), 2) + pow(deltaHp / (Kh * sh), 2) + Rt * (deltaCp / (Kc * sc)) * (deltaHp / (Kh * sh)))));
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/utils/distance.js
+function distance_default(a, b, mode = "lab") {
+	a = new Color_default(a);
+	b = new Color_default(b);
+	const l1 = a.get(mode);
+	const l2 = b.get(mode);
+	let sum_sq = 0;
+	for (let i in l1) {
+		const d = (l1[i] || 0) - (l2[i] || 0);
+		sum_sq += d * d;
+	}
+	return Math.sqrt(sum_sq);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/utils/valid.js
+var valid_default = (...args) => {
+	try {
+		new Color_default(...args);
+		return true;
+	} catch (e) {
+		return false;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/utils/scales.js
+var scales_default = {
+	cool() {
+		return scale_default([chroma_default.hsl(180, 1, .9), chroma_default.hsl(250, .7, .4)]);
+	},
+	hot() {
+		return scale_default([
+			"#000",
+			"#f00",
+			"#ff0",
+			"#fff"
+		], [
+			0,
+			.25,
+			.75,
+			1
+		]).mode("rgb");
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/colors/colorbrewer.js
+/**
+ColorBrewer colors for chroma.js
+
+Copyright (c) 2002 Cynthia Brewer, Mark Harrower, and The
+Pennsylvania State University.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+*/
+const colorbrewer = {
+	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 colorbrewerTypes = Object.keys(colorbrewer);
+const typeMap = new Map(colorbrewerTypes.map((key) => [key.toLowerCase(), key]));
+const colorbrewerProxy = typeof Proxy === "function" ? new Proxy(colorbrewer, {
+	get(target, prop) {
+		const lower = prop.toLowerCase();
+		if (typeMap.has(lower)) return target[typeMap.get(lower)];
+	},
+	getOwnPropertyNames() {
+		return Object.getOwnPropertyNames(colorbrewerTypes);
+	}
+}) : colorbrewer;
+var colorbrewer_default = colorbrewerProxy;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/cmyk/cmyk2rgb.js
+const cmyk2rgb = (...args) => {
+	args = unpack_default(args, "cmyk");
+	const [c, m, y, k] = args;
+	const alpha = args.length > 4 ? args[4] : 1;
+	if (k === 1) return [
+		0,
+		0,
+		0,
+		alpha
+	];
+	return [
+		c >= 1 ? 0 : 255 * (1 - c) * (1 - k),
+		m >= 1 ? 0 : 255 * (1 - m) * (1 - k),
+		y >= 1 ? 0 : 255 * (1 - y) * (1 - k),
+		alpha
+	];
+};
+var cmyk2rgb_default = cmyk2rgb;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/cmyk/rgb2cmyk.js
+const { max } = Math;
+const rgb2cmyk = (...args) => {
+	let [r, g, b] = unpack_default(args, "rgb");
+	r = r / 255;
+	g = g / 255;
+	b = b / 255;
+	const k = 1 - max(r, max(g, b));
+	const f = k < 1 ? 1 / (1 - k) : 0;
+	return [
+		(1 - r - k) * f,
+		(1 - g - k) * f,
+		(1 - b - k) * f,
+		k
+	];
+};
+var rgb2cmyk_default = rgb2cmyk;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/cmyk/index.js
+Color_default.prototype.cmyk = function() {
+	return rgb2cmyk_default(this._rgb);
+};
+const cmyk = (...args) => new Color_default(...args, "cmyk");
+Object.assign(chroma_default, { cmyk });
+input_default.format.cmyk = cmyk2rgb_default;
+input_default.autodetect.push({
+	p: 2,
+	test: (...args) => {
+		args = unpack_default(args, "cmyk");
+		if (type_default(args) === "array" && args.length === 4) return "cmyk";
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/css/hsl2css.js
+const hsl2css = (...args) => {
+	const hsla = unpack_default(args, "hsla");
+	let mode = last_default(args) || "lsa";
+	hsla[0] = rnd2(hsla[0] || 0) + "deg";
+	hsla[1] = rnd2(hsla[1] * 100) + "%";
+	hsla[2] = rnd2(hsla[2] * 100) + "%";
+	if (mode === "hsla" || hsla.length > 3 && hsla[3] < 1) {
+		hsla[3] = "/ " + (hsla.length > 3 ? hsla[3] : 1);
+		mode = "hsla";
+	} else hsla.length = 3;
+	return `${mode.substr(0, 3)}(${hsla.join(" ")})`;
+};
+var hsl2css_default = hsl2css;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/css/lab2css.js
+const lab2css = (...args) => {
+	const laba = unpack_default(args, "lab");
+	let mode = last_default(args) || "lab";
+	laba[0] = rnd2(laba[0]) + "%";
+	laba[1] = rnd2(laba[1]);
+	laba[2] = rnd2(laba[2]);
+	if (mode === "laba" || laba.length > 3 && laba[3] < 1) laba[3] = "/ " + (laba.length > 3 ? laba[3] : 1);
+	else laba.length = 3;
+	return `lab(${laba.join(" ")})`;
+};
+var lab2css_default = lab2css;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/css/lch2css.js
+const lch2css = (...args) => {
+	const lcha = unpack_default(args, "lch");
+	let mode = last_default(args) || "lab";
+	lcha[0] = rnd2(lcha[0]) + "%";
+	lcha[1] = rnd2(lcha[1]);
+	lcha[2] = isNaN(lcha[2]) ? "none" : rnd2(lcha[2]) + "deg";
+	if (mode === "lcha" || lcha.length > 3 && lcha[3] < 1) lcha[3] = "/ " + (lcha.length > 3 ? lcha[3] : 1);
+	else lcha.length = 3;
+	return `lch(${lcha.join(" ")})`;
+};
+var lch2css_default = lch2css;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/css/oklab2css.js
+const oklab2css = (...args) => {
+	const laba = unpack_default(args, "lab");
+	laba[0] = rnd2(laba[0] * 100) + "%";
+	laba[1] = rnd3(laba[1]);
+	laba[2] = rnd3(laba[2]);
+	if (laba.length > 3 && laba[3] < 1) laba[3] = "/ " + (laba.length > 3 ? laba[3] : 1);
+	else laba.length = 3;
+	return `oklab(${laba.join(" ")})`;
+};
+var oklab2css_default = oklab2css;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/oklch/rgb2oklch.js
+const rgb2oklch = (...args) => {
+	const [r, g, b, ...rest] = unpack_default(args, "rgb");
+	const [l, a, b_] = rgb2oklab_default(r, g, b);
+	const [L, c, h] = lab2lch_default(l, a, b_);
+	return [
+		L,
+		c,
+		h,
+		...rest.length > 0 && rest[0] < 1 ? [rest[0]] : []
+	];
+};
+var rgb2oklch_default = rgb2oklch;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/css/oklch2css.js
+const oklch2css = (...args) => {
+	const lcha = unpack_default(args, "lch");
+	lcha[0] = rnd2(lcha[0] * 100) + "%";
+	lcha[1] = rnd3(lcha[1]);
+	lcha[2] = isNaN(lcha[2]) ? "none" : rnd2(lcha[2]) + "deg";
+	if (lcha.length > 3 && lcha[3] < 1) lcha[3] = "/ " + (lcha.length > 3 ? lcha[3] : 1);
+	else lcha.length = 3;
+	return `oklch(${lcha.join(" ")})`;
+};
+var oklch2css_default = oklch2css;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/css/rgb2css.js
+const { round: round$2 } = Math;
+const rgb2css = (...args) => {
+	const rgba = unpack_default(args, "rgba");
+	let mode = last_default(args) || "rgb";
+	if (mode.substr(0, 3) === "hsl") return hsl2css_default(rgb2hsl_default(rgba), mode);
+	if (mode.substr(0, 3) === "lab") {
+		const prevWhitePoint = getLabWhitePoint();
+		setLabWhitePoint("d50");
+		const cssColor = lab2css_default(rgb2lab_default(rgba), mode);
+		setLabWhitePoint(prevWhitePoint);
+		return cssColor;
+	}
+	if (mode.substr(0, 3) === "lch") {
+		const prevWhitePoint = getLabWhitePoint();
+		setLabWhitePoint("d50");
+		const cssColor = lch2css_default(rgb2lch_default(rgba), mode);
+		setLabWhitePoint(prevWhitePoint);
+		return cssColor;
+	}
+	if (mode.substr(0, 5) === "oklab") return oklab2css_default(rgb2oklab_default(rgba));
+	if (mode.substr(0, 5) === "oklch") return oklch2css_default(rgb2oklch_default(rgba));
+	rgba[0] = round$2(rgba[0]);
+	rgba[1] = round$2(rgba[1]);
+	rgba[2] = round$2(rgba[2]);
+	if (mode === "rgba" || rgba.length > 3 && rgba[3] < 1) {
+		rgba[3] = "/ " + (rgba.length > 3 ? rgba[3] : 1);
+		mode = "rgba";
+	}
+	return `${mode.substr(0, 3)}(${rgba.slice(0, mode === "rgb" ? 3 : 4).join(" ")})`;
+};
+var rgb2css_default = rgb2css;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/oklch/oklch2rgb.js
+const oklch2rgb = (...args) => {
+	args = unpack_default(args, "lch");
+	const [l, c, h, ...rest] = args;
+	const [L, a, b_] = lch2lab_default(l, c, h);
+	const [r, g, b] = oklab2rgb_default(L, a, b_);
+	return [
+		r,
+		g,
+		b,
+		...rest.length > 0 && rest[0] < 1 ? [rest[0]] : []
+	];
+};
+var oklch2rgb_default = oklch2rgb;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/css/css2rgb.js
+const INT_OR_PCT = /((?:-?\d+)|(?:-?\d+(?:\.\d+)?)%|none)/.source;
+const FLOAT_OR_PCT = /((?:-?(?:\d+(?:\.\d*)?|\.\d+)%?)|none)/.source;
+const PCT = /((?:-?(?:\d+(?:\.\d*)?|\.\d+)%)|none)/.source;
+const RE_S = /\s*/.source;
+const SEP = /\s+/.source;
+const COMMA = /\s*,\s*/.source;
+const ANLGE = /((?:-?(?:\d+(?:\.\d*)?|\.\d+)(?:deg)?)|none)/.source;
+const ALPHA = /\s*(?:\/\s*((?:[01]|[01]?\.\d+)|\d+(?:\.\d+)?%))?/.source;
+const RE_RGB = new RegExp("^rgba?\\(" + RE_S + [
+	INT_OR_PCT,
+	INT_OR_PCT,
+	INT_OR_PCT
+].join(SEP) + ALPHA + "\\)$");
+const RE_RGB_LEGACY = new RegExp("^rgb\\(" + RE_S + [
+	INT_OR_PCT,
+	INT_OR_PCT,
+	INT_OR_PCT
+].join(COMMA) + RE_S + "\\)$");
+const RE_RGBA_LEGACY = new RegExp("^rgba\\(" + RE_S + [
+	INT_OR_PCT,
+	INT_OR_PCT,
+	INT_OR_PCT,
+	FLOAT_OR_PCT
+].join(COMMA) + RE_S + "\\)$");
+const RE_HSL = new RegExp("^hsla?\\(" + RE_S + [
+	ANLGE,
+	PCT,
+	PCT
+].join(SEP) + ALPHA + "\\)$");
+const RE_HSL_LEGACY = new RegExp("^hsl?\\(" + RE_S + [
+	ANLGE,
+	PCT,
+	PCT
+].join(COMMA) + RE_S + "\\)$");
+const RE_HSLA_LEGACY = /^hsla\(\s*(-?\d+(?:\.\d+)?),\s*(-?\d+(?:\.\d+)?)%\s*,\s*(-?\d+(?:\.\d+)?)%\s*,\s*([01]|[01]?\.\d+)\)$/;
+const RE_LAB = new RegExp("^lab\\(" + RE_S + [
+	FLOAT_OR_PCT,
+	FLOAT_OR_PCT,
+	FLOAT_OR_PCT
+].join(SEP) + ALPHA + "\\)$");
+const RE_LCH = new RegExp("^lch\\(" + RE_S + [
+	FLOAT_OR_PCT,
+	FLOAT_OR_PCT,
+	ANLGE
+].join(SEP) + ALPHA + "\\)$");
+const RE_OKLAB = new RegExp("^oklab\\(" + RE_S + [
+	FLOAT_OR_PCT,
+	FLOAT_OR_PCT,
+	FLOAT_OR_PCT
+].join(SEP) + ALPHA + "\\)$");
+const RE_OKLCH = new RegExp("^oklch\\(" + RE_S + [
+	FLOAT_OR_PCT,
+	FLOAT_OR_PCT,
+	ANLGE
+].join(SEP) + ALPHA + "\\)$");
+const { round: round$1 } = Math;
+const roundRGB = (rgb) => {
+	return rgb.map((v, i) => i <= 2 ? limit_default(round$1(v), 0, 255) : v);
+};
+const percentToAbsolute = (pct, min = 0, max = 100, signed = false) => {
+	if (typeof pct === "string" && pct.endsWith("%")) {
+		pct = parseFloat(pct.substring(0, pct.length - 1)) / 100;
+		if (signed) pct = min + (pct + 1) * .5 * (max - min);
+		else pct = min + pct * (max - min);
+	}
+	return +pct;
+};
+const noneToValue = (v, noneValue) => {
+	return v === "none" ? noneValue : v;
+};
+const css2rgb = (css) => {
+	css = css.toLowerCase().trim();
+	if (css === "transparent") return [
+		0,
+		0,
+		0,
+		0
+	];
+	let m;
+	if (input_default.format.named) try {
+		return input_default.format.named(css);
+	} catch (e) {}
+	if ((m = css.match(RE_RGB)) || (m = css.match(RE_RGB_LEGACY))) {
+		let rgb = m.slice(1, 4);
+		for (let i = 0; i < 3; i++) rgb[i] = +percentToAbsolute(noneToValue(rgb[i], 0), 0, 255);
+		rgb = roundRGB(rgb);
+		const alpha = m[4] !== void 0 ? +percentToAbsolute(m[4], 0, 1) : 1;
+		rgb[3] = alpha;
+		return rgb;
+	}
+	if (m = css.match(RE_RGBA_LEGACY)) {
+		const rgb = m.slice(1, 5);
+		for (let i = 0; i < 4; i++) rgb[i] = +percentToAbsolute(rgb[i], 0, 255);
+		return rgb;
+	}
+	if ((m = css.match(RE_HSL)) || (m = css.match(RE_HSL_LEGACY))) {
+		const hsl = m.slice(1, 4);
+		hsl[0] = +noneToValue(hsl[0].replace("deg", ""), 0);
+		hsl[1] = +percentToAbsolute(noneToValue(hsl[1], 0), 0, 100) * .01;
+		hsl[2] = +percentToAbsolute(noneToValue(hsl[2], 0), 0, 100) * .01;
+		const rgb = roundRGB(hsl2rgb_default(hsl));
+		rgb[3] = m[4] !== void 0 ? +percentToAbsolute(m[4], 0, 1) : 1;
+		return rgb;
+	}
+	if (m = css.match(RE_HSLA_LEGACY)) {
+		const hsl = m.slice(1, 4);
+		hsl[1] *= .01;
+		hsl[2] *= .01;
+		const rgb = hsl2rgb_default(hsl);
+		for (let i = 0; i < 3; i++) rgb[i] = round$1(rgb[i]);
+		rgb[3] = +m[4];
+		return rgb;
+	}
+	if (m = css.match(RE_LAB)) {
+		const lab = m.slice(1, 4);
+		lab[0] = percentToAbsolute(noneToValue(lab[0], 0), 0, 100);
+		lab[1] = percentToAbsolute(noneToValue(lab[1], 0), -125, 125, true);
+		lab[2] = percentToAbsolute(noneToValue(lab[2], 0), -125, 125, true);
+		const wp = getLabWhitePoint();
+		setLabWhitePoint("d50");
+		const rgb = roundRGB(lab2rgb_default(lab));
+		setLabWhitePoint(wp);
+		rgb[3] = m[4] !== void 0 ? +percentToAbsolute(m[4], 0, 1) : 1;
+		return rgb;
+	}
+	if (m = css.match(RE_LCH)) {
+		const lch = m.slice(1, 4);
+		lch[0] = percentToAbsolute(lch[0], 0, 100);
+		lch[1] = percentToAbsolute(noneToValue(lch[1], 0), 0, 150, false);
+		lch[2] = +noneToValue(lch[2].replace("deg", ""), 0);
+		const wp = getLabWhitePoint();
+		setLabWhitePoint("d50");
+		const rgb = roundRGB(lch2rgb_default(lch));
+		setLabWhitePoint(wp);
+		rgb[3] = m[4] !== void 0 ? +percentToAbsolute(m[4], 0, 1) : 1;
+		return rgb;
+	}
+	if (m = css.match(RE_OKLAB)) {
+		const oklab = m.slice(1, 4);
+		oklab[0] = percentToAbsolute(noneToValue(oklab[0], 0), 0, 1);
+		oklab[1] = percentToAbsolute(noneToValue(oklab[1], 0), -.4, .4, true);
+		oklab[2] = percentToAbsolute(noneToValue(oklab[2], 0), -.4, .4, true);
+		const rgb = roundRGB(oklab2rgb_default(oklab));
+		rgb[3] = m[4] !== void 0 ? +percentToAbsolute(m[4], 0, 1) : 1;
+		return rgb;
+	}
+	if (m = css.match(RE_OKLCH)) {
+		const oklch = m.slice(1, 4);
+		oklch[0] = percentToAbsolute(noneToValue(oklch[0], 0), 0, 1);
+		oklch[1] = percentToAbsolute(noneToValue(oklch[1], 0), 0, .4, false);
+		oklch[2] = +noneToValue(oklch[2].replace("deg", ""), 0);
+		const rgb = roundRGB(oklch2rgb_default(oklch));
+		rgb[3] = m[4] !== void 0 ? +percentToAbsolute(m[4], 0, 1) : 1;
+		return rgb;
+	}
+};
+css2rgb.test = (s) => {
+	return RE_RGB.test(s) || RE_HSL.test(s) || RE_LAB.test(s) || RE_LCH.test(s) || RE_OKLAB.test(s) || RE_OKLCH.test(s) || RE_RGB_LEGACY.test(s) || RE_RGBA_LEGACY.test(s) || RE_HSL_LEGACY.test(s) || RE_HSLA_LEGACY.test(s) || s === "transparent";
+};
+var css2rgb_default = css2rgb;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/css/index.js
+Color_default.prototype.css = function(mode) {
+	return rgb2css_default(this._rgb, mode);
+};
+const css = (...args) => new Color_default(...args, "css");
+chroma_default.css = css;
+input_default.format.css = css2rgb_default;
+input_default.autodetect.push({
+	p: 5,
+	test: (h, ...rest) => {
+		if (!rest.length && type_default(h) === "string" && css2rgb_default.test(h)) return "css";
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/gl/index.js
+input_default.format.gl = (...args) => {
+	const rgb = unpack_default(args, "rgba");
+	rgb[0] *= 255;
+	rgb[1] *= 255;
+	rgb[2] *= 255;
+	return rgb;
+};
+const gl = (...args) => new Color_default(...args, "gl");
+chroma_default.gl = gl;
+Color_default.prototype.gl = function() {
+	const rgb = this._rgb;
+	return [
+		rgb[0] / 255,
+		rgb[1] / 255,
+		rgb[2] / 255,
+		rgb[3]
+	];
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/hex/index.js
+Color_default.prototype.hex = function(mode) {
+	return rgb2hex_default(this._rgb, mode);
+};
+const hex = (...args) => new Color_default(...args, "hex");
+chroma_default.hex = hex;
+input_default.format.hex = hex2rgb_default;
+input_default.autodetect.push({
+	p: 4,
+	test: (h, ...rest) => {
+		if (!rest.length && type_default(h) === "string" && [
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9
+		].indexOf(h.length) >= 0) return "hex";
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/temp/temperature2rgb.js
+const { log } = Math;
+const temperature2rgb = (kelvin) => {
+	const temp = kelvin / 100;
+	let r, g, b;
+	if (temp < 66) {
+		r = 255;
+		g = temp < 6 ? 0 : -155.25485562709179 - .44596950469579133 * (g = temp - 2) + 104.49216199393888 * log(g);
+		b = temp < 20 ? 0 : -254.76935184120902 + .8274096064007395 * (b = temp - 10) + 115.67994401066147 * log(b);
+	} else {
+		r = 351.97690566805693 + .114206453784165 * (r = temp - 55) - 40.25366309332127 * log(r);
+		g = 325.4494125711974 + .07943456536662342 * (g = temp - 50) - 28.0852963507957 * log(g);
+		b = 255;
+	}
+	return [
+		r,
+		g,
+		b,
+		1
+	];
+};
+var temperature2rgb_default = temperature2rgb;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/temp/rgb2temperature.js
+const { round } = Math;
+const rgb2temperature = (...args) => {
+	const rgb = unpack_default(args, "rgb");
+	const r = rgb[0], b = rgb[2];
+	let minTemp = 1e3;
+	let maxTemp = 4e4;
+	const eps = .4;
+	let temp;
+	while (maxTemp - minTemp > eps) {
+		temp = (maxTemp + minTemp) * .5;
+		const rgb = temperature2rgb_default(temp);
+		if (rgb[2] / rgb[0] >= b / r) maxTemp = temp;
+		else minTemp = temp;
+	}
+	return round(temp);
+};
+var rgb2temperature_default = rgb2temperature;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/temp/index.js
+Color_default.prototype.temp = Color_default.prototype.kelvin = Color_default.prototype.temperature = function() {
+	return rgb2temperature_default(this._rgb);
+};
+const temp = (...args) => new Color_default(...args, "temp");
+Object.assign(chroma_default, {
+	temp,
+	kelvin: temp,
+	temperature: temp
+});
+input_default.format.temp = input_default.format.kelvin = input_default.format.temperature = temperature2rgb_default;
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/src/io/oklch/index.js
+Color_default.prototype.oklch = function() {
+	return rgb2oklch_default(this._rgb);
+};
+const oklch = (...args) => new Color_default(...args, "oklch");
+Object.assign(chroma_default, { oklch });
+input_default.format.oklch = oklch2rgb_default;
+input_default.autodetect.push({
+	p: 2,
+	test: (...args) => {
+		args = unpack_default(args, "oklch");
+		if (type_default(args) === "array" && args.length === 3) return "oklch";
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840c5155f1e299d91bd40b2a8eb0f3e4c0c62d1c/node_modules/chroma-js/index.js
+Object.assign(chroma_default, {
+	analyze,
+	average: average_default,
+	bezier: bezier_default,
+	blend: blend_default,
+	brewer: colorbrewer_default,
+	Color: Color_default,
+	colors: w3cx11_default,
+	contrast: contrast_default,
+	contrastAPCA: contrastAPCA_default,
+	cubehelix: cubehelix_default,
+	deltaE: delta_e_default,
+	distance: distance_default,
+	input: input_default,
+	interpolate: mix_default,
+	limits,
+	mix: mix_default,
+	random: random_default,
+	scale: scale_default,
+	scales: scales_default,
+	valid: valid_default
+});
+var chroma_js_default = chroma_default;
+
+//#endregion
+//#region ../../node_modules/.pnpm/@mantine+colors-generator@8.3.13_chroma-js@3.2.0_patch_hash=d987322bee5bda6851d8538d840_5f8f37723442888f47e0bba4bb8659dc/node_modules/@mantine/colors-generator/esm/generate-colors.mjs
+const LIGHTNESS_MAP = [
+	.96,
+	.907,
+	.805,
+	.697,
+	.605,
+	.547,
+	.518,
+	.445,
+	.395,
+	.34
+];
+const SATURATION_MAP = [
+	.32,
+	.16,
+	.08,
+	.04,
+	0,
+	0,
+	.04,
+	.08,
+	.16,
+	.32
+];
+function getClosestLightness(colorObject) {
+	const lightnessGoal = colorObject.get("hsl.l");
+	return LIGHTNESS_MAP.reduce((prev, curr) => Math.abs(curr - lightnessGoal) < Math.abs(prev - lightnessGoal) ? curr : prev);
+}
+function generateColorsMap(color) {
+	const colorObject = chroma_js_default(color);
+	const closestLightness = getClosestLightness(colorObject);
+	const baseColorIndex = LIGHTNESS_MAP.findIndex((l) => l === closestLightness);
+	const colors = LIGHTNESS_MAP.map((l) => colorObject.set("hsl.l", l)).map((c) => chroma_js_default(c)).map((c, i) => {
+		const saturationDelta = SATURATION_MAP[i] - SATURATION_MAP[baseColorIndex];
+		return saturationDelta >= 0 ? c.saturate(saturationDelta) : c.desaturate(saturationDelta * -1);
+	});
+	colors[baseColorIndex] = chroma_js_default(color);
+	return {
+		baseColorIndex,
+		colors
+	};
+}
+function generateColors(color) {
+	return generateColorsMap(color).colors.map((c) => c.hex());
+}
+
+//#endregion
+export { chroma_js_default as n, generateColors as t };