@ixfx/components 0.4.2 → 0.4.4

package/dist/colour-C3MQIjFJ-vRCdr8W-.js

@@ -1,3732 +0,0 @@
-import { C as resultThrow, S as percentTest, a as movingAverageLight, b as numberInclusiveRangeTest, g as errorResult, i as interpolate, m as pairwise, t as clamp, u as scaleClamped, x as numberTest } from "./dist-CA13FvMn.js";
-//#region node_modules/.pnpm/@ixfx+visual@0.56.13/node_modules/@ixfx/visual/dist/chunk-pbuEa-1d.js
-var __defProp$1 = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp$1(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp$1(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-//#endregion
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/guard-hlhkAOMZ.js
-/**
-* Returns true if xy (and z, if present) are _null_.
-* @param p
-* @returns True if all props are null
-*/
-function isNull(p) {
-	if (isPoint3d(p)) {
-		if (p.z !== null) return false;
-	}
-	return p.x === null && p.y === null;
-}
-/***
-* Returns true if either x, y, z isNaN.
-*/
-function isNaN(p) {
-	if (isPoint3d(p)) {
-		if (!Number.isNaN(p.z)) return false;
-	}
-	return Number.isNaN(p.x) || Number.isNaN(p.y);
-}
-function pointTest(p, name = `Point`, extraInfo = ``) {
-	if (p === void 0) return errorResult(`'${name}' is undefined. Expected {x,y} got ${JSON.stringify(p)}`, extraInfo);
-	if (p === null) return errorResult(`'${name}' is null. Expected {x,y} got ${JSON.stringify(p)}`, extraInfo);
-	if (typeof p !== `object`) return errorResult(`'${name}' is type '${typeof p}'. Expected object.`, extraInfo);
-	if (p.x === void 0) return errorResult(`'${name}.x' is undefined. Expected {x,y} got ${JSON.stringify(p)}`, extraInfo);
-	if (p.y === void 0) return errorResult(`'${name}.y' is undefined. Expected {x,y} got ${JSON.stringify(p)}`, extraInfo);
-	if (typeof p.x !== `number`) return errorResult(`'${name}.x' must be a number. Got ${typeof p.x}`, extraInfo);
-	if (typeof p.y !== `number`) return errorResult(`'${name}.y' must be a number. Got ${typeof p.y}`, extraInfo);
-	if (p.z !== void 0) {
-		if (typeof p.z !== `number`) return errorResult(`${name}.z must be a number. Got: ${typeof p.z}`, extraInfo);
-		if (Number.isNaN(p.z)) return errorResult(`'${name}.z' is NaN. Got: ${JSON.stringify(p)}`, extraInfo);
-	}
-	if (p.x === null) return errorResult(`'${name}.x' is null`, extraInfo);
-	if (p.y === null) return errorResult(`'${name}.y' is null`, extraInfo);
-	if (Number.isNaN(p.x)) return errorResult(`'${name}.x' is NaN`, extraInfo);
-	if (Number.isNaN(p.y)) return errorResult(`'${name}.y' is NaN`, extraInfo);
-	return {
-		success: true,
-		value: p
-	};
-}
-/**
-* Throws an error if point is invalid
-* @param p
-* @param name
-*/
-function guard$5(p, name = `Point`, info) {
-	resultThrow(pointTest(p, name, info));
-}
-/**
-* Throws if parameter is not a valid point, or either x or y is 0
-* @param pt
-* @returns Throws an error if not a valid point or zero.
-*/
-function guardNonZeroPoint(pt, name = `pt`) {
-	guard$5(pt, name);
-	resultThrow(numberTest(pt.x, `nonZero`, `${name}.x`), numberTest(pt.y, `nonZero`, `${name}.y`), () => {
-		if (typeof pt.z !== `undefined`) return numberTest(pt.z, `nonZero`, `${name}.z`);
-	});
-	return true;
-}
-/**
-* Returns _true_ if `p` has x & y properties.
-* Returns _false_ if `p` is undefined, null or does not contain properties.
-* Use {@link isPoint3d} to check further check for `z`.
-* @param p
-* @returns True if `p` has x & y props
-*/
-function isPoint(p) {
-	if (p === void 0) return false;
-	if (p === null) return false;
-	if (p.x === void 0) return false;
-	if (p.y === void 0) return false;
-	return true;
-}
-/**
-* Returns _true_ if `p` has x, y, & z properties.
-* Returns _false_ if `p` is undefined, null or does not contain properties.
-* @param p
-* @returns _True_ if `p` has x, y, & z props
-*/
-function isPoint3d(p) {
-	if (p === void 0) return false;
-	if (p === null) return false;
-	if (p.x === void 0) return false;
-	if (p.y === void 0) return false;
-	if (p.z === void 0) return false;
-	return true;
-}
-/**
-* Returns true if both xy (and z, if present) are 0.
-* Use `Points.Empty` to return an empty point.
-* @param p
-* @returns _True_ is all props are 0
-*/
-function isEmpty(p) {
-	if (isPoint3d(p)) {
-		if (p.z !== 0) return false;
-	}
-	return p.x === 0 && p.y === 0;
-}
-/**
-* Returns true if point is a placeholder, where xy (and z, if present)
-* are `NaN`.
-*
-* Use Points.Placeholder to return a placeholder point.
-* @param p
-* @returns True if all props are NaN
-*/
-function isPlaceholder(p) {
-	if (isPoint3d(p)) {
-		if (!Number.isNaN(p.z)) return false;
-	}
-	return Number.isNaN(p.x) && Number.isNaN(p.y);
-}
-//#endregion
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/angles-BkBEzlEN.js
-const piPi = Math.PI * 2;
-/**
-* Averages a set of points, by default as a 'mean'.
-* 
-* List of points has to all have Z property or none of them -- it's not
-* possible to mix 2D and 3D points.
-* @param points 
-* @returns 
-*/
-const average$1 = (points, kind = `mean`) => {
-	let xSum = 0;
-	let ySum = 0;
-	let zSum = NaN;
-	let total = 0;
-	if (kind !== `mean`) throw new Error(`Unknown averaging kind: '${kind}' expected: 'mean'`);
-	for (const p of points) {
-		xSum += p.x;
-		ySum += p.y;
-		if (`z` in p && p.z !== void 0) zSum += p.z;
-		else if (Number.isNaN(zSum)) throw new Error(`List of points should all have Z property, or none`);
-		total++;
-	}
-	xSum /= total;
-	ySum /= total;
-	if (Number.isNaN(zSum)) return {
-		x: xSum,
-		y: ySum
-	};
-	else return {
-		x: xSum,
-		y: ySum,
-		z: zSum / total
-	};
-};
-function averager(kind, opts = {}) {
-	let x;
-	let y;
-	let z;
-	switch (kind) {
-		case `moving-average-light`: {
-			const scaling = opts.scaling ?? 3;
-			x = movingAverageLight(scaling);
-			y = movingAverageLight(scaling);
-			z = movingAverageLight(scaling);
-			break;
-		}
-		default: throw new Error(`Unknown averaging kind '${kind}'. Expected: 'moving-average-light'`);
-	}
-	return (point) => {
-		const ax = x(point.x);
-		const ay = y(point.y);
-		if (isPoint3d(point)) {
-			const az = z(point.z);
-			return Object.freeze({
-				x: ax,
-				y: ay,
-				z: az
-			});
-		} else return Object.freeze({
-			x: ax,
-			y: ay
-		});
-	};
-}
-function degreeToRadian(angleInDegrees) {
-	return Array.isArray(angleInDegrees) ? angleInDegrees.map((v) => v * (Math.PI / 180)) : angleInDegrees * (Math.PI / 180);
-}
-function degreeToGradian(angleInDegrees) {
-	return angleInDegrees * 1.111111;
-}
-/**
-* Returns the gradian value converted to degrees.
-* By default it wraps, so any value 360 or greater wraps around.
-* @param angleInGradians
-* @param wrap
-* @returns Degrees
-*/
-function gradianToDegree(angleInGradians, wrap = true) {
-	if (wrap) return angleInGradians * .9 % 360;
-	return angleInGradians * .9;
-}
-function radianToGradian(angleInRadians) {
-	return angleInRadians * 63.6619772368;
-}
-function gradianToRadian(angleInGradian) {
-	return angleInGradian * .0157079633;
-}
-function radianToDegree(angleInRadians) {
-	return Array.isArray(angleInRadians) ? angleInRadians.map((v) => v * 180 / Math.PI) : angleInRadians * 180 / Math.PI;
-}
-/**
-* Parses CSS-style angle strings into an 'Angle' type. By default assumes degrees.
-*
-* ```js
-* angleParse(`100`);     // { value: 100, unit: `deg` }
-* angleParse(100);       // { value: 100, unit: `deg` }
-* angleParse(`100deg`);  // { value: 100, unit: `deg` }
-*
-* // More exotic units:
-* angleParse(`100rad`);  // { value: 100, unit: `rad` }
-* angleParse(`100turn`); // { value: 100, unit: `turn` }
-* angleParse(`100grad`); // { value: 100, unit: `grad` }
-* angleParse(`n`); // { value: 90, unit: `deg` }
-* angleParse(`e`); // { value: 0, unit: `deg` }
-* angleParse(`s`); // { value: 270, unit: `deg` }
-* angleParse(`w`); // { value: 180, unit: `deg` }
-* angleParse(`ne`); // ne/nw/se/sw supported
-* // Once parsed, use angleConvert to convert to a different unit:
-* angleConvert(`100rad`, `deg`); // { value: 5729.57795, unit: `deg` }
-* ```
-*
-* Once parsed in this format, use {@link angleConvert} to convert to
-* a different unit.
-* @param value
-* @returns Angle
-*/
-function angleParse(value) {
-	if (isAngleType(value)) return value;
-	if (typeof value === `number`) return {
-		value,
-		unit: `deg`
-	};
-	value = value.toLowerCase();
-	let unit = `deg`;
-	let numberValue = NaN;
-	if (value.endsWith(`grad`)) {
-		numberValue = Number.parseFloat(value.substring(0, value.length - 4));
-		unit = `grad`;
-	} else if (value.endsWith(`rad`)) {
-		numberValue = Number.parseFloat(value.substring(0, value.length - 3));
-		unit = `rad`;
-	} else if (value.endsWith(`turn`)) {
-		numberValue = Number.parseFloat(value.substring(0, value.length - 4));
-		unit = `turn`;
-	} else if (value.endsWith(`deg`)) {
-		numberValue = Number.parseFloat(value.substring(0, value.length - 3));
-		unit = `deg`;
-	} else numberValue = Number.parseFloat(value);
-	if (Number.isNaN(numberValue)) if (value === `n`) return {
-		value: 90,
-		unit: `deg`
-	};
-	else if (value === `e`) return {
-		value: 0,
-		unit: `deg`
-	};
-	else if (value === `s`) return {
-		value: 270,
-		unit: `deg`
-	};
-	else if (value === `w`) return {
-		value: 180,
-		unit: `deg`
-	};
-	else if (value === `ne`) return {
-		value: 45,
-		unit: `deg`
-	};
-	else if (value === `se`) return {
-		value: 315,
-		unit: `deg`
-	};
-	else if (value === `sw`) return {
-		value: 225,
-		unit: `deg`
-	};
-	else if (value === `nw`) return {
-		value: 135,
-		unit: `deg`
-	};
-	else throw new Error(`Invalid angle (bad value?): '${value}'. If using cardinals, use: 'n', 'se', etc.`);
-	if (unit.length === 0) throw new Error(`Invalid angle (no unit)`);
-	return {
-		value: numberValue,
-		unit
-	};
-}
-function isAngleType(v) {
-	if (typeof v !== `object`) return false;
-	if (`unit` in v && `value` in v) {
-		if (typeof v.unit !== `string`) return false;
-		if (typeof v.value !== `number`) return false;
-		return true;
-	}
-	return false;
-}
-/**
-* Converts an angle to another representation.
-* Input value is assumed degrees unless it's an {@link Angle} type of has the unit.
-*
-* These are all identical inputs: 100, `100`, `100deg`
-* ```js
-* angleConvert(100, `rad`); // Converts 100deg to radians
-* ```
-*
-* Other units can be used for string input: `2turn`, `1grad`, `2rad`.
-* ```js
-* angleConvert(`2rad`, `deg`); // Converts 2radians to degrees
-* ```
-*
-* Can also use an object input:
-* ```js
-* angleConvert({ value: 10, unit: `deg`}, `rad`);
-* ```
-* @param angleOrDegrees
-* @param destination
-* @returns Angle
-*/
-function angleConvert(angleOrDegrees, destination) {
-	const input = typeof angleOrDegrees === `object` ? angleOrDegrees : angleParse(angleOrDegrees);
-	switch (destination) {
-		case `deg`:
-			if (input.unit === `deg`) return input;
-			if (input.unit === `rad`) return {
-				value: radianToDegree(input.value),
-				unit: `deg`
-			};
-			if (input.unit === `grad`) return {
-				value: gradianToDegree(input.value),
-				unit: `deg`
-			};
-			if (input.unit === `turn`) return {
-				value: turnToDegree(input.value),
-				unit: `deg`
-			};
-			throw new Error(`Unknown unit: ${input.unit}`);
-		case `grad`:
-			if (input.unit === `deg`) return {
-				value: degreeToGradian(input.value),
-				unit: `grad`
-			};
-			if (input.unit === `rad`) return {
-				value: radianToGradian(input.value),
-				unit: `grad`
-			};
-			if (input.unit === `grad`) return input;
-			if (input.unit === `turn`) return {
-				value: radianToGradian(turnToRadian(input.value)),
-				unit: `grad`
-			};
-			throw new Error(`Unknown unit: ${input.unit}`);
-		case `rad`:
-			if (input.unit === `deg`) return {
-				value: degreeToRadian(input.value),
-				unit: `rad`
-			};
-			if (input.unit === `rad`) return input;
-			if (input.unit === `grad`) return {
-				value: gradianToRadian(input.value),
-				unit: `rad`
-			};
-			if (input.unit === `turn`) return {
-				value: turnToRadian(input.value),
-				unit: `rad`
-			};
-			throw new Error(`Unknown unit: ${input.unit}`);
-		case `turn`:
-			if (input.unit === `deg`) return {
-				value: degreeToTurn(input.value),
-				unit: `turn`
-			};
-			if (input.unit === `rad`) return {
-				value: radianToTurn(input.value),
-				unit: `turn`
-			};
-			if (input.unit === `grad`) return {
-				value: radianToTurn(gradianToRadian(input.value)),
-				unit: `turn`
-			};
-			if (input.unit === `turn`) return input;
-			throw new Error(`Unknown unit: ${input.unit}`);
-		default: throw new Error(`Destination unit unknown ('${destination}). Expects: deg, grad, rad or turn`);
-	}
-}
-/**
-* Converts 'turns' to degrees. By defaults wraps the value, so
-* turn value of 1 or 2 equal 0deg instead of 360 or 720deg.
-* @param turns
-* @param wrap
-* @returns Degrees
-*/
-function turnToDegree(turns, wrap = true) {
-	if (wrap) return turns * 360 % 360;
-	return turns * 360;
-}
-/**
-* Normalise a radian angle to 0..2*PI range
-* @param angleRadian
-* @returns Normalised angle
-*/
-function radiansNormalise(angleRadian) {
-	angleRadian %= piPi;
-	return angleRadian < 0 ? angleRadian + piPi : angleRadian;
-}
-function turnToRadian(turns) {
-	return turns * piPi;
-}
-function degreeToTurn(degrees) {
-	return degrees / 360;
-}
-function radianToTurn(radians) {
-	return radians / piPi;
-}
-//#endregion
-//#region node_modules/.pnpm/@ixfx+visual@0.56.13/node_modules/@ixfx/visual/dist/colour-C3MQIjFJ.js
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {
-	enumerable: true,
-	configurable: true,
-	writable: true,
-	value
-}) : obj[key] = value;
-var __export = (target, all) => {
-	for (var name2 in all) __defProp(target, name2, {
-		get: all[name2],
-		enumerable: true
-	});
-};
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var COLOR_KEYS = {
-	hsl: [
-		"h",
-		"s",
-		"l"
-	],
-	oklab: [
-		"l",
-		"a",
-		"b"
-	],
-	oklch: [
-		"l",
-		"c",
-		"h"
-	],
-	rgb: [
-		"r",
-		"g",
-		"b"
-	]
-};
-var COLOR_MODELS = [
-	"hsl",
-	"oklab",
-	"oklch",
-	"rgb"
-];
-var DEG2RAD = Math.PI / 180;
-var LAB_TO_LMS = {
-	l: [.3963377773761749, .2158037573099136],
-	m: [-.1055613458156586, -.0638541728258133],
-	s: [-.0894841775298119, -1.2914855480194092]
-};
-var LRGB_TO_LMS = {
-	l: [
-		.4122214708,
-		.5363325363,
-		.0514459929
-	],
-	m: [
-		.2119034982,
-		.6806995451,
-		.1073969566
-	],
-	s: [
-		.0883024619,
-		.2817188376,
-		.6299787005
-	]
-};
-var LSM_TO_LAB = {
-	l: [
-		.2104542553,
-		.793617785,
-		.0040720468
-	],
-	a: [
-		1.9779984951,
-		2.428592205,
-		.4505937099
-	],
-	b: [
-		.0259040371,
-		.7827717662,
-		.808675766
-	]
-};
-var LSM_TO_RGB = {
-	r: [
-		4.076741636075958,
-		-3.307711539258063,
-		.2309699031821043
-	],
-	g: [
-		-1.2684379732850315,
-		2.609757349287688,
-		-.341319376002657
-	],
-	b: [
-		-.0041960761386756,
-		-.7034186179359362,
-		1.7076146940746117
-	]
-};
-var PRECISION = 5;
-var RAD2DEG = 180 / Math.PI;
-var MESSAGES = {
-	alpha: "alpha must be a number between 0 and 1",
-	alphaAdjustment: "alpha must be a number between -1 and 1",
-	amount: "amount must be a number between 0 and 100",
-	colorRequired: "color is required",
-	degreesRange: "degrees must be a number between -360 and 360",
-	hueArgs: "point, chroma and h are required",
-	hueRange: "hue must be a number between 0 and 360",
-	input: "input is required",
-	inputHex: "input is required and must be a hex",
-	inputNumber: "input is required and must be a number",
-	inputString: "input is required and must be a string",
-	invalid: "invalid input",
-	invalidColor: "invalid color",
-	invalidCSS: "invalid CSS string",
-	invalidHex: "invalid hex",
-	invalidKey: "invalid key",
-	invalidModel: "invalid model",
-	invalidRange: "color value out of range",
-	left: "left is required and must be a string",
-	lightnessRange: "lightness must be a number between 0 and 1",
-	options: "invalid options",
-	paletteSize: "palette size must be at least 2",
-	ratioRange: "ratio must be a number between 0 and 1",
-	right: "right is required and must be a string",
-	threshold: "threshold must be a number between 0 and 255",
-	thresholdNormalized: "threshold must be a number between 0 and 1"
-};
-function invariant(condition, message) {
-	if (condition) return;
-	const error = !message ? /* @__PURE__ */ new Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.") : new Error(message);
-	error.name = "colorizr";
-	throw error;
-}
-var cssColors = {
-	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",
-	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",
-	grey: "#808080",
-	green: "#008000",
-	greenyellow: "#adff2f",
-	honeydew: "#f0fff0",
-	hotpink: "#ff69b4",
-	indianred: "#cd5c5c",
-	indigo: "#4b0082",
-	ivory: "#fffff0",
-	khaki: "#f0e68c",
-	lavender: "#e6e6fa",
-	lavenderblush: "#fff0f5",
-	lawngreen: "#7cfc00",
-	lemonchiffon: "#fffacd",
-	lightblue: "#add8e6",
-	lightcoral: "#f08080",
-	lightcyan: "#e0ffff",
-	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",
-	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",
-	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 hexRegex = /^#(?:[\da-f]{3,4}|[\da-f]{6,8})$/i;
-function hasValidMatches(input) {
-	return Array.isArray(input) && input.length === 6;
-}
-function isHex(input) {
-	if (!isString(input)) return false;
-	return hexRegex.test(input);
-}
-function isHSL(input) {
-	if (!isPlainObject(input)) return false;
-	const entries = Object.entries(input);
-	return !!entries.length && entries.every(([key, value]) => {
-		if (key === "h") return value >= 0 && value <= 360;
-		if (key === "alpha") return value >= 0 && value <= 1;
-		return COLOR_KEYS.hsl.includes(key) && value >= 0 && value <= 100;
-	});
-}
-function isLAB(input) {
-	if (!isPlainObject(input)) return false;
-	const entries = Object.entries(input);
-	return !!entries.length && entries.every(([key, value]) => {
-		if (key === "l") return value >= 0 && value <= 100;
-		if (key === "alpha") return value >= 0 && value <= 1;
-		return COLOR_KEYS.oklab.includes(key) && value >= -1 && value <= 1;
-	});
-}
-function isLCH(input) {
-	if (!isPlainObject(input)) return false;
-	const entries = Object.entries(input);
-	return !!entries.length && entries.every(([key, value]) => {
-		if (key === "l") return value >= 0 && value <= 100;
-		if (key === "alpha") return value >= 0 && value <= 1;
-		return COLOR_KEYS.oklch.includes(key) && value >= 0 && value <= (key === "h" ? 360 : 1);
-	});
-}
-function isNamedColor(input) {
-	return isString(input) && Object.keys(cssColors).includes(input.toLowerCase());
-}
-function isNumber(input) {
-	return typeof input === "number" && !Number.isNaN(input);
-}
-function isNumberInRange(input, min, max) {
-	return isNumber(input) && input >= min && input <= max;
-}
-function isPlainObject(input) {
-	if (!input) return false;
-	const { toString } = Object.prototype;
-	const prototype = Object.getPrototypeOf(input);
-	return toString.call(input) === "[object Object]" && (prototype === null || prototype === Object.getPrototypeOf({}));
-}
-function isRGB(input) {
-	if (!isPlainObject(input)) return false;
-	const entries = Object.entries(input);
-	return !!entries.length && entries.every(([key, value]) => {
-		if (key === "alpha") return value >= 0 && value <= 1;
-		return COLOR_KEYS.rgb.includes(key) && value >= 0 && value <= 255;
-	});
-}
-function isString(input, validate = true) {
-	const isValid = typeof input === "string";
-	if (validate) return isValid && !!input.trim().length;
-	return isValid;
-}
-function isValidColorModel(input) {
-	return isHSL(input) || isRGB(input) || isLAB(input) || isLCH(input);
-}
-function formatHex(input) {
-	invariant(isHex(input), MESSAGES.inputHex);
-	let color = input.replace("#", "");
-	if (color.length === 3 || color.length === 4) {
-		const values = [...color];
-		color = "";
-		values.forEach((d) => {
-			color += `${d}${d}`;
-		});
-	}
-	const hex = `#${color}`;
-	invariant(isHex(hex), MESSAGES.invalidHex);
-	return hex;
-}
-function addAlpha(input, alpha) {
-	invariant(isValidColorModel(input), MESSAGES.invalid);
-	let value = alpha;
-	if (value === void 0) return input;
-	if (value > 1) value /= 100;
-	if (value === 1) return input;
-	return {
-		...input,
-		alpha: value
-	};
-}
-function clamp$1(value, min = 0, max = 100) {
-	return Math.min(Math.max(value, min), max);
-}
-function constrainDegrees(input, amount) {
-	invariant(isNumber(input), MESSAGES.inputNumber);
-	let value = input + amount;
-	if (value > 360) value %= 360;
-	if (value < 0) value += 360;
-	return Math.abs(value);
-}
-function extractAlpha(input) {
-	if (Array.isArray(input)) return;
-	return input.alpha;
-}
-function limit(input, model, key) {
-	invariant(isNumber(input), MESSAGES.inputNumber);
-	invariant(COLOR_MODELS.includes(model), `${MESSAGES.invalidModel}${model ? `: ${model}` : ""}`);
-	invariant(COLOR_KEYS[model].includes(key), `${MESSAGES.invalidKey}${key ? `: ${key}` : ""}`);
-	switch (model) {
-		case "hsl":
-			invariant(COLOR_KEYS.hsl.includes(key), MESSAGES.invalidKey);
-			if (["l", "s"].includes(key)) return clamp$1(input);
-			return clamp$1(input, 0, 360);
-		case "rgb":
-			invariant(COLOR_KEYS.rgb.includes(key), MESSAGES.invalidKey);
-			return clamp$1(input, 0, 255);
-		default: throw new Error("Invalid inputs");
-	}
-}
-function parseInput(input, model) {
-	const keys = COLOR_KEYS[model];
-	const validator = {
-		hsl: isHSL,
-		oklab: isLAB,
-		oklch: isLCH,
-		rgb: isRGB
-	};
-	invariant(isPlainObject(input) || Array.isArray(input), MESSAGES.invalid);
-	const value = Array.isArray(input) ? {
-		[keys[0]]: input[0],
-		[keys[1]]: input[1],
-		[keys[2]]: input[2]
-	} : input;
-	invariant(validator[model](value), `${MESSAGES.invalidColor}: ${model}`);
-	return value;
-}
-function restrictValues(input, precision = PRECISION, forcePrecision = true) {
-	const output = new Map(Object.entries(input));
-	for (const [key, value] of output.entries()) output.set(key, round$1(value, precision, forcePrecision));
-	return Object.fromEntries(output);
-}
-function round$1(input, precision = 2, forcePrecision = true) {
-	if (!isNumber(input) || input === 0) return 0;
-	if (forcePrecision) {
-		const factor2 = 10 ** precision;
-		return Math.round(input * factor2) / factor2;
-	}
-	let digits = Math.abs(Math.ceil(Math.log(Math.abs(input)) / Math.LN10));
-	if (digits === 0) digits = 2;
-	else if (digits > precision) digits = precision;
-	let exponent = precision - (digits < 0 ? 0 : digits);
-	if (exponent <= 1 && precision > 1) exponent = 2;
-	else if (exponent > precision || exponent === 0) exponent = precision;
-	const factor = 10 ** exponent;
-	return Math.round(input * factor) / factor;
-}
-function addAlphaToHex(input, alpha) {
-	invariant(isHex(input), MESSAGES.inputHex);
-	invariant(isNumberInRange(alpha, 0, 1), MESSAGES.alpha);
-	if (alpha >= 1) return removeAlphaFromHex(input);
-	return `${removeAlphaFromHex(input)}${convertAlphaToHex(alpha)}`;
-}
-function convertAlphaToHex(input) {
-	invariant(isNumber(input), MESSAGES.inputNumber);
-	let alpha = input;
-	if (input > 1) alpha /= 100;
-	return Math.round(alpha * 255).toString(16).padStart(2, "0");
-}
-function extractAlphaFromHex(input) {
-	invariant(isHex(input), MESSAGES.inputString);
-	const alpha = input.substring(7, 9);
-	if (!alpha) return 1;
-	return round$1(parseInt(alpha, 16) / 255);
-}
-function removeAlphaFromHex(input) {
-	invariant(isHex(input), MESSAGES.inputHex);
-	if (input.length === 5) return input.substring(0, 4);
-	return input.substring(0, 7);
-}
-function hex2rgb(input) {
-	invariant(isHex(input), MESSAGES.inputHex);
-	const hex = formatHex(input).slice(1);
-	const alpha = extractAlphaFromHex(input);
-	return addAlpha({
-		r: parseInt(hex.charAt(0) + hex.charAt(1), 16),
-		g: parseInt(hex.charAt(2) + hex.charAt(3), 16),
-		b: parseInt(hex.charAt(4) + hex.charAt(5), 16)
-	}, alpha);
-}
-var converters_exports = {};
-__export(converters_exports, {
-	hex2hsl: () => hex2hsl,
-	hex2oklab: () => hex2oklab,
-	hex2oklch: () => hex2oklch,
-	hex2rgb: () => hex2rgb,
-	hsl2hex: () => hsl2hex,
-	hsl2oklab: () => hsl2oklab,
-	hsl2oklch: () => hsl2oklch,
-	hsl2rgb: () => hsl2rgb,
-	oklab2hex: () => oklab2hex,
-	oklab2hsl: () => oklab2hsl,
-	oklab2oklch: () => oklab2oklch,
-	oklab2rgb: () => oklab2rgb,
-	oklch2hex: () => oklch2hex,
-	oklch2hsl: () => oklch2hsl,
-	oklch2oklab: () => oklch2oklab,
-	oklch2rgb: () => oklch2rgb,
-	rgb2hex: () => rgb2hex,
-	rgb2hsl: () => rgb2hsl,
-	rgb2oklab: () => rgb2oklab,
-	rgb2oklch: () => rgb2oklch
-});
-function rgb2hsl(input) {
-	const value = parseInput(input, "rgb");
-	const alpha = extractAlpha(input);
-	const rLimit = limit(value.r, "rgb", "r") / 255;
-	const gLimit = limit(value.g, "rgb", "g") / 255;
-	const bLimit = limit(value.b, "rgb", "b") / 255;
-	const min = Math.min(rLimit, gLimit, bLimit);
-	const max = Math.max(rLimit, gLimit, bLimit);
-	const delta = max - min;
-	let h = 0;
-	let s;
-	const l = (max + min) / 2;
-	let rate;
-	switch (max) {
-		case rLimit:
-			rate = !delta ? 0 : (gLimit - bLimit) / delta;
-			h = 60 * rate;
-			break;
-		case gLimit:
-			rate = (bLimit - rLimit) / delta;
-			h = 60 * rate + 120;
-			break;
-		case bLimit:
-			rate = (rLimit - gLimit) / delta;
-			h = 60 * rate + 240;
-			break;
-		default: break;
-	}
-	if (h < 0) h = 360 + h;
-	if (min === max) s = 0;
-	else s = l < .5 ? delta / (2 * l) : delta / (2 - 2 * l);
-	return addAlpha({
-		h: Math.abs(+(h % 360).toFixed(2)),
-		s: +(s * 100).toFixed(2),
-		l: +(l * 100).toFixed(2)
-	}, alpha);
-}
-function hex2hsl(input) {
-	invariant(isHex(input), MESSAGES.inputHex);
-	const alpha = extractAlphaFromHex(input);
-	return addAlpha(rgb2hsl(hex2rgb(input)), alpha);
-}
-var { cbrt, sign } = Math;
-function rgb2lrgb(input) {
-	const abs2 = Math.abs(input);
-	if (abs2 < .04045) return input / 12.92;
-	return (sign(input) || 1) * ((abs2 + .055) / 1.055) ** 2.4;
-}
-function rgb2oklab(input, precision = PRECISION) {
-	const value = parseInput(input, "rgb");
-	const alpha = extractAlpha(input);
-	const [lr, lg, lb] = [
-		rgb2lrgb(value.r / 255),
-		rgb2lrgb(value.g / 255),
-		rgb2lrgb(value.b / 255)
-	];
-	const l = cbrt(LRGB_TO_LMS.l[0] * lr + LRGB_TO_LMS.l[1] * lg + LRGB_TO_LMS.l[2] * lb);
-	const m = cbrt(LRGB_TO_LMS.m[0] * lr + LRGB_TO_LMS.m[1] * lg + LRGB_TO_LMS.m[2] * lb);
-	const s = cbrt(LRGB_TO_LMS.s[0] * lr + LRGB_TO_LMS.s[1] * lg + LRGB_TO_LMS.s[2] * lb);
-	return addAlpha(restrictValues({
-		l: LSM_TO_LAB.l[0] * l + LSM_TO_LAB.l[1] * m - LSM_TO_LAB.l[2] * s,
-		a: LSM_TO_LAB.a[0] * l - LSM_TO_LAB.a[1] * m + LSM_TO_LAB.a[2] * s,
-		b: LSM_TO_LAB.b[0] * l + LSM_TO_LAB.b[1] * m - LSM_TO_LAB.b[2] * s
-	}, precision), alpha);
-}
-function hex2oklab(input, precision) {
-	invariant(isHex(input), MESSAGES.inputHex);
-	const alpha = extractAlphaFromHex(input);
-	return addAlpha(rgb2oklab(hex2rgb(input), precision), alpha);
-}
-var { atan2, sqrt } = Math;
-function oklab2oklch(input, precision) {
-	const { l, a, b } = restrictValues(parseInput(input, "oklab"));
-	const alpha = extractAlpha(input);
-	const c = sqrt(a ** 2 + b ** 2);
-	let h = (atan2(b, a) * RAD2DEG + 360) % 360;
-	if (round$1(c * 1e4) === 0) h = 0;
-	return addAlpha(restrictValues({
-		l,
-		c,
-		h
-	}, precision), alpha);
-}
-function rgb2oklch(input, precision) {
-	const value = parseInput(input, "rgb");
-	const alpha = extractAlpha(input);
-	return addAlpha(oklab2oklch(rgb2oklab(value, precision), precision), alpha);
-}
-function hex2oklch(input, precision) {
-	invariant(isHex(input), MESSAGES.inputHex);
-	const alpha = extractAlphaFromHex(input);
-	return addAlpha(rgb2oklch(hex2rgb(input), precision), alpha);
-}
-function hue2rgb(point, chroma2, h) {
-	invariant(isNumber(point) && isNumber(chroma2) && isNumber(h), MESSAGES.hueArgs);
-	let hue = h;
-	if (hue < 0) hue += 1;
-	if (hue > 1) hue -= 1;
-	if (hue < 1 / 6) return round$1(point + (chroma2 - point) * 6 * hue, 4);
-	if (hue < 1 / 2) return round$1(chroma2, 4);
-	if (hue < 2 / 3) return round$1(point + (chroma2 - point) * (2 / 3 - hue) * 6, 4);
-	return round$1(point, 4);
-}
-function hsl2rgb(input) {
-	const value = parseInput(input, "hsl");
-	const alpha = extractAlpha(input);
-	const h = round$1(value.h) / 360;
-	const s = round$1(value.s) / 100;
-	const l = round$1(value.l) / 100;
-	let r;
-	let g;
-	let b;
-	let point;
-	let chroma2;
-	if (s === 0) {
-		r = l;
-		g = l;
-		b = l;
-	} else {
-		chroma2 = l < .5 ? l * (1 + s) : l + s - l * s;
-		point = 2 * l - chroma2;
-		r = hue2rgb(point, chroma2, h + 1 / 3);
-		g = hue2rgb(point, chroma2, h);
-		b = hue2rgb(point, chroma2, h - 1 / 3);
-	}
-	return addAlpha({
-		r: Math.round(r * 255),
-		g: Math.round(g * 255),
-		b: Math.round(b * 255)
-	}, alpha);
-}
-function rgb2hex(input) {
-	const rgb = parseInput(input, "rgb");
-	const alpha = extractAlpha(input);
-	const hex = `#${[
-		rgb.r,
-		rgb.g,
-		rgb.b
-	].map((d) => `0${Math.floor(d).toString(16)}`.slice(-2)).join("")}`;
-	return alpha !== void 0 && alpha < 1 ? addAlphaToHex(hex, alpha) : hex;
-}
-function hsl2hex(input) {
-	const value = parseInput(input, "hsl");
-	const alpha = extractAlpha(input);
-	const hex = rgb2hex(hsl2rgb(value));
-	return alpha !== void 0 && alpha < 1 ? addAlphaToHex(hex, alpha) : hex;
-}
-function hsl2oklab(input, precision) {
-	const value = parseInput(input, "hsl");
-	const alpha = extractAlpha(input);
-	return addAlpha(rgb2oklab(hsl2rgb(value), precision), alpha);
-}
-function hsl2oklch(input, precision) {
-	const value = parseInput(input, "hsl");
-	const alpha = extractAlpha(input);
-	return addAlpha(rgb2oklch(hsl2rgb(value), precision), alpha);
-}
-var { abs } = Math;
-function lrgb2rgb(input) {
-	const absoluteNumber = abs(input);
-	const sign2 = input < 0 ? -1 : 1;
-	if (absoluteNumber > .0031308) return sign2 * (absoluteNumber ** (1 / 2.4) * 1.055 - .055);
-	return input * 12.92;
-}
-function oklab2rgb(input, precision = 0) {
-	const { l: L, a: A, b: B } = parseInput(input, "oklab");
-	const alpha = extractAlpha(input);
-	const l = (L + LAB_TO_LMS.l[0] * A + LAB_TO_LMS.l[1] * B) ** 3;
-	const m = (L + LAB_TO_LMS.m[0] * A + LAB_TO_LMS.m[1] * B) ** 3;
-	const s = (L + LAB_TO_LMS.s[0] * A + LAB_TO_LMS.s[1] * B) ** 3;
-	const r = 255 * lrgb2rgb(LSM_TO_RGB.r[0] * l + LSM_TO_RGB.r[1] * m + LSM_TO_RGB.r[2] * s);
-	const g = 255 * lrgb2rgb(LSM_TO_RGB.g[0] * l + LSM_TO_RGB.g[1] * m + LSM_TO_RGB.g[2] * s);
-	const b = 255 * lrgb2rgb(LSM_TO_RGB.b[0] * l + LSM_TO_RGB.b[1] * m + LSM_TO_RGB.b[2] * s);
-	return addAlpha({
-		r: clamp$1(round$1(r, precision), 0, 255),
-		g: clamp$1(round$1(g, precision), 0, 255),
-		b: clamp$1(round$1(b, precision), 0, 255)
-	}, alpha);
-}
-function oklab2hex(input) {
-	const value = parseInput(input, "oklab");
-	const alpha = extractAlpha(input);
-	const hex = rgb2hex(oklab2rgb(value));
-	return alpha !== void 0 && alpha < 1 ? addAlphaToHex(hex, alpha) : hex;
-}
-function oklab2hsl(input) {
-	const value = parseInput(input, "oklab");
-	const alpha = extractAlpha(input);
-	return addAlpha(rgb2hsl(oklab2rgb(value)), alpha);
-}
-var { sin, cos } = Math;
-function oklch2oklab(input, precision) {
-	let { l, c, h } = parseInput(input, "oklch");
-	const alpha = extractAlpha(input);
-	if (Number.isNaN(h) || h < 0) h = 0;
-	return addAlpha(restrictValues({
-		l,
-		a: c * cos(h * DEG2RAD),
-		b: c * sin(h * DEG2RAD)
-	}, precision), alpha);
-}
-function oklch2rgb(input, precision = 0) {
-	const value = parseInput(input, "oklch");
-	const alpha = extractAlpha(input);
-	return addAlpha(oklab2rgb(oklch2oklab(value), precision), alpha);
-}
-function oklch2hex(input) {
-	const value = parseInput(input, "oklch");
-	const alpha = extractAlpha(input);
-	const hex = rgb2hex(oklch2rgb(value));
-	return alpha !== void 0 && alpha < 1 ? addAlphaToHex(hex, alpha) : hex;
-}
-function oklch2hsl(input) {
-	const value = parseInput(input, "oklch");
-	const alpha = extractAlpha(input);
-	return addAlpha(rgb2hsl(oklch2rgb(value)), alpha);
-}
-var MODEL = "(rgb|hsl|oklab|oklch)a?";
-var SEP = "(?:\\s*[,/]\\s*|\\s+)";
-var VALUE = "(none|[\\d%.-]+(?:deg|grad|rad|turn)?)";
-var colorRegex = new RegExp(`${MODEL}\\s*\\(\\s*${VALUE}${SEP}${VALUE}${SEP}${VALUE}(?:${SEP}${VALUE})?\\s*\\)`, "i");
-function parseAngle(value) {
-	const number_ = parseFloat(value);
-	let result;
-	if (value.endsWith("grad")) result = number_ * .9;
-	else if (value.endsWith("rad")) result = number_ * (180 / Math.PI);
-	else if (value.endsWith("turn")) result = number_ * 360;
-	else result = number_;
-	return Math.round(result * 1e5) / 1e5;
-}
-function extractColorParts(input) {
-	invariant(isString(input), MESSAGES.inputString);
-	if (isHex(input)) {
-		const keys2 = COLOR_KEYS.rgb;
-		const { r, g, b } = hex2rgb(input);
-		const alpha2 = extractAlphaFromHex(input);
-		return {
-			model: "rgb",
-			[keys2[0]]: r,
-			[keys2[1]]: g,
-			[keys2[2]]: b,
-			alpha: alpha2 < 1 ? alpha2 : void 0
-		};
-	}
-	const matches = colorRegex.exec(input);
-	invariant(hasValidMatches(matches), MESSAGES.invalidCSS);
-	const model = matches[1];
-	const keys = COLOR_KEYS[model];
-	let alpha = matches[5] ? parseFloat(matches[5]) : 1;
-	if (alpha > 1) alpha /= 100;
-	const parseValue = (value, index) => {
-		if (value === "none") return 0;
-		if (model === "hsl" && index === 0 || model === "oklch" && index === 2) return parseAngle(value);
-		const parsedValue = parseFloat(value);
-		if (!value.includes("%")) return parsedValue;
-		if (model === "oklch") {
-			if (index === 1) return parsedValue * .4 / 100;
-		} else if (model === "oklab") {
-			if (index === 1 || index === 2) return parsedValue * .4 / 100;
-		}
-		return parsedValue;
-	};
-	const values = [
-		parseValue(matches[2], 0),
-		parseValue(matches[3], 1),
-		parseValue(matches[4], 2)
-	];
-	if (model === "oklab") {
-		invariant(values[1] >= -.4 && values[1] <= .4, MESSAGES.invalidRange);
-		invariant(values[2] >= -.4 && values[2] <= .4, MESSAGES.invalidRange);
-	} else if (model === "oklch") invariant(values[1] >= 0 && values[1] <= .4, MESSAGES.invalidRange);
-	return {
-		model,
-		[keys[0]]: values[0],
-		[keys[1]]: values[1],
-		[keys[2]]: values[2],
-		alpha: alpha < 1 ? alpha : void 0
-	};
-}
-var toHslConverters = {
-	oklab: oklab2hsl,
-	oklch: oklch2hsl,
-	rgb: rgb2hsl
-};
-var toOklabConverters = {
-	hsl: hsl2oklab,
-	oklch: oklch2oklab,
-	rgb: rgb2oklab
-};
-var toOklchConverters = {
-	hsl: hsl2oklch,
-	oklab: oklab2oklch,
-	rgb: rgb2oklch
-};
-var toRgbConverters = {
-	hsl: hsl2rgb,
-	oklab: oklab2rgb,
-	oklch: oklch2rgb
-};
-var toHexConverters = {
-	hsl: hsl2hex,
-	oklab: oklab2hex,
-	oklch: oklch2hex,
-	rgb: rgb2hex
-};
-var fromHexConverters = {
-	hsl: hex2hsl,
-	oklab: hex2oklab,
-	oklch: hex2oklch,
-	rgb: hex2rgb
-};
-var converterTables = {
-	hsl: toHslConverters,
-	oklab: toOklabConverters,
-	oklch: toOklchConverters,
-	rgb: toRgbConverters
-};
-function convertFromCSS(value, output) {
-	const { alpha, model, ...color } = extractColorParts(value);
-	if (["oklab", "oklch"].includes(model) && color.l > 1) color.l = round$1(color.l / 100, PRECISION);
-	const colorTuple = Object.values(color);
-	if (output === "hex") {
-		const alphaPrefix = alpha ? convertAlphaToHex(alpha) : "";
-		return `${toHexConverters[model](colorTuple)}${alphaPrefix}`;
-	}
-	const converter = converterTables[output]?.[model];
-	return addAlpha(converter ? converter(colorTuple) : color, alpha);
-}
-function convertFromHex(value, output) {
-	const alpha = extractAlphaFromHex(value);
-	if (output === "hex") return `${removeAlphaFromHex(value)}${alpha !== 1 ? convertAlphaToHex(alpha) : ""}`;
-	return addAlpha(fromHexConverters[output](value), alpha);
-}
-function parseCSS(input, format) {
-	invariant(isString(input), MESSAGES.inputString);
-	const value = isNamedColor(input) ? cssColors[input.toLowerCase()] : input;
-	const output = format ?? (isHex(value) ? "hex" : extractColorParts(value).model);
-	if (isHex(value)) return convertFromHex(value, output);
-	return convertFromCSS(value, output);
-}
-var mainTRC = 2.4;
-var normBG = .56;
-var normTXT = .57;
-var revBG = .65;
-var revTXT = .62;
-var sRco = .2126729;
-var sGco = .7151522;
-var sBco = .072175;
-var blkThreshold = .022;
-var blkClamp = 1.414;
-var scaleBoW = 1.14;
-var scaleWoB = 1.14;
-var loBoWOffset = .027;
-var loWoBOffset = .027;
-var loClip = .1;
-var deltaYmin = 5e-4;
-function softClamp(Y) {
-	return Y > blkThreshold ? Y : Y + (blkThreshold - Y) ** blkClamp;
-}
-function sRGBtoY(r, g, b) {
-	return sRco * (r / 255) ** mainTRC + sGco * (g / 255) ** mainTRC + sBco * (b / 255) ** mainTRC;
-}
-function apcaContrast(background, foreground) {
-	invariant(isString(background), MESSAGES.inputString);
-	invariant(isString(foreground), MESSAGES.inputString);
-	const bg = hex2rgb(parseCSS(background, "hex"));
-	const fg = hex2rgb(parseCSS(foreground, "hex"));
-	const txtY = softClamp(sRGBtoY(fg.r, fg.g, fg.b));
-	const bgY = softClamp(sRGBtoY(bg.r, bg.g, bg.b));
-	if (Math.abs(bgY - txtY) < deltaYmin) return 0;
-	const SAPC = bgY > txtY ? (bgY ** normBG - txtY ** normTXT) * scaleBoW : (bgY ** revBG - txtY ** revTXT) * scaleWoB;
-	if (Math.abs(SAPC) < loClip) return 0;
-	return round$1(SAPC > 0 ? (SAPC - loBoWOffset) * 100 : (SAPC + loWoBOffset) * 100, 5);
-}
-function brightnessDifference(left, right, precision = PRECISION) {
-	invariant(isString(left), MESSAGES.left);
-	invariant(isString(right), MESSAGES.right);
-	const RGBLeft = parseCSS(left, "rgb");
-	const RGBRight = parseCSS(right, "rgb");
-	const brightnessLeft = (RGBLeft.r * 299 + RGBLeft.g * 587 + RGBLeft.b * 114) / 1e3;
-	const brightnessRight = (RGBRight.r * 299 + RGBRight.g * 587 + RGBRight.b * 114) / 1e3;
-	return round$1(Math.abs(brightnessRight - brightnessLeft), precision);
-}
-function chroma(input) {
-	invariant(isString(input), MESSAGES.inputString);
-	const { r, g, b } = parseCSS(input, "rgb");
-	return round$1((Math.max(r, g, b) - Math.min(r, g, b)) / 255, 4);
-}
-function colorDifference(left, right) {
-	invariant(isString(left), MESSAGES.left);
-	invariant(isString(right), MESSAGES.right);
-	const RGBLeft = parseCSS(left, "rgb");
-	const RGBRight = parseCSS(right, "rgb");
-	return Math.max(RGBLeft.r, RGBRight.r) - Math.min(RGBLeft.r, RGBRight.r) + (Math.max(RGBLeft.g, RGBRight.g) - Math.min(RGBLeft.g, RGBRight.g)) + (Math.max(RGBLeft.b, RGBRight.b) - Math.min(RGBLeft.b, RGBRight.b));
-}
-function luminance(input) {
-	invariant(isString(input), MESSAGES.inputString);
-	const { r, g, b } = parseCSS(input, "rgb");
-	const rgb = [
-		r / 255,
-		g / 255,
-		b / 255
-	];
-	for (let index = 0; index < rgb.length; index++) if (rgb[index] <= .04045) rgb[index] /= 12.92;
-	else rgb[index] = ((rgb[index] + .055) / 1.055) ** 2.4;
-	return round$1(.2126 * rgb[0] + .7152 * rgb[1] + .0722 * rgb[2], 4);
-}
-function contrast(left, right) {
-	invariant(isString(left), MESSAGES.left);
-	invariant(isString(right), MESSAGES.right);
-	const LuminanceLeft = luminance(left);
-	const LuminanceRight = luminance(right);
-	return round$1(LuminanceLeft >= LuminanceRight ? (LuminanceLeft + .05) / (LuminanceRight + .05) : (LuminanceRight + .05) / (LuminanceLeft + .05));
-}
-function compare(left, right) {
-	invariant(isString(left), MESSAGES.left);
-	invariant(isString(right), MESSAGES.right);
-	const colorThreshold = 500;
-	const brightnessThreshold = 125;
-	const colorDifference2 = colorDifference(left, right);
-	const contrast2 = contrast(left, right);
-	const brightnessDifference2 = brightnessDifference(left, right);
-	const isBright = brightnessDifference2 >= brightnessThreshold;
-	const hasEnoughDifference = colorDifference2 >= colorThreshold;
-	let compliant = 0;
-	if (isBright && hasEnoughDifference) compliant = 2;
-	else if (isBright || hasEnoughDifference) compliant = 1;
-	return {
-		brightnessDifference: brightnessDifference2,
-		colorDifference: colorDifference2,
-		compliant,
-		contrast: contrast2,
-		largeAA: contrast2 >= 3,
-		largeAAA: contrast2 >= 4.5,
-		normalAA: contrast2 >= 4.5,
-		normalAAA: contrast2 >= 7
-	};
-}
-function getColorModel(input) {
-	if (isHex(input) || isNamedColor(input)) return "hex";
-	if (isHSL(input)) return "hsl";
-	if (isLAB(input)) return "oklab";
-	if (isLCH(input)) return "oklch";
-	if (isRGB(input)) return "rgb";
-	throw new Error(MESSAGES.invalid);
-}
-function getColorValue(input, output) {
-	const value = isNamedColor(input) ? cssColors[input.toLowerCase()] : input;
-	const from = getColorModel(value);
-	if (from === output) return value;
-	const converter = converters_exports[`${from}2${output}`];
-	if (!converter) throw new Error(`Converter not found for ${from} to ${output}`);
-	return converter(value);
-}
-function formatCSS(input, options = {}) {
-	invariant(isHex(input) || isValidColorModel(input), MESSAGES.invalid);
-	const { alpha, format = "hex", precision = PRECISION, separator: baseSeparator = " " } = options;
-	const opacity2 = alpha && alpha !== 1 ? `${round$1(alpha * 100)}%` : null;
-	let params = [];
-	let separator = baseSeparator;
-	switch (format) {
-		case "hsl": {
-			const { h, s, l } = getColorValue(input, "hsl");
-			params = [
-				h,
-				`${s}%`,
-				`${l}%`
-			];
-			break;
-		}
-		case "oklab": {
-			separator = " ";
-			const { l, a, b } = restrictValues(getColorValue(input, "oklab"), precision);
-			params = [
-				`${round$1(l * 100, precision)}%`,
-				a,
-				b
-			];
-			break;
-		}
-		case "oklch": {
-			separator = " ";
-			const { l, c, h } = restrictValues(getColorValue(input, "oklch"), precision);
-			params = [
-				`${round$1(l * 100, precision)}%`,
-				c,
-				h
-			];
-			break;
-		}
-		case "rgb": {
-			const { r, g, b } = getColorValue(input, "rgb");
-			params = [
-				r,
-				g,
-				b
-			];
-			break;
-		}
-		default: {
-			const hex = removeAlphaFromHex(getColorValue(input, "hex"));
-			if (alpha && alpha !== 1) return `${hex}${convertAlphaToHex(alpha)}`;
-			return hex;
-		}
-	}
-	return `${format}(${params.join(separator)}${opacity2 ? ` / ${opacity2}` : ""})`;
-}
-function updater(key, operator, format) {
-	return (input, amount) => {
-		invariant(isString(input), MESSAGES.inputString);
-		invariant(isNumberInRange(amount, 0, 100), MESSAGES.amount);
-		const color = parseCSS(input, "hsl");
-		const output = isHex(input) || isNamedColor(input) ? "hex" : extractColorParts(input).model;
-		return formatCSS({
-			...color,
-			[key]: clamp$1(color[key] + (operator === "+" ? amount : -amount), 0, 100)
-		}, { format: format ?? output });
-	};
-}
-function darken(input, amount, format) {
-	return updater("l", "-", format)(input, amount);
-}
-function desaturate(input, amount, format) {
-	return updater("s", "-", format)(input, amount);
-}
-function grayscale(input, format) {
-	invariant(isString(input), MESSAGES.inputString);
-	const output = isHex(input) || isNamedColor(input) ? "hex" : extractColorParts(input).model;
-	const lch = parseCSS(input, "oklch");
-	return formatCSS({
-		...lch,
-		c: 0
-	}, {
-		format: format ?? output,
-		alpha: lch.alpha
-	});
-}
-function rotate(input, degrees, format) {
-	invariant(isString(input), MESSAGES.inputString);
-	invariant(isNumberInRange(degrees, -360, 360), MESSAGES.degreesRange);
-	const color = parseCSS(input, "hsl");
-	const output = isHex(input) || isNamedColor(input) ? "hex" : extractColorParts(input).model;
-	return formatCSS({
-		...color,
-		h: constrainDegrees(color.h, degrees)
-	}, { format: format ?? output });
-}
-function invert(input) {
-	invariant(isString(input), MESSAGES.inputString);
-	const format = isHex(input) || isNamedColor(input) ? "hex" : extractColorParts(input).model;
-	return formatCSS(rotate(parseCSS(input, "hex"), 180), { format });
-}
-function lighten(input, amount, format) {
-	return updater("l", "+", format)(input, amount);
-}
-function interpolateHue(h1, h2, c1, c2, ratio) {
-	if (c1 < 1e-4) return h2;
-	if (c2 < 1e-4) return h1;
-	let diff = h2 - h1;
-	if (diff > 180) diff -= 360;
-	else if (diff < -180) diff += 360;
-	let result = h1 + diff * ratio;
-	if (result < 0) result += 360;
-	else if (result >= 360) result -= 360;
-	return result;
-}
-function mix(color1, color2, ratio = .5, format) {
-	invariant(isString(color1), MESSAGES.inputString);
-	invariant(isString(color2), MESSAGES.inputString);
-	invariant(isNumberInRange(ratio, 0, 1), MESSAGES.ratioRange);
-	const output = isHex(color1) || isNamedColor(color1) ? "hex" : extractColorParts(color1).model;
-	const lch1 = parseCSS(color1, "oklch");
-	const lch2 = parseCSS(color2, "oklch");
-	const l = lch1.l + (lch2.l - lch1.l) * ratio;
-	const c = lch1.c + (lch2.c - lch1.c) * ratio;
-	const h = interpolateHue(lch1.h, lch2.h, lch1.c, lch2.c, ratio);
-	const alpha1 = lch1.alpha ?? 1;
-	const alpha = alpha1 + ((lch2.alpha ?? 1) - alpha1) * ratio;
-	return formatCSS({
-		l,
-		c,
-		h
-	}, {
-		format: format ?? output,
-		alpha: alpha < 1 ? alpha : void 0
-	});
-}
-function parseColor(color) {
-	invariant(!!color, MESSAGES.input);
-	const output = {};
-	if (isString(color)) {
-		const { alpha = 1 } = extractColorParts(color);
-		const type = isHex(color) ? "hex" : extractColorParts(color).model;
-		output.hex = addAlphaToHex(parseCSS(color, "hex"), alpha);
-		output.hsl = addAlpha(parseCSS(color, "hsl"), alpha);
-		output.oklab = addAlpha(parseCSS(color, "oklab"), alpha);
-		output.oklch = addAlpha(parseCSS(color, "oklch"), alpha);
-		output.rgb = addAlpha(parseCSS(color, "rgb"), alpha);
-		output.alpha = alpha;
-		output.type = type;
-	} else if (isPlainObject(color)) {
-		const { alpha = 1 } = color;
-		if (isHSL(color)) {
-			output.hsl = {
-				h: limit(color.h, "hsl", "h"),
-				s: limit(color.s, "hsl", "s"),
-				l: limit(color.l, "hsl", "l")
-			};
-			output.rgb = hsl2rgb(output.hsl);
-			output.oklab = hsl2oklab(output.hsl);
-			output.oklch = hsl2oklch(output.hsl);
-			output.type = "hsl";
-		} else if (isLAB(color)) {
-			output.hsl = oklab2hsl(color);
-			output.oklab = color;
-			output.oklch = oklab2oklch(color);
-			output.rgb = oklab2rgb(color);
-			output.type = "oklab";
-		} else if (isLCH(color)) {
-			output.hsl = oklch2hsl(color);
-			output.oklab = oklch2oklab(color);
-			output.oklch = color;
-			output.rgb = oklch2rgb(color);
-			output.type = "oklch";
-		} else if (isRGB(color)) {
-			output.rgb = {
-				r: limit(color.r, "rgb", "r"),
-				g: limit(color.g, "rgb", "g"),
-				b: limit(color.b, "rgb", "b")
-			};
-			output.hsl = rgb2hsl(output.rgb);
-			output.oklab = rgb2oklab(output.rgb);
-			output.oklch = rgb2oklch(output.rgb);
-			output.type = "rgb";
-		} else throw new Error("invalid color");
-		output.hex = addAlphaToHex(hsl2hex(output.hsl), alpha);
-		output.hsl = addAlpha(output.hsl, alpha);
-		output.oklab = addAlpha(output.oklab, alpha);
-		output.oklch = addAlpha(output.oklch, alpha);
-		output.rgb = addAlpha(output.rgb, alpha);
-		output.alpha = alpha;
-	} else throw new Error(MESSAGES.input);
-	return output;
-}
-function opacify(input, alpha, format) {
-	invariant(isString(input), MESSAGES.inputString);
-	invariant(isNumberInRange(alpha, 0, 1), MESSAGES.alpha);
-	const type = isHex(input) || isNamedColor(input) ? "hex" : extractColorParts(input).model;
-	return formatCSS(parseCSS(input, "rgb"), {
-		format: format ?? type,
-		alpha
-	});
-}
-function opacity(input) {
-	invariant(isString(input), MESSAGES.inputString);
-	if (isHex(input)) return extractAlphaFromHex(input);
-	else if (Object.keys(cssColors).includes(input)) return 1;
-	const { alpha } = extractColorParts(input);
-	if (!alpha) return 1;
-	return alpha;
-}
-function pickByContrast(darkContrast, lightContrast, darkColor, lightColor) {
-	return darkContrast >= lightContrast ? darkColor : lightColor;
-}
-function readableColor(backgroundColor, options = {}) {
-	const { darkColor = "#000000", lightColor = "#ffffff", method = "yiq", threshold } = options;
-	invariant(isString(backgroundColor), MESSAGES.inputString);
-	switch (method) {
-		case "yiq": {
-			const yiqThreshold = threshold ?? 128;
-			invariant(yiqThreshold >= 0 && yiqThreshold <= 255, MESSAGES.threshold);
-			const { r, g, b } = hex2rgb(parseCSS(backgroundColor, "hex"));
-			return (r * 299 + g * 587 + b * 114) / 1e3 >= yiqThreshold ? darkColor : lightColor;
-		}
-		case "wcag": {
-			const wcagThreshold = threshold ?? .5;
-			invariant(wcagThreshold >= 0 && wcagThreshold <= 1, MESSAGES.thresholdNormalized);
-			return luminance(backgroundColor) >= wcagThreshold ? darkColor : lightColor;
-		}
-		case "contrast": return pickByContrast(contrast(darkColor, backgroundColor), contrast(lightColor, backgroundColor), darkColor, lightColor);
-		case "oklab": {
-			const oklabThreshold = threshold ?? .5;
-			invariant(oklabThreshold >= 0 && oklabThreshold <= 1, MESSAGES.thresholdNormalized);
-			const { l } = hex2oklab(parseCSS(backgroundColor, "hex"));
-			return l >= oklabThreshold ? darkColor : lightColor;
-		}
-		case "apca": return pickByContrast(Math.abs(apcaContrast(backgroundColor, darkColor)), Math.abs(apcaContrast(backgroundColor, lightColor)), darkColor, lightColor);
-		default: throw new Error(`Unknown method: ${method}`);
-	}
-}
-function saturate(input, amount, format) {
-	return updater("s", "+", format)(input, amount);
-}
-function transparentize(input, alpha, format) {
-	invariant(isString(input), MESSAGES.inputString);
-	invariant(isNumberInRange(alpha, -1, 1), MESSAGES.alphaAdjustment);
-	return formatCSS(parseCSS(input, "oklab"), {
-		format,
-		alpha: round$1(clamp$1(opacity(input) - alpha, 0, 1))
-	});
-}
-var Colorizr = class {
-	constructor(color, options = {}) {
-		/** The alpha/opacity value (0-1). */
-		__publicField(this, "alpha");
-		__publicField(this, "hex");
-		__publicField(this, "hsl");
-		__publicField(this, "oklab");
-		__publicField(this, "oklch");
-		__publicField(this, "rgb");
-		__publicField(this, "type");
-		invariant(!!color, MESSAGES.colorRequired);
-		const { alpha, hex, hsl, oklab, oklch, rgb, type } = parseColor(color);
-		this.hex = hex;
-		this.hsl = hsl;
-		this.oklab = oklab;
-		this.oklch = oklch;
-		this.rgb = rgb;
-		this.alpha = alpha;
-		this.type = options.format ?? type;
-	}
-	/**
-	* Get CSS string
-	*/
-	get css() {
-		return this.currentColor;
-	}
-	/**
-	* Get the red value
-	*/
-	get red() {
-		return this.rgb.r;
-	}
-	/**
-	* Get the green value
-	*/
-	get green() {
-		return this.rgb.g;
-	}
-	/**
-	* Get the blue value
-	*/
-	get blue() {
-		return this.rgb.b;
-	}
-	/**
-	* Get the hue value
-	*/
-	get hue() {
-		return this.hsl.h;
-	}
-	/**
-	* Get the saturation value
-	*/
-	get saturation() {
-		return this.hsl.s;
-	}
-	/**
-	* Get the lightness value
-	*/
-	get lightness() {
-		return this.hsl.l;
-	}
-	/**
-	* Get the luminance value
-	*/
-	get luminance() {
-		return luminance(this.currentColor);
-	}
-	/**
-	* Get the chroma value
-	*/
-	get chroma() {
-		return chroma(this.currentColor);
-	}
-	get opacity() {
-		return opacity(this.currentColor);
-	}
-	/**
-	* Get the most readable color (light or dark) for this color as a background.
-	*/
-	get readableColor() {
-		return readableColor(this.currentColor);
-	}
-	get currentColor() {
-		return formatCSS(this[this.type], {
-			format: this.type,
-			alpha: this.alpha
-		});
-	}
-	/**
-	* Get the brightness difference between this color and another.
-	*
-	* @param input - The color to compare against.
-	* @returns The brightness difference value.
-	*/
-	brightnessDifference(input) {
-		return brightnessDifference(this.currentColor, input);
-	}
-	/**
-	* Get the color difference between this color and another.
-	*
-	* @param input - The color to compare against.
-	* @returns The color difference value.
-	*/
-	colorDifference(input) {
-		return colorDifference(this.currentColor, input);
-	}
-	/**
-	* Test 2 colors for WCAG compliance.
-	*
-	* @param input - The color to compare against.
-	* @returns Analysis object with compliance information.
-	*/
-	compare(input) {
-		return compare(this.currentColor, input);
-	}
-	/**
-	* Get the contrast ratio between this color and another.
-	*
-	* @param input - The color to compare against.
-	* @returns The contrast ratio.
-	*/
-	contrast(input) {
-		return contrast(this.currentColor, input);
-	}
-	/**
-	* Format the color to a specific type.
-	*
-	* @param type - The color format to convert to.
-	* @param precision - The decimal precision for the output.
-	* @returns The formatted color string.
-	*/
-	format(type, precision) {
-		return formatCSS(this.rgb, {
-			alpha: this.alpha,
-			format: type,
-			precision
-		});
-	}
-	/**
-	* Increase lightness.
-	*
-	* @param amount - A number between 0 and 100.
-	* @returns The lightened color string.
-	*/
-	lighten(amount) {
-		return lighten(this.currentColor, amount);
-	}
-	/**
-	* Decrease lightness.
-	*
-	* @param amount - A number between 0 and 100.
-	* @returns The darkened color string.
-	*/
-	darken(amount) {
-		return darken(this.currentColor, amount);
-	}
-	/**
-	* Increase saturation.
-	*
-	* @param amount - A number between 0 and 100.
-	* @returns The saturated color string.
-	*/
-	saturate(amount) {
-		return saturate(this.currentColor, amount);
-	}
-	/**
-	* Decrease saturation.
-	*
-	* @param amount - A number between 0 and 100.
-	* @returns The desaturated color string.
-	*/
-	desaturate(amount) {
-		return desaturate(this.currentColor, amount);
-	}
-	/**
-	* Convert to grayscale.
-	*
-	* @returns The grayscale color string.
-	*/
-	grayscale() {
-		return grayscale(this.currentColor);
-	}
-	/**
-	* Invert color.
-	*
-	* @returns The inverted color string.
-	*/
-	invert() {
-		return invert(this.currentColor);
-	}
-	/**
-	* Mix with another color.
-	*
-	* @param color - The color to mix with.
-	* @param ratio - A number between 0 and 1 (0 = this color, 1 = input color).
-	* @returns The mixed color string.
-	*/
-	mix(color, ratio) {
-		return mix(this.currentColor, color, ratio);
-	}
-	/**
-	* Add opacity to the color.
-	*
-	* @param alpha - A number between 0 and 1.
-	* @returns The opacified color string.
-	*/
-	opacify(alpha = .9) {
-		return opacify(this.currentColor, alpha, this.type);
-	}
-	/**
-	* Rotate color hue.
-	*
-	* @param degrees - A number between -360 and 360.
-	* @returns The rotated color string.
-	*/
-	rotate(degrees) {
-		return rotate(this.currentColor, degrees);
-	}
-	/**
-	* Make the color more transparent.
-	*
-	* @param alpha - A number between -1 and 1.
-	* @returns The transparentized color string.
-	*/
-	transparentize(alpha = .1) {
-		return transparentize(this.currentColor, alpha, this.type);
-	}
-};
-function convert$1(input, format) {
-	return formatCSS(parseCSS(input, format), { format });
-}
-/* v8 ignore next 3  -- @preserve */
-function isHsl(v) {
-	if (typeof v !== `object`) return false;
-	if (!(`h` in v)) return false;
-	if (!(`s` in v)) return false;
-	if (!(`l` in v)) return false;
-	if (!(`unit` in v)) return false;
-	if (!(`space` in v)) return false;
-	if (v.space !== `hsl`) return false;
-	return true;
-}
-function isRgb(v) {
-	if (typeof v !== `object`) return false;
-	if (!(`r` in v)) return false;
-	if (!(`g` in v)) return false;
-	if (!(`b` in v)) return false;
-	if (!(`space` in v)) return false;
-	if (!(`unit` in v)) return false;
-	if (v.space === `srgb`) return true;
-	return false;
-}
-/**
-* If the input object has r,g&b properties, it will return a fully-
-* formed Rgb type with `unit` and `space` properties.
-*
-* If it lacks these basic three properties or they are out of range,
-*  _undefined_ is returned.
-*
-* If RGB values are less than 1 assumes unit:scalar. Otherwise unit:8bit.
-* If RGB values exceed 255, _undefined_ returned.
-* @param v
-* @returns
-*/
-function tryParseObjectToRgb(v) {
-	if (typeof v !== `object`) throw new TypeError(`Param 'v' is expected to be an object, got: ${typeof v}`);
-	if (!(`r` in v && `g` in v && `b` in v)) return;
-	if (!(`unit` in v)) if (v.r <= 1 && v.g <= 1 && v.b <= 1) v.unit = `scalar`;
-	else if (v.r > 255 && v.g <= 255 && v.b <= 255) return;
-	else v.unit = `8bit`;
-	if (!(`space` in v)) v.space = `srgb`;
-	return v;
-}
-function tryParseObjectToHsl(v) {
-	if (!(`h` in v && `s` in v && `l` in v)) return;
-	if (!(`unit` in v)) if (v.s <= 1 && v.l <= 1) v.unit = `scalar`;
-	else if (v.s > 100 || v.l > 100) return;
-	else v.unit = `absolute`;
-	if (!(`space` in v)) v.space = `hsl`;
-	return v;
-}
-function isOkLch(v) {
-	if (typeof v !== `object`) return false;
-	if (!(`l` in v)) return false;
-	if (!(`c` in v)) return false;
-	if (!(`h` in v)) return false;
-	if (!(`unit` in v)) return false;
-	if (!(`space` in v)) return false;
-	if (v.space === `lch`) return true;
-	if (v.space === `oklch`) return true;
-	return false;
-}
-function isColourish(v) {
-	if (typeof v === `string`) return true;
-	if (typeof v !== `object`) return false;
-	if (isHsl(v)) return true;
-	if (isOkLch(v)) return true;
-	if (isRgb(v)) return true;
-	return false;
-}
-function calculateHueDistance(a, b, limit = 1) {
-	let long = -1;
-	let short = -1;
-	if (b < a) {
-		long = b - a;
-		short = limit - (a - b);
-	} else {
-		long = b - a;
-		short = long - limit;
-	}
-	const forward = short > 0 ? short : long;
-	const backward = short > 0 ? long : short;
-	if (Math.abs(long) < Math.abs(short)) {
-		const t = short;
-		short = long;
-		long = t;
-	}
-	return {
-		long,
-		short,
-		forward,
-		backward
-	};
-}
-function libraryRgbToHexString(rgb) {
-	const componentToHex = (c) => {
-		const hex = Math.floor(c).toString(16);
-		return hex.length === 1 ? `0${hex}` : hex;
-	};
-	let part = `#${componentToHex(rgb.r)}${componentToHex(rgb.g)}${componentToHex(rgb.b)}`;
-	if (typeof rgb.alpha !== `undefined` && rgb.alpha !== 255) part += componentToHex(rgb.alpha);
-	return part;
-}
-function wrapScalarHue(value) {
-	value = value % 1;
-	if (value < 0) return (1 - Math.abs(value)) % 1;
-	return value;
-}
-var hsl_exports = /* @__PURE__ */ __exportAll({
-	absolute: () => absolute$1,
-	changeLightness: () => changeLightness$1,
-	fromCss: () => fromCss$3,
-	fromHexString: () => fromHexString$3,
-	generateScalar: () => generateScalar$1,
-	guard: () => guard$4,
-	interpolator: () => interpolator$3,
-	parseCssHslFunction: () => parseCssHslFunction,
-	scalar: () => scalar$3,
-	toAbsolute: () => toAbsolute$1,
-	toCssString: () => toCssString$2,
-	toHexString: () => toHexString$3,
-	toLibraryRgb: () => toLibraryRgb,
-	toScalar: () => toScalar$3,
-	withOpacity: () => withOpacity$3
-});
-/**
-* Scales the opacity value of an input HSL value
-* ```js
-* withOpacity()
-* ```
-* @param value Colour
-* @param fn Function that calcules opacity based on input scalar value
-*/
-function withOpacity$3(value, fn) {
-	switch (value.unit) {
-		case `absolute`: return {
-			...value,
-			opacity: fn((value.opacity ?? 100) / 100, value) * 100
-		};
-		case `scalar`: return {
-			...value,
-			opacity: fn(value.opacity ?? 1, value)
-		};
-	}
-}
-/**
-* Increases or decreases lightness by this percentage, returning new colour
-*
-* Amount to change:
-* 'fixed': a fixed amount
-* 'delta': increase/decrease by this amount
-* 'pdelta': proportion of current value to change by ('percentage delta')
-*
-* ```
-* const colour = { h: 0.5, s: 0.5, l: 0.5, space: `hsl`, unit: `scalar` };
-* changeLightness(colour, { pdelta: 0.1 }); // l: 0.55
-* changeLightness(colour, { delta: 0.1 });  // l: 0.6
-* changeLightness(colour, { fixed: 0.5 });  // l: 0.5
-* ```
-*
-* Keep in mind the numerical value will depend on the unit of `value`. If it's scalar,
-* lightness is 0..1 scale, otherwise 0..100 scale.
-*
-* Use negative values to decrease (does not apply to 'fixed')
-* @param value Hsl colour
-* @param amount Amount to change
-*/
-function changeLightness$1(value, amount) {
-	let newL = 0;
-	if (typeof amount.pdelta !== `undefined`) newL = value.l + value.l * amount.pdelta;
-	else if (typeof amount.delta !== `undefined`) newL = amount.delta + value.l;
-	else if (typeof amount.fixed !== `undefined`) {
-		if (amount.fixed < 0) throw new TypeError(`Cannot use negative value with 'fixed'`);
-		newL = amount.fixed;
-	} else throw new TypeError(`Parameter 'amount' is missing 'delta/pdelta/fixed' properties`);
-	return {
-		...value,
-		l: scaleProperty(value, newL, `l`)
-	};
-}
-function scaleProperty(hsl, value, property) {
-	if (hsl.unit === `scalar`) {
-		if (value > 1) value = 1;
-		else if (value < 0) value = 0;
-	} else if (value > 100) value = 100;
-	else if (value < 0) value = 0;
-	return value;
-}
-const hslTransparent = Object.freeze({
-	h: 0,
-	s: 0,
-	l: 0,
-	opacity: 0,
-	unit: `absolute`,
-	space: `hsl`
-});
-function fromHexString$3(hexString, options = {}) {
-	return fromLibrary$2(hex2hsl(hexString), options);
-}
-function fromCss$3(value, options = {}) {
-	value = value.toLowerCase();
-	if (value.startsWith(`hsla(`)) throw new Error(`hsla() not supported`);
-	if (value.startsWith(`rgba(`)) throw new Error(`rgba() not supported`);
-	if (value.startsWith(`#`)) return fromHexString$3(value, options);
-	if (value.startsWith(`--`)) try {
-		value = resolveCss(value);
-	} catch (error) {
-		if (typeof options.fallbackString !== `undefined`) value = options.fallbackString;
-		if (typeof options.fallbackColour !== `undefined`) return options.fallbackColour;
-		throw error;
-	}
-	if (value === `transparent`) return hslTransparent;
-	if (typeof cssDefinedHexColours[value] !== `undefined`) return fromHexString$3(cssDefinedHexColours[value], options);
-	if (value.startsWith(`rgb(`)) return fromLibrary$2(toLibraryHsl(value), options);
-	if (!value.startsWith(`hsl(`)) try {
-		value = convert$1(value, `hsl`);
-	} catch (error) {
-		if (options.fallbackString) value = options.fallbackString;
-		else throw error;
-	}
-	try {
-		const hsl = parseCssHslFunction(value);
-		if (options.scalar) return toScalar$3(hsl);
-		return toAbsolute$1(hsl);
-	} catch (error) {
-		if (options.fallbackColour) return options.fallbackColour;
-		throw error;
-	}
-}
-function toCssString$2(hsl) {
-	const abs = toAbsolute$1(hsl);
-	let css = `hsl(${abs.h}deg ${abs.s}% ${abs.l}%`;
-	if (`opacity` in abs && abs.opacity !== void 0 && abs.opacity < 100) css += ` / ${abs.opacity}%`;
-	css += `)`;
-	return css;
-}
-function toHexString$3(hsl) {
-	return libraryRgbToHexString(toLibraryRgb(hsl));
-}
-function fromLibrary$2(hsl, parsingOptions = {}) {
-	if (typeof hsl === `undefined` || hsl === null) {
-		if (parsingOptions.fallbackColour) return parsingOptions.fallbackColour;
-	}
-	const scalarOpt = parsingOptions.scalar ?? true;
-	resultThrow(numberInclusiveRangeTest(hsl.h, 0, 360, `h`), numberInclusiveRangeTest(hsl.s, 0, 100, `s`), numberInclusiveRangeTest(hsl.l, 0, 100, `l`), percentTest(hsl.alpha ?? 1, `alpha`));
-	if (scalarOpt) return scalar$3(hsl.h / 360, hsl.s / 100, hsl.l / 100, hsl.alpha ?? 1);
-	else return absolute$1(hsl.h, hsl.s, hsl.l, (hsl.alpha ?? 1) * 100);
-}
-function toAbsolute$1(hslOrString) {
-	if (typeof hslOrString === `string`) return fromCss$3(hslOrString, { scalar: false });
-	if (isRgb(hslOrString)) return toAbsolute$1(fromLibrary$2(toLibraryHsl(hslOrString), { scalar: false }));
-	const hsl = hslOrString;
-	guard$4(hsl);
-	if (hsl.unit === `absolute`) return hsl;
-	return {
-		h: hsl.h * 360,
-		s: hsl.s * 100,
-		l: hsl.l * 100,
-		opacity: (hsl.opacity ?? 1) * 100,
-		unit: `absolute`,
-		space: `hsl`
-	};
-}
-/**
-* Generates a {@link HslScalar} value.
-*
-* ```js
-* generateScaler(10); // 10deg, default to full saturation, half lightness and full opacity
-*
-* // Generate HSL value from radian angle and 50% saturation
-* generateScalar(`10rad`, 0.5);
-*
-* // Generate from numeric CSS variable
-* generateScalar(`--hue`);
-* ```
-* @param absoluteHslOrVariable Hue angle or CSS variable
-* @param saturation
-* @param lightness
-* @param opacity
-*/
-function generateScalar$1(absoluteHslOrVariable, saturation = 1, lightness = .5, opacity = 1) {
-	if (typeof absoluteHslOrVariable === `string`) {
-		if (absoluteHslOrVariable.startsWith(`--`)) absoluteHslOrVariable = getComputedStyle(document.body).getPropertyValue(absoluteHslOrVariable).trim();
-	}
-	const hue = angleParse(absoluteHslOrVariable);
-	if (saturation > 1) throw new TypeError(`Param 'saturation' must be between 0..1`);
-	if (lightness > 1) throw new TypeError(`Param 'lightness' must be between 0..1`);
-	if (opacity > 1) throw new TypeError(`Param 'opacity' must be between 0..1`);
-	return {
-		h: angleConvert(hue, `deg`).value / 360,
-		s: saturation,
-		l: lightness,
-		opacity,
-		unit: `scalar`,
-		space: `hsl`
-	};
-}
-/**
-* Converts a {@link Hsl} value to scalar units, or parses a colour string
-* and converts it.
-*
-* ```js
-* toScalar({ h: 100, s: 50, l: 100, unit: `absolute` });
-* toScalar(`red`);
-* ```
-* @param colour
-*/
-function toScalar$3(colour) {
-	if (typeof colour === `string`) return fromCss$3(colour, { scalar: true });
-	if (isRgb(colour)) return toScalar$3(fromLibrary$2(toLibraryHsl(colour), { scalar: true }));
-	const hsl = colour;
-	guard$4(hsl);
-	if (hsl.unit === `scalar`) return hsl;
-	return {
-		h: hsl.h / 360,
-		s: hsl.s / 100,
-		l: hsl.l / 100,
-		opacity: (hsl.opacity ?? 1) / 100,
-		unit: `scalar`,
-		space: `hsl`
-	};
-}
-function guard$4(hsl) {
-	const { h, s, l, opacity, space, unit } = hsl;
-	if (space !== `hsl`) throw new Error(`Space is expected to be 'hsl'. Got: ${space}`);
-	if (unit === `absolute`) resultThrow(numberTest(h, `finite`, `h`), numberInclusiveRangeTest(s, 0, 100, `s`), numberInclusiveRangeTest(l, 0, 100, `l`), () => {
-		if (typeof opacity === `number`) return numberInclusiveRangeTest(opacity, 0, 100, `opacity`);
-	});
-	else if (unit === `scalar`) resultThrow(numberTest(h, `percentage`, `h`), numberTest(s, `percentage`, `s`), numberTest(l, `percentage`, `l`), () => {
-		if (typeof opacity === `number`) return numberTest(opacity, `percentage`, `opacity`);
-	});
-	else throw new Error(`Unit is expected to be 'absolute' or 'scalar'. Got: ${unit}`);
-}
-function interpolator$3(a, b, direction = `shorter`) {
-	a = toScalar$3(a);
-	b = toScalar$3(b);
-	const aOpacity = a.opacity ?? 1;
-	const distanceCalc = calculateHueDistance(a.h, b.h, 1);
-	const hueDistance = direction === `longer` ? distanceCalc.long : distanceCalc.short;
-	const satDistance = b.s - a.s;
-	const lightDistance = b.l - a.l;
-	const opacityDistance = (b.opacity ?? 1) - aOpacity;
-	return (amount) => {
-		amount = clamp(amount);
-		let h = interpolate(amount, 0, Math.abs(hueDistance));
-		if (hueDistance < 0) h = a.h - h;
-		else h = a.h + h;
-		const s = interpolate(amount, 0, satDistance);
-		const l = interpolate(amount, 0, lightDistance);
-		const o = interpolate(amount, 0, opacityDistance);
-		return scalar$3(wrapScalarHue(h), s + a.s, l + a.l, o + aOpacity);
-	};
-}
-/**
-* Creates a HslScalar value from scalar (0..1) values
-* @param hue
-* @param sat
-* @param lightness
-* @param opacity
-*/
-function scalar$3(hue = .5, sat = 1, lightness = .5, opacity = 1) {
-	const hsl = {
-		unit: `scalar`,
-		space: `hsl`,
-		h: hue,
-		s: sat,
-		l: lightness,
-		opacity
-	};
-	guard$4(hsl);
-	return hsl;
-}
-function absolute$1(hue = 200, sat = 100, lightness = 50, opacity = 100) {
-	const hsl = {
-		unit: `absolute`,
-		space: `hsl`,
-		h: hue,
-		s: sat,
-		l: lightness,
-		opacity
-	};
-	guard$4(hsl);
-	return hsl;
-}
-/**
-* It seems Colorizr can't handle 'deg' units
-* @param value
-*/
-function parseCssHslFunction(value) {
-	if (value.startsWith(`hsla`)) throw new Error(`hsla() is not supported`);
-	if (!value.startsWith(`hsl(`)) throw new Error(`Expected hsl(..) CSS colour`);
-	const start = value.indexOf(`(`);
-	const end = value.indexOf(`)`);
-	if (end < start) throw new Error(`Is hsl() not terminated? Missing ')'`);
-	let split = value.substring(start + 1, end).split(/[\s,]+/);
-	if (split.length < 3) throw new Error(`Expected three tokens. Got: ${split.length} length`);
-	let returnRelative = false;
-	if (split[0].endsWith(`%`)) returnRelative = true;
-	if (split[1].endsWith(`%`) && split[2].endsWith(`%`)) returnRelative = true;
-	const valueAsScalar = (v, pos) => {
-		if (v === `none`) return 0;
-		if (v.endsWith(`%`)) return Number.parseFloat(v.substring(0, v.length - 1)) / 100;
-		if (v.endsWith(`deg`) && pos === 0) v = v.substring(0, v.length - 3);
-		const vf = Number.parseFloat(v);
-		if (pos === 0) return vf / 360;
-		if (pos === 3) return vf;
-		return vf / 100;
-	};
-	const valueAsAbs = (v, pos) => {
-		if (v === `none`) return 0;
-		if (v.endsWith(`%`)) {
-			const vf = Number.parseFloat(v.substring(0, v.length - 1));
-			if (pos === 0) return vf * 360;
-			return vf;
-		}
-		if (v.endsWith(`deg`) && pos === 0) return Number.parseFloat(v.substring(0, v.length - 3));
-		return Number.parseFloat(v);
-	};
-	if (split.length > 3) {
-		if (split[3] === `/`) split = [
-			split[0],
-			split[1],
-			split[2],
-			split[4]
-		];
-	}
-	if (returnRelative) return scalar$3(valueAsScalar(split[0], 0), valueAsScalar(split[1], 1), valueAsScalar(split[2], 2), valueAsScalar(split[3] ?? `100%`, 3));
-	else return absolute$1(valueAsAbs(split[0], 0), valueAsAbs(split[1], 1), valueAsAbs(split[2], 2), valueAsAbs(split[3] ?? `100%`, 3));
-}
-/**
-* Converts a Hsl structure (or CSS string) to Colorizr's RGB format
-* @param hsl HSL colour
-*/
-function toLibraryRgb(hsl) {
-	if (typeof hsl === `string`) return toLibraryRgb(fromCss$3(hsl, { scalar: false }));
-	hsl = toAbsolute$1(hsl);
-	return {
-		...hsl2rgb({
-			h: hsl.h,
-			s: hsl.s,
-			l: hsl.l
-		}),
-		alpha: (hsl.opacity ?? 100) / 100 * 255
-	};
-}
-var srgb_exports = /* @__PURE__ */ __exportAll({
-	changeLightness: () => changeLightness,
-	eightBit: () => eightBit$1,
-	fromCss: () => fromCss$2,
-	fromHexString: () => fromHexString$2,
-	guard: () => guard$3,
-	interpolator: () => interpolator$2,
-	lightness: () => lightness,
-	parseCssRgbFunction: () => parseCssRgbFunction,
-	scalar: () => scalar$2,
-	to8bit: () => to8bit$1,
-	toCssString: () => toCssString$1,
-	toHexString: () => toHexString$2,
-	toLibraryHsl: () => toLibraryHsl,
-	toScalar: () => toScalar$2,
-	withOpacity: () => withOpacity$2
-});
-function withOpacity$2(value, fn) {
-	switch (value.unit) {
-		case `8bit`: return {
-			...value,
-			opacity: fn((value.opacity ?? 255) / 255, value) * 255
-		};
-		case `scalar`: return {
-			...value,
-			opacity: fn(value.opacity ?? 1, value)
-		};
-	}
-}
-function fromHexString$2(hexString, scalar = true) {
-	return fromLibrary$1(hex2rgb(hexString), { scalar });
-}
-const srgbTansparent = Object.freeze({
-	r: 0,
-	g: 0,
-	b: 0,
-	opacity: 0,
-	unit: `8bit`,
-	space: `srgb`
-});
-/**
-* Converts a colour in a legal CSS form into Rgb value, by default RgbScalar (0..1) scale.
-* ```js
-* fromCss(`rebeccapurple`);
-* fromCss(`rgb(40% 20% 60%)`);
-*
-* // Get 8bit version on 0..255 scale
-* fromCss(`blue`, { scalar: false });
-* ```
-*
-* @param value
-* @param options
-*/
-function fromCss$2(value, options = {}) {
-	value = value.toLowerCase();
-	if (value.startsWith(`hsla(`)) throw new Error(`hsla() not supported`);
-	if (value.startsWith(`rgba(`)) throw new Error(`rgba() not supported`);
-	const scalar = options.scalar ?? true;
-	if (value.startsWith(`#`)) return fromHexString$2(value, scalar);
-	if (value === `transparent`) return srgbTansparent;
-	if (typeof cssDefinedHexColours[value] !== `undefined`) return fromHexString$2(cssDefinedHexColours[value], scalar);
-	if (value.startsWith(`hsl(`)) return fromLibrary$1(toLibraryRgb(value), options);
-	if (!value.startsWith(`rgb(`)) try {
-		value = convert$1(value, `rgb`);
-	} catch (error) {
-		if (options.fallbackString) value = options.fallbackString;
-		else throw error;
-	}
-	try {
-		const rgb = parseCssRgbFunction(value);
-		if (scalar) return toScalar$2(rgb);
-		return to8bit$1(rgb);
-	} catch (error) {
-		if (options.fallbackColour) return options.fallbackColour;
-		throw error;
-	}
-}
-function toHexString$2(rgb) {
-	return libraryRgbToHexString(toLibrary$1(rgb));
-}
-function toCssString$1(rgb) {
-	guard$3(rgb);
-	switch (rgb.unit) {
-		case `8bit`:
-			if (rgb.opacity === void 0 || rgb.opacity === 255) return `rgb(${rgb.r} ${rgb.g} ${rgb.b})`;
-			return `rgb(${rgb.r} ${rgb.g} ${rgb.b} / ${(rgb.opacity ?? 255) / 255})`;
-		case `scalar`:
-			if (rgb.opacity === void 0 || rgb.opacity === 1) return `rgb(${rgb.r * 100}% ${rgb.g * 100}% ${rgb.b * 100}%)`;
-			return `rgb(${rgb.r * 100}% ${rgb.g * 100}% ${rgb.b * 100}% / ${(rgb.opacity ?? 1) * 100}%)`;
-		default: throw new Error(`Unknown unit: ${rgb.unit}`);
-	}
-}
-function toLibrary$1(rgb) {
-	const abs = to8bit$1(rgb);
-	return {
-		r: abs.r,
-		g: abs.g,
-		b: abs.b,
-		alpha: abs.opacity
-	};
-}
-function fromLibrary$1(rgb, parsingOptions = {}) {
-	if (parsingOptions.scalar) return {
-		r: rgb.r / 255,
-		g: rgb.g / 255,
-		b: rgb.b / 255,
-		opacity: rgb.alpha ?? 1,
-		unit: `scalar`,
-		space: `srgb`
-	};
-	else return {
-		r: rgb.r,
-		g: rgb.g,
-		b: rgb.b,
-		opacity: rgb.alpha ?? 255,
-		unit: `8bit`,
-		space: `srgb`
-	};
-}
-function to8bit$1(rgbOrString) {
-	if (typeof rgbOrString === `string`) return fromCss$2(rgbOrString, { scalar: false });
-	if (isHsl(rgbOrString)) return to8bit$1(fromLibrary$1(toLibraryRgb(rgbOrString), { scalar: false }));
-	guard$3(rgbOrString);
-	if (rgbOrString.unit === `8bit`) return rgbOrString;
-	return {
-		r: rgbOrString.r * 255,
-		g: rgbOrString.g * 255,
-		b: rgbOrString.b * 255,
-		opacity: (rgbOrString.opacity ?? 1) * 255,
-		unit: `8bit`,
-		space: `srgb`
-	};
-}
-function toScalar$2(rgbOrString) {
-	if (typeof rgbOrString === `string`) return fromCss$2(rgbOrString, { scalar: true });
-	if (isHsl(rgbOrString)) return toScalar$2(fromLibrary$1(toLibraryRgb(rgbOrString), { scalar: true }));
-	guard$3(rgbOrString);
-	if (rgbOrString.unit === `scalar`) return rgbOrString;
-	return {
-		r: rgbOrString.r / 255,
-		g: rgbOrString.g / 255,
-		b: rgbOrString.b / 255,
-		opacity: (rgbOrString.opacity ?? 1) / 255,
-		unit: `scalar`,
-		space: `srgb`
-	};
-}
-function guard$3(rgb) {
-	const { r, g, b, opacity, space, unit } = rgb;
-	if (space !== `srgb`) throw new Error(`Space is expected to be 'srgb'. Got: ${space}`);
-	if (unit === `8bit`) resultThrow(numberInclusiveRangeTest(r, 0, 255, `r`), numberInclusiveRangeTest(g, 0, 255, `g`), numberInclusiveRangeTest(b, 0, 255, `b`), () => {
-		if (typeof opacity === `number`) return numberInclusiveRangeTest(opacity, 0, 255, `opacity`);
-	});
-	else if (unit === `scalar`) resultThrow(numberTest(r, `percentage`, `r`), numberTest(g, `percentage`, `g`), numberTest(b, `percentage`, `b`), () => {
-		if (typeof opacity === `number`) return numberTest(opacity, `percentage`, `opacity`);
-	});
-	else throw new Error(`Unit is expected to be '8bit' or 'scalar'. Got: ${unit}`);
-}
-/**
-* Sets the lightness value.
-*
-* Amount to change:
-* 'fixed': a fixed amount
-* 'delta': increase/decrease by this amount
-* 'pdelta': proportion of current value to change by ('percentage delta')
-*
-* Use negative values to decrease
-* @param rgb Colour
-* @param amount Amount to change
-*/
-function changeLightness(rgb, amount) {
-	let newL = 0;
-	const co = new Colorizr(toCssString$1(rgb));
-	const scalarUnit = rgb.unit === `scalar`;
-	if (typeof amount.pdelta !== `undefined`) newL = co.oklab.l + co.oklab.l * amount.pdelta;
-	else if (typeof amount.delta !== `undefined`) newL = co.oklab.l + amount.delta;
-	else if (typeof amount.fixed !== `undefined`) {
-		if (amount.fixed < 0) throw new TypeError(`Amount cannot be negative when using 'fixed'`);
-		newL = amount.fixed;
-	} else throw new TypeError(`Parameter 'amount' is missing 'pdelta/delta/fixed' properties`);
-	if (newL < 0) newL = 0;
-	else if (newL > 1) newL = 1;
-	return fromLibrary$1(oklab2rgb({
-		a: co.oklab.a,
-		b: co.oklab.b,
-		l: newL,
-		alpha: co.oklab.alpha
-	}), { scalar: scalarUnit });
-}
-/**
-* Returns a lightness value (0..1) for an RGB input
-*
-* Calculates lightness by converting to Oklab and using the 'L' value
-* @param rgb
-*/
-function lightness(rgb) {
-	return new Colorizr(toCssString$1(rgb)).oklab.l;
-}
-/**
-* Creates a Rgb8Bit value from 8bit (0..255) values
-* @param red
-* @param green
-* @param blue
-* @param opacity
-*/
-function eightBit$1(red = 100, green = 100, blue = 100, opacity = 255) {
-	const rgb = {
-		unit: `8bit`,
-		space: `srgb`,
-		r: red,
-		g: green,
-		b: blue,
-		opacity
-	};
-	guard$3(rgb);
-	return rgb;
-}
-/**
-* Creates a RgbScalar value from scalar (0..1) values
-* @param red
-* @param green
-* @param blue
-* @param opacity
-*/
-function scalar$2(red = .5, green = .5, blue = .5, opacity = 1) {
-	const rgb = {
-		unit: `scalar`,
-		space: `srgb`,
-		r: red,
-		g: green,
-		b: blue,
-		opacity
-	};
-	guard$3(rgb);
-	return rgb;
-}
-/**
-* It seems Colorizr can't handle % values properly :'(
-* @param value
-*/
-function parseCssRgbFunction(value) {
-	if (value.startsWith(`rgba`)) throw new Error(`RGBA is not supported`);
-	if (!value.startsWith(`rgb(`)) throw new Error(`Expected rgb(..) CSS colour`);
-	const start = value.indexOf(`(`);
-	const end = value.indexOf(`)`);
-	if (end < start) throw new Error(`Is rgb() not terminated? Missing ')'`);
-	let split = value.substring(start + 1, end).split(/[\s,]+/);
-	if (split.length < 3) throw new Error(`Expected three tokens. Got: ${split.length} length`);
-	let relativeCount = 0;
-	for (const s of split) if (s.endsWith(`%`)) relativeCount++;
-	const valueAsScalar = (v, pos) => {
-		if (v.endsWith(`%`)) return Number.parseFloat(v.substring(0, v.length - 1)) / 100;
-		if (pos < 3) return Number.parseFloat(v) / 255;
-		else return Number.parseFloat(v);
-	};
-	const valueAs8bit = (v, pos) => {
-		if (v.endsWith(`%`)) return Number.parseFloat(v.substring(0, v.length - 1)) / 100 * 255;
-		if (pos < 3) return Number.parseFloat(v);
-		else return Number.parseFloat(v) * 255;
-	};
-	if (split.length > 3) {
-		if (split[3] === `/`) split = [
-			split[0],
-			split[1],
-			split[2],
-			split[4]
-		];
-	}
-	if (relativeCount > 1) return scalar$2(valueAsScalar(split[0], 0), valueAsScalar(split[1], 1), valueAsScalar(split[2], 2), valueAsScalar(split[3] ?? `1`, 3));
-	else return eightBit$1(valueAs8bit(split[0], 0), valueAs8bit(split[1], 1), valueAs8bit(split[2], 2), valueAs8bit(split[3] ?? `1`, 3));
-}
-/**
-* Interpolates colours in Srgb space. Probably
-* really ugly, use OkLch space isntead.
-*
-* ```js
-* const i = interpolator(`red`, `blue`);
-* i(0.5); // Get 50% between these colours
-* ```
-* @param colourA
-* @param colourB
-*/
-function interpolator$2(colourA, colourB) {
-	const aa = toScalar$2(colourA);
-	const bb = toScalar$2(colourB);
-	const aOpacity = aa.opacity ?? 1;
-	const opacityDistance = (bb.opacity ?? 1) - aOpacity;
-	const r = bb.r - aa.r;
-	const g = bb.g - aa.g;
-	const b = bb.b - aa.b;
-	return (amount) => {
-		amount = clamp(amount);
-		return scalar$2(aa.r + interpolate(amount, 0, r), aa.g + interpolate(amount, 0, g), aa.b + interpolate(amount, 0, b), aOpacity + interpolate(amount, 0, opacityDistance));
-	};
-}
-/**
-* Converts a Rgb structure (or CSS string) to Colorizr's HSL format
-* @param rgb
-*/
-function toLibraryHsl(rgb) {
-	if (typeof rgb === `string`) return toLibraryHsl(fromCss$2(rgb, { scalar: false }));
-	rgb = to8bit$1(rgb);
-	return {
-		...rgb2hsl({
-			r: rgb.r,
-			g: rgb.g,
-			b: rgb.b
-		}),
-		alpha: (rgb.opacity ?? 255) / 255
-	};
-}
-var oklch_exports = /* @__PURE__ */ __exportAll({
-	OKLCH_CHROMA_MAX: () => OKLCH_CHROMA_MAX,
-	absolute: () => absolute,
-	fromCss: () => fromCss$1,
-	fromHexString: () => fromHexString$1,
-	fromLibrary: () => fromLibrary,
-	generateScalar: () => generateScalar,
-	guard: () => guard$2,
-	interpolator: () => interpolator$1,
-	scalar: () => scalar$1,
-	toAbsolute: () => toAbsolute,
-	toCssString: () => toCssString,
-	toHexString: () => toHexString$1,
-	toScalar: () => toScalar$1,
-	withOpacity: () => withOpacity$1
-});
-const OKLCH_CHROMA_MAX = .4;
-function guard$2(lch) {
-	const { l, c, h, opacity, space, unit } = lch;
-	if (space !== `oklch`) throw new Error(`Space is expected to be 'oklch'. Got: ${space}`);
-	if (unit === `absolute`) resultThrow(percentTest(l, `l`), () => {
-		if (typeof c === `number`) return numberInclusiveRangeTest(c, 0, OKLCH_CHROMA_MAX, `c`);
-	}, () => {
-		if (typeof h === `number`) return numberInclusiveRangeTest(h, 0, 360, `h`);
-	}, percentTest(opacity ?? 1, `opacity`));
-	else if (unit === `scalar`) resultThrow(percentTest(l, `l`), percentTest(c, `c`), percentTest(h, `h`), percentTest(lch.opacity ?? 1, `opacity`));
-	else throw new Error(`Unit is expected to be 'absolute' or 'scalar'. Got: ${unit}`);
-}
-function fromLibrary(lch, parsingOptions = {}) {
-	if (typeof lch === `undefined` || lch === null) {
-		if (parsingOptions.fallbackColour) return parsingOptions.fallbackColour;
-	}
-	const scalarReturn = parsingOptions.scalar ?? true;
-	resultThrow(percentTest(lch.l, `l`), percentTest(lch.c, `c`), numberInclusiveRangeTest(lch.h, 0, 360, `h`), percentTest(lch.alpha ?? 1, `alpha`));
-	if (scalarReturn) return scalar$1(lch.l, lch.c / OKLCH_CHROMA_MAX, lch.h / 360, lch.alpha ?? 1);
-	else return absolute(lch.l, lch.c, lch.h, lch.alpha ?? 1);
-}
-/**
-* Parse a HEX-formatted colour into OkLch structured format
-* @param hexString
-* @param options
-*/
-function fromHexString$1(hexString, options = {}) {
-	return fromLibrary(hex2oklch(hexString), options);
-}
-const oklchTransparent = Object.freeze({
-	l: 0,
-	c: 0,
-	h: 0,
-	opacity: 0,
-	unit: `absolute`,
-	space: `oklch`
-});
-function fromCss$1(value, options = {}) {
-	value = value.toLowerCase();
-	if (value.startsWith(`#`)) return fromHexString$1(value, options);
-	if (value === `transparent`) return oklchTransparent;
-	if (typeof cssDefinedHexColours[value] !== `undefined`) return fromHexString$1(cssDefinedHexColours[value], options);
-	if (value.startsWith(`rgb(`)) {
-		const rgb = to8bit$1(parseCssRgbFunction(value));
-		return fromLibrary(rgb2oklch({
-			r: rgb.r,
-			g: rgb.g,
-			b: rgb.b
-		}), options);
-	}
-	if (!value.startsWith(`hsl(`) && !value.startsWith(`oklch(`)) try {
-		value = convert$1(value, `oklch`);
-	} catch (error) {
-		if (options.fallbackString) value = options.fallbackString;
-		else throw error;
-	}
-	const lch = new Colorizr(value).oklch;
-	return fromLibrary(lch, options);
-}
-/**
-* Returns a string or {@link OkLch} value to absolute form.
-*
-* This means ranges are:
-* lightness: 0..1
-* chroma: 0...CHROMA_MAX (0.4)
-* hue: 0..360
-* @param lchOrString
-*/
-function toAbsolute(lchOrString) {
-	if (typeof lchOrString === `string`) return toAbsolute(fromCss$1(lchOrString, { scalar: true }));
-	guard$2(lchOrString);
-	if (lchOrString.unit === `absolute`) return lchOrString;
-	return {
-		space: `oklch`,
-		unit: `absolute`,
-		l: lchOrString.l,
-		c: lchOrString.c * OKLCH_CHROMA_MAX,
-		h: lchOrString.h * 360,
-		opacity: lchOrString.opacity
-	};
-}
-function toScalar$1(lchOrString) {
-	if (typeof lchOrString === `string`) return toScalar$1(fromCss$1(lchOrString, { scalar: true }));
-	const lch = lchOrString;
-	guard$2(lch);
-	if (lch.unit === `scalar`) return lch;
-	return {
-		l: lch.l,
-		c: lch.c / OKLCH_CHROMA_MAX,
-		h: lch.h / 360,
-		opacity: lch.opacity ?? 1,
-		unit: `scalar`,
-		space: `oklch`
-	};
-}
-function toLibrary(lch) {
-	const abs = toAbsolute(lch);
-	return {
-		l: abs.l,
-		c: abs.c,
-		h: abs.h,
-		alpha: abs.opacity
-	};
-}
-/**
-* Returns the colour as a CSS colour string: `oklch(l c h / opacity)`.
-*
-* @param lch Colour
-* @param precision Set precision of numbers, defaults to 3
-* @returns CSS colour string
-*/
-function toCssString(lch, precision = 3) {
-	guard$2(lch);
-	const { l, c, h, opacity } = lch;
-	let css = ``;
-	switch (lch.unit) {
-		case `absolute`:
-			css = `oklch(${(l * 100).toFixed(precision)}% ${c.toFixed(precision)} ${h.toFixed(precision)}`;
-			break;
-		case `scalar`:
-			css = `oklch(${l.toFixed(precision)} ${(c * OKLCH_CHROMA_MAX).toFixed(precision)} ${(h * 360).toFixed(precision)}`;
-			break;
-	}
-	if (typeof opacity !== `undefined` && opacity !== 1) css += ` / ${opacity.toFixed(precision)}`;
-	css += `)`;
-	return css;
-}
-function toHexString$1(lch) {
-	return libraryRgbToHexString(oklch2rgb(toLibrary(lch)));
-}
-function generateScalar(absoluteHslOrVariable, chroma = 1, lightness = .5, opacity = 1) {
-	if (typeof absoluteHslOrVariable === `string`) {
-		if (absoluteHslOrVariable.startsWith(`--`)) absoluteHslOrVariable = getComputedStyle(document.body).getPropertyValue(absoluteHslOrVariable).trim();
-	}
-	if (lightness > 1) throw new TypeError(`Param 'lightness' must be between 0..1`);
-	if (chroma > 1) throw new TypeError(`Param 'chroma' must be between 0..1`);
-	const hueDeg = angleConvert(angleParse(absoluteHslOrVariable), `deg`).value / 360;
-	if (opacity > 1) throw new TypeError(`Param 'opacity' must be between 0..1`);
-	return {
-		l: lightness,
-		c: chroma,
-		h: hueDeg,
-		opacity,
-		unit: `scalar`,
-		space: `oklch`
-	};
-}
-/**
-* Scales the opacity value of an input Oklch value
-* ```js
-* withOpacity()
-* ```
-* @param value
-* @param fn
-*/
-function withOpacity$1(value, fn) {
-	switch (value.unit) {
-		case `absolute`: return {
-			...value,
-			opacity: fn((value.opacity ?? 100) / 100, value) * 100
-		};
-		case `scalar`: return {
-			...value,
-			opacity: fn(value.opacity ?? 1, value)
-		};
-	}
-}
-function interpolator$1(a, b, direction = `shorter`) {
-	a = toScalar$1(a);
-	b = toScalar$1(b);
-	const aOpacity = a.opacity ?? 1;
-	const distanceCalc = calculateHueDistance(a.h, b.h, 1);
-	const hueDistance = direction === `longer` ? distanceCalc.long : distanceCalc.short;
-	const chromaDistance = b.c - a.c;
-	const lightDistance = b.l - a.l;
-	const opacityDistance = (b.opacity ?? 1) - aOpacity;
-	return (amount) => {
-		amount = clamp(amount);
-		let h = interpolate(amount, 0, Math.abs(hueDistance));
-		if (hueDistance < 0) h = a.h - h;
-		else h = a.h + h;
-		const c = interpolate(amount, 0, chromaDistance);
-		const l = interpolate(amount, 0, lightDistance);
-		const o = interpolate(amount, 0, opacityDistance);
-		return scalar$1(l + a.l, c + a.c, wrapScalarHue(h), o + aOpacity);
-	};
-}
-function scalar$1(lightness = .7, chroma = .1, hue = .5, opacity = 1) {
-	const lch = {
-		unit: `scalar`,
-		space: `oklch`,
-		l: lightness,
-		c: chroma,
-		h: hue,
-		opacity
-	};
-	guard$2(lch);
-	return lch;
-}
-/**
-* Create an LCH colour using absolute hue
-* @param l Lightness 0..1
-* @param c Chroma 0..4
-* @param h Hue 0..360
-* @param opacity
-*/
-function absolute(l, c, h, opacity = 1) {
-	const lch = {
-		space: `oklch`,
-		unit: `absolute`,
-		opacity,
-		l,
-		c,
-		h
-	};
-	guard$2(lch);
-	return lch;
-}
-/**
-* Converts from some kind of colour that is legal in CSS
-* into a structured Colour type.
-* 
-* Handles: hex format, CSS variables, colour names
-* ```js
-* fromCssColour(`#ffffff`);
-* fromCssColour(`blue`);
-* fromCssColour(`--some-variable`);
-* fromCssColour(`hsl(50, 50%, 50%)`);
-* fromCssColour(`rgb(50, 100, 100)`);
-* ```
-* @param colour 
-* @returns 
-*/
-const fromCssColour = (colour) => {
-	if (colour.startsWith(`#`)) return fromHexString$2(colour, true);
-	if (colour.startsWith(`--`)) {
-		const fromCss = getComputedStyle(document.body).getPropertyValue(colour).trim();
-		if (fromCss.length === 0 || fromCss === null) throw new Error(`Variable missing: ${colour}`);
-		return fromCssColour(fromCss);
-	}
-	const colourLower = colour.toLowerCase();
-	if (typeof cssDefinedHexColours[colourLower] !== `undefined`) return fromHexString$2(cssDefinedHexColours[colourLower], true);
-	if (colourLower.startsWith(`hsl(`)) return fromCss$3(colour, { scalar: true });
-	if (colourLower.startsWith(`rgb(`)) return fromCss$2(colour, { scalar: true });
-	if (colourLower.startsWith(`oklch(`)) return fromCss$1(colour, { scalar: true });
-	throw new Error(`String colour is not a hex colour, CSS variable nor well-defined colour. Input: '${colour}'`);
-};
-/**
-* Resolves a named colour or CSS variable to a colour string.
-* Doesn't do conversion or parsing.
-* 
-* ```js
-* resolveCss(`red`);
-* resolveCss(`my-var`);
-* ```
-* @param colour Colour
-* @param fallback Fallback if CSS variable is missing
-* @returns 
-*/
-function resolveCss(colour, fallback) {
-	if (colour.startsWith(`--`)) {
-		const fromCss = getComputedStyle(document.body).getPropertyValue(colour).trim();
-		if (fromCss.length === 0 || fromCss === null) {
-			if (typeof fallback !== `undefined`) return fallback;
-			throw new Error(`CSS variable missing: '${colour}'`);
-		}
-		return resolveCss(fromCss);
-	}
-	if (typeof cssDefinedHexColours[colour] !== `undefined`) return cssDefinedHexColours[colour];
-	return colour;
-}
-const cssDefinedHexColours = Object.freeze({
-	"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",
-	"darkkhaki": "#bdb76b",
-	"darkmagenta": "#8b008b",
-	"darkolivegreen": "#556b2f",
-	"darkorange": "#ff8c00",
-	"darkorchid": "#9932cc",
-	"darkred": "#8b0000",
-	"darksalmon": "#e9967a",
-	"darkseagreen": "#8fbc8f",
-	"darkslateblue": "#483d8b",
-	"darkslategray": "#2f4f4f",
-	"darkturquoise": "#00ced1",
-	"darkviolet": "#9400d3",
-	"deeppink": "#ff1493",
-	"deepskyblue": "#00bfff",
-	"dimgray": "#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",
-	"honeydew": "#f0fff0",
-	"hotpink": "#ff69b4",
-	"indianred": "#cd5c5c",
-	"indigo": "#4b0082",
-	"ivory": "#fffff0",
-	"khaki": "#f0e68c",
-	"lavender": "#e6e6fa",
-	"lavenderblush": "#fff0f5",
-	"lawngreen": "#7cfc00",
-	"lemonchiffon": "#fffacd",
-	"lightblue": "#add8e6",
-	"lightcoral": "#f08080",
-	"lightcyan": "#e0ffff",
-	"lightgoldenrodyellow": "#fafad2",
-	"lightgray": "#d3d3d3",
-	"lightgreen": "#90ee90",
-	"lightpink": "#ffb6c1",
-	"lightsalmon": "#ffa07a",
-	"lightseagreen": "#20b2aa",
-	"lightskyblue": "#87cefa",
-	"lightslategray": "#778899",
-	"lightsteelblue": "#b0c4de",
-	"lightyellow": "#ffffe0",
-	"lime": "#00ff00",
-	"limegreen": "#32cd32",
-	"linen": "#faf0e6",
-	"magenta": "#ff00ff",
-	"maroon": "#800000",
-	"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",
-	"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",
-	"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",
-	"transparent": "#00000000"
-});
-/**
-* Converts an object or string representation of colour to ixfx's
-* structured colour.
-* Use {@link convertToString} if you want a CSS colour string instead.
-* @param colour
-* @param destination
-*/
-function convert(colour, destination) {
-	if (destination === `hsl-scalar`) {
-		if (typeof colour === `string` || isHsl(colour) || isRgb(colour)) return toScalar$3(colour);
-	} else if (destination === `hsl-absolute`) {
-		if (typeof colour === `string` || isHsl(colour)) return toAbsolute$1(colour);
-	} else if (destination === `oklch-scalar`) {
-		if (typeof colour === `string` || isOkLch(colour)) return toScalar$1(colour);
-	} else if (destination === `oklch-absolute`) {
-		if (typeof colour === `string` || isOkLch(colour)) return toAbsolute(colour);
-	} else if (destination === `srgb-8bit`) {
-		if (typeof colour === `string` || isRgb(colour)) return to8bit$1(colour);
-	} else if (destination === `srgb-scalar`) {
-		if (typeof colour === `string` || isRgb(colour)) return toScalar$2(colour);
-	} else throw new Error(`Destination '${destination}' not supported for input: ${JSON.stringify(colour)}`);
-	return convert(toCssColour(colour), destination);
-}
-/**
-* Like {@link convert}, but result is a CSS colour string
-* @param colour
-* @param destination
-*/
-function convertToString(colour, destination) {
-	return toCssColour(convert(colour, destination));
-}
-/**
-* Converts some kind of colour into a scalar representation. Supports oklch, hsl and srgb.
-* @param colour Colour to convert
-* @param destination Destination colour format
-*/
-function convertScalar(colour, destination) {
-	if (destination === `oklch`) return convert(colour, `oklch-scalar`);
-	if (destination === `srgb`) return convert(colour, `srgb-scalar`);
-	if (destination === `hsl`) return convert(colour, `hsl-scalar`);
-	throw new Error(`Unknown destination: '${destination}'`);
-}
-function toCssColour(colour) {
-	if (typeof colour === `string`) return colour;
-	if (isHsl(colour)) return toCssString$2(colour);
-	if (isRgb(colour)) return toCssString$1(colour);
-	if (isOkLch(colour)) return toCssString(colour);
-	const asRgb = tryParseObjectToRgb(colour);
-	if (asRgb) return toCssString$1(asRgb);
-	const asHsl = tryParseObjectToHsl(colour);
-	if (asHsl) return toCssString$2(asHsl);
-	throw new Error(`Unknown colour format: '${JSON.stringify(colour)}'`);
-}
-function toHexColour(colour) {
-	if (isHsl(colour)) return toHexString$3(colour);
-	if (isRgb(colour)) return toHexString$2(colour);
-	if (isOkLch(colour)) return toHexString$1(colour);
-	if (typeof colour === `string`) {
-		if (colour.startsWith(`#`)) return colour;
-		return toHexString$2(convert(colour, `srgb-8bit`));
-	}
-	const asRgb = tryParseObjectToRgb(colour);
-	if (asRgb) return toHexString$2(asRgb);
-	const asHsl = tryParseObjectToHsl(colour);
-	if (asHsl) return toHexString$3(asHsl);
-	throw new Error(`Unknown colour format: '${JSON.stringify(colour)}'`);
-}
-function toLibraryColour(colour) {
-	return new Colorizr(toCssColour(colour));
-}
-function guard$1(colour) {
-	switch (colour.space) {
-		case `hsl`:
-			guard$4(colour);
-			break;
-		case `srgb`:
-			guard$3(colour);
-			break;
-		case `oklch`:
-			guard$2(colour);
-			break;
-		default: throw new Error(`Unsupported colour space: '${colour.space}'`);
-	}
-}
-function toColour(colourish) {
-	if (!isColourish(colourish)) throw new Error(`Could not parse input. Expected CSS colour string or structured colour {r,g,b}, {h,s,l} etc. Got: ${JSON.stringify(colourish)}`);
-	let c;
-	if (typeof colourish === `string`) c = fromCssColour(colourish);
-	else c = colourish;
-	if (c === void 0) throw new Error(`Could not parse input. Expected CSS colour string or structured colour {r,g,b}, {h,s,l} etc.`);
-	guard$1(c);
-	return c;
-}
-/**
-* Returns a CSS-ready string
-* representation.
-* ```js
-* element.style.backgroundColor = resolveToString(`red`);
-* ```
-*
-* Tries each parameter in turn, returning the value
-* for the first that resolves. This can be useful for
-* having fallback values.
-*
-* ```js
-* // Try a CSS variable, a object property or finally fallback to red.
-* element.style.backgroundColor = toStringFirst('--some-var', opts.background, `red`);
-* ```
-* @param colours Array of colours to resolve
-*/
-function toStringFirst(...colours) {
-	for (const colour of colours) {
-		if (colour === void 0) continue;
-		if (colour === null) continue;
-		try {
-			return toCssColour(toColour(colour));
-		} catch {}
-	}
-	return `rebeccapurple`;
-}
-function rgbToHsl(rgb, scalarResult) {
-	let { r, g, b } = rgb;
-	const opacity = rgb.opacity ?? 1;
-	if (rgb.unit === `8bit`) {
-		r /= 255;
-		g /= 255;
-		b /= 255;
-	}
-	const max = Math.max(r, g, b);
-	const min = Math.min(r, g, b);
-	let h = (max + min) / 2;
-	let s = h;
-	const l = h;
-	if (max === min) if (scalarResult) return scalar$3(0, 0, 0, opacity);
-	else return absolute$1(0, 0, 0, opacity);
-	const d = max - min;
-	s = l >= .5 ? d / (2 - (max + min)) : d / (max + min);
-	switch (max) {
-		case r:
-			h = ((g - b) / d + 0) * 60;
-			break;
-		case g:
-			h = ((b - r) / d + 2) * 60;
-			break;
-		case b:
-			h = ((r - g) / d + 4) * 60;
-			break;
-	}
-	if (scalarResult) return scalar$3(h / 360, s, l, opacity);
-	else return absolute$1(h, s * 100, l * 100, opacity);
-}
-/**
-* Returns a full HSL colour string (eg `hsl(20,50%,75%)`) based on a index.
-* It's useful for generating perceptually different shades as the index increments.
-*
-* ```
-* el.style.backgroundColor = goldenAgeColour(10);
-* ```
-*
-* Saturation and lightness can be specified, as numeric ranges of 0-1.
-*
-* @param saturation Saturation (0-1), defaults to 0.5
-* @param lightness Lightness (0-1), defaults to 0.75
-* @param alpha Opacity (0-1), defaults to 1.0
-* @returns HSL colour string eg `hsl(20,50%,75%)`
-*/
-const goldenAngleColour = (index, saturation = .5, lightness = .75, alpha = 1) => {
-	resultThrow(numberTest(index, `positive`, `index`), numberTest(saturation, `percentage`, `saturation`), numberTest(lightness, `percentage`, `lightness`), numberTest(alpha, `percentage`, `alpha`));
-	return toCssString$2(scalar$3(index * 137.508 % 360 / 360, saturation, lightness, alpha));
-};
-/**
-* Returns a random hue component (0..359)
-* 
-* ```
-* // Generate hue
-* const h = randomHue(); // 0-359
-*
-* // Generate hue and assign as part of a HSL string
-* el.style.backgroundColor = `hsl(${randomHue(), 50%, 75%})`;
-* ```
-* @param rand
-* @returns
-*/
-const randomHue = (rand = Math.random) => rand() * 360;
-/**
-* Returns a function to interpolate between colours, with results as a structured {@link Colour} object.
-* ```js
-* const i = interpolator([`orange`, `yellow`, `red`]);
-*
-* // Get a random colour on the above spectrum
-* i(Math.random());
-* ```
-*
-* Results will vary depending on the colour space used, play with the options.
-* When using a hue-based colour space, the `hue` option sets the logic for how hue values wrap.
-*
-* ```js
-* interpolator([`orange`, `yellow`, `red`], { space: `hsl`, hue: `longer })
-* ```
-*
-* Example: Draw the interpolation as a spectrum on a canvas, where each pixel is one step
-* ```js
-* let v = 0;
-* let incrementBy = 0.01;
-* while (v <= 1) {
-*  // Get colour at this interpolation point 0..1
-*  const colour = fn(v);
-*  // Convert to a CSS string
-*  ctx.fillStyle = Colour.toCssColour(colour);
-*  // Draw a 1px wide rect, and shuffle along to the next x position
-*  ctx.fillRect(x, y, 1, h);
-*  x += 1;
-*  v += incrementBy;
-* }
-* ```
-* @param colours Colours to interpolate between
-* @param opts Options for interpolation
-* @returns Function that interpolates based on an amount, returning a structured Colour
-*/
-function interpolator(colours, opts = {}) {
-	const direction = opts.direction ?? `shorter`;
-	const destination = opts.destination ?? `oklch-scalar`;
-	const space = opts.space ?? `oklch`;
-	const ranges = interpolateInit(colours, space);
-	const rangeInterpolators = ranges.map((range) => interpolatorDual(range[0], range[1], {
-		space,
-		direction,
-		destination
-	}));
-	const asTargetDestination = colours.map((c) => convert(c, destination));
-	return (amt) => {
-		if (amt >= 1) return asTargetDestination.at(-1);
-		if (amt <= 0) return asTargetDestination.at(0);
-		const s = scaleClamped(amt, 0, 1, 0, ranges.length);
-		const index = Math.floor(s);
-		const amtAdjusted = s - index;
-		const ri = rangeInterpolators[index];
-		return ri(amtAdjusted);
-	};
-}
-/**
-* Returns a set of pairwise colours, convert to the destination colour space in scalar form
-* @param colours
-* @param destination
-* @returns Array of pairwise colours, converted to destination scalar
-*/
-function interpolateInit(colours, destination = `hsl`) {
-	if (!Array.isArray(colours)) throw new Error(`Param 'colours' is not an array as expected. Got: ${typeof colours}`);
-	if (colours.length < 2) throw new Error(`Param 'colours' should be at least two in length. Got: ${colours.length}`);
-	return [...pairwise(colours.map((colour) => convertScalar(colour, destination)))];
-}
-/**
-* Returns a CSS `linear-gradient` with stops corresponding to the given list of `colours`.
-* ```js
-* element.style.background = Colour.cssLinearGradient(['red','green','blue']);
-* ```
-* @param colours
-* @returns A 'linear-gradient' string for use in CSS, eg for background.
-*/
-function cssLinearGradient(colours) {
-	return `linear-gradient(to right, ${colours.map((c) => toCssColour(c)).join(`, `)})`;
-}
-/**
-* Returns a function that interpolates between two colours. Returns string colour values.
-* If you want the result as a structured colour, use {@link interpolatorDual} instead.
-*
-* By default takes a shorter direction and uses the OkLCH colourspace.
-* ```js
-* const i = interpolator(`blue`, `red`);
-* i(0.5); // Get the colour at 50%, as a string.
-* ```
-*
-* To work with structured colour values, use one of the space's `interpolate` functions.
-*
-* If you want to create discrete steps, consider {@link createSteps} or {@link scale}.
-*
-* @param colourA First colour
-* @param colourB Second colour
-* @param options Interpolation options. By default uses shorter direction and OkLCH colour space.
-*/
-function interpolatorDualToString(colourA, colourB, options = {}) {
-	const f = interpolatorDual(colourA, colourB, options);
-	return (amount) => toCssColour(f(amount));
-}
-/**
-* Returns a function that interpolates between two colours. Returns structured colour values.
-* If you want the result as a ready-to-use CSS string, use {@link interpolatorDualToString} instead.
-*
-* By default takes a shorter direction and uses the OkLCH colourspace.
-* ```js
-* const i = interpolator(`blue`, `red`);
-* i(0.5); // Get the colour at 50%, as a Colour structure.
-* ```
-*
-* If you want to create discrete steps, consider {@link createSteps} or {@link scale}.
-* @param colourA First colour
-* @param colourB Second colour
-* @param options Interpolation options. By default uses shorter direction and OkLCH colour space.
-* @returns Function that interpolates between two colours, returning a structured Colour
-*/
-function interpolatorDual(colourA, colourB, options = {}) {
-	const space = options.space ?? `oklch`;
-	const direction = options.direction ?? `shorter`;
-	const destination = options.destination ?? `oklch-scalar`;
-	let inter;
-	switch (space) {
-		case `hsl`: {
-			const hslInter = interpolator$3(convert(colourA, `hsl-scalar`), convert(colourB, `hsl-scalar`), direction);
-			inter = (amount) => {
-				return convert(hslInter(amount), destination);
-			};
-			break;
-		}
-		case `srgb`: {
-			const srgbInter = interpolator$2(convert(colourA, `srgb-scalar`), convert(colourB, `srgb-scalar`));
-			inter = (amount) => {
-				return convert(srgbInter(amount), destination);
-			};
-			break;
-		}
-		default: {
-			const oklchInter = interpolator$1(convert(colourA, `oklch-scalar`), convert(colourB, `oklch-scalar`), direction);
-			inter = (amount) => {
-				return convert(oklchInter(amount), destination);
-			};
-		}
-	}
-	return (amount) => inter(amount);
-}
-/**
-* Produces a stepped scale of colours.
-*
-* Builds off {@link createSteps} which can only step between two colours.
-*
-* ```js
-* // A scale of from red to green, with three colours in-between
-* const steps = Colour.scale([ `red`, `green` ], { stepsBetween: 3 });
-* for (const step of steps) {
-*  // A CSS colour string
-* }
-* ```
-*
-* {@link cssLinearGradient} can produce a smooth gradient in CSS on the basis
-* of the stepped colours.
-* @param colours
-* @param opts
-* @returns Array of colours in string form
-*/
-function scale(colours, opts = {}) {
-	const direction = opts.direction ?? `shorter`;
-	const space = opts.space ?? `oklch`;
-	const pieces = interpolateInit(colours, space);
-	let stepsBetween = 0;
-	if (typeof opts.stepsBetween === `number`) {
-		stepsBetween = opts.stepsBetween;
-		if (stepsBetween < 1) throw new Error(`Param 'stepsBetween' must be at least 1`);
-	} else if (typeof opts.stepsTotal === `number`) {
-		if (opts.stepsTotal <= colours.length) throw new Error(`Param 'stepsTotal' must be greater than number of provided colour stops (${colours.length}) +1 per stop`);
-		const totalSteps = opts.stepsTotal - colours.length;
-		stepsBetween = Math.floor(totalSteps / pieces.length);
-	}
-	const steps = pieces.map((piece) => {
-		const pieceSteps = createSteps(piece[0], piece[1], {
-			steps: stepsBetween,
-			space,
-			direction,
-			exclusive: true
-		});
-		pieceSteps.push(piece[1]);
-		return pieceSteps;
-	});
-	const firstPiece = pieces[0];
-	steps.unshift([firstPiece[0]]);
-	return steps.flat().map((c) => toCssColour(c));
-}
-function createSteps(a, b, options = {}) {
-	const exclusive = options.exclusive ?? false;
-	const steps = options.steps ?? 5;
-	const space = options.space ?? `oklch`;
-	const direction = options.direction ?? `shorter`;
-	if (!exclusive && steps < 2) throw new Error(`Param 'steps' should be at least 2 when 'exclusive' is false`);
-	if (exclusive && steps < 1) throw new Error(`Param 'steps' should be at least 1 when 'exlusive' is true`);
-	const aa = convertScalar(a, space);
-	const bb = convertScalar(b, space);
-	let inter;
-	switch (space) {
-		case `hsl`:
-			inter = interpolator$3(aa, bb, direction);
-			break;
-		case `oklch`:
-			inter = interpolator$1(aa, bb, direction);
-			break;
-		case `srgb`:
-			inter = interpolator$2(aa, bb);
-			break;
-		default: throw new Error(`Colour space '${space}' not supported for interpolation.`);
-	}
-	if (!inter) throw new Error(`Could not create interpolator for space: ${space}`);
-	let stepBy = 0;
-	let startAt = 0;
-	let endAt = 1;
-	if (exclusive) {
-		stepBy = 1 / (steps + 1);
-		startAt = stepBy;
-		endAt = 1 - stepBy;
-	} else stepBy = 1 / (steps - 1);
-	const results = [];
-	for (let interpolateAmount = startAt; interpolateAmount <= endAt; interpolateAmount += stepBy) results.push(inter(interpolateAmount));
-	return results;
-}
-/**
-* Multiplies the opacity of a colour by `amount`, returning a computed CSS colour.
-*
-* ```js
-* multiplyOpacity(`red`, 0.5); // Returns a colour string
-* ```
-*
-* For example, to half the opacity, use `amount: 0.5`.
-* Clamps the result to ensure it's between 0..1
-* @param colourish Colour
-* @param amount Amount
-*/
-function multiplyOpacity(colourish, amount) {
-	return withOpacity(colourish, (o) => clamp(o * amount));
-}
-/**
-* Does a computation with the opacity of a colour, returning colour.
-*
-* Passes operation to `HslSpace` or `SrgbSpace` depending on space of `colourish`.
-* @param colourish Colour
-* @param fn Function that takes original opacity as input and returns output opacity
-*/
-function withOpacity(colourish, fn) {
-	const colour = toColour(colourish);
-	let result;
-	switch (colour.space) {
-		case `hsl`:
-			result = withOpacity$3(colour, fn);
-			break;
-		case `srgb`:
-			result = withOpacity$2(colour, fn);
-			break;
-		case `oklch`:
-			result = withOpacity$1(colour, fn);
-			break;
-		default: throw new Error(`Unknown space: '${colour.space}'. Expected hsl, srgb, oklch`);
-	}
-	if (!result) throw new Error(`Is colour in correct form?`);
-	if (typeof colourish === `string`) return toCssColour(result);
-	return result;
-}
-function setOpacity(colourish, opacity) {
-	const colour = toColour(colourish);
-	colour.opacity = opacity;
-	if (typeof colourish === `string`) return toCssColour(colour);
-	return colour;
-}
-/**
-* Encode 8-bit RGB values into a 24-bit value (0...16_777_215)
-* 
-* Assumes RGB values are within 0..255 range
-* @param rgb 
-* @returns 
-*/
-function encodeRgbTo24Bit(rgb) {
-	return rgb.r << 16 | rgb.g << 8 | rgb.b;
-}
-/**
-* Decode a 24-bit number (0...16_777_215) into 8-bit RGB
-* @param colour 
-* @returns 
-*/
-function decodeRgbFrom24Bit(colour) {
-	if (colour > 16777215) throw new TypeError(`Param 'colour' is out of range. Expected max value of 16_777_215, got ${colour}`);
-	return {
-		r: colour >> 16 & 255,
-		g: colour >> 8 & 255,
-		b: colour & 255,
-		unit: `8bit`,
-		space: `srgb`
-	};
-}
-/**
-* Encodes 8-bit RGB value into 16-bit RGB565 (0..65_535)
-* 5-bit are used for R & B channels, 6 bits for G
-* 
-* Read more: https://rgbcolorpicker.com/565
-* @param rgb 
-* @returns 
-*/
-function encodeRgbTo16Bit565(rgb) {
-	const r = rgb.r >> 3 & 31;
-	const g = rgb.g >> 2 & 63;
-	const b = rgb.b >> 3 & 31;
-	return r << 11 | g << 5 | b;
-}
-/**
-* Decodes 8-bit RGB value from a 16-bit RGB565 value (0...65_535)
-* Read more: https://rgbcolorpicker.com/565
-* @param colour 
-* @returns 
-*/
-function decodeRgbFrom16Bit565(colour) {
-	if (colour > 65535) throw new TypeError(`Param 'colour' is out of range. Expected max: 65_535. Got: ${colour}`);
-	return {
-		r: (colour >> 11 & 31) << 3,
-		g: (colour >> 5 & 63) << 2,
-		b: (colour & 31) << 3,
-		unit: `8bit`,
-		space: `srgb`
-	};
-}
-var ycbcr_exports = /* @__PURE__ */ __exportAll({
-	eightBit: () => eightBit,
-	fromCss: () => fromCss,
-	fromHexString: () => fromHexString,
-	fromSrgTo8bit: () => fromSrgTo8bit,
-	guard: () => guard,
-	scalar: () => scalar,
-	to8bit: () => to8bit,
-	toHexString: () => toHexString,
-	toScalar: () => toScalar,
-	toSrgb8bit: () => toSrgb8bit
-});
-/**
-* Creates a YCbCr8bit value from 8bit (0..255) values
-* @param y Luma 0..255
-* @param cb Chroma blue 0..255
-* @param cr Chroma red 0..255
-* @param opacity 0..255
-* @returns YCbCr8bit
-*/
-function eightBit(y = 100, cb = 100, cr = 100, opacity = 255) {
-	const rgb = {
-		unit: `8bit`,
-		space: `ycbcr`,
-		y,
-		cb,
-		cr,
-		opacity
-	};
-	guard(rgb);
-	return rgb;
-}
-/**
-* Creates a YCbCr8bit value from scalar (0..1) values
-* @param y Luma 0..1
-* @param cb Chroma blue 0..1
-* @param cr Chroma red 0..1
-* @param opacity 0..1
-* @returns YCbCrScalar
-*/
-function scalar(y = .5, cb = .5, cr = .5, opacity = 1) {
-	const rgb = {
-		unit: `scalar`,
-		space: `ycbcr`,
-		y,
-		cb,
-		cr,
-		opacity
-	};
-	guard(rgb);
-	return rgb;
-}
-/**
-* Converts from scalar or 8bit RGB to YCbCr8bit
-* @param rgb
-* @returns
-*/
-function fromSrgTo8bit(rgb) {
-	const { r, g, b, opacity } = to8bit$1(rgb);
-	return eightBit(.299 * r + .587 * g + .114 * b + 0, -.169 * r + -.331 * g + .5 * b + 128, .5 * r + -.419 * g + -.081 * b + 128, opacity);
-}
-function toSrgb8bit(ycbcr) {
-	const { y, cb, cr, opacity } = to8bit(ycbcr);
-	return {
-		unit: `8bit`,
-		space: `srgb`,
-		r: 1 * y + 0 * (cb - 128) + 1.4 * (cr - 128),
-		g: 1 * y + -.343 * (cb - 128) + -.711 * (cr - 128),
-		b: 1 * y + 1.765 * (cb - 128) + 0 * (cr - 128),
-		opacity
-	};
-}
-/**
-* Returns a YCbCr8bit format from either scalar or 8bit.
-* If the input is already 8bit, it is returned as-is.
-* @param ycbcr 8bit or scalar YCbCr value
-* @returns YCbCr8bit
-*/
-function to8bit(ycbcr) {
-	guard(ycbcr);
-	if (ycbcr.unit === `8bit`) return ycbcr;
-	const { y, cb, cr, opacity } = ycbcr;
-	return eightBit(y * 255, cb * 255, cr * 255, typeof opacity === `number` ? opacity * 255 : 255);
-}
-function fromHexString(hexString, options = {}) {
-	return fromSrgTo8bit(fromHexString$2(hexString, false));
-}
-function fromCss(value, options = {}) {
-	const scalar = options.scalar ?? false;
-	const rgb = fromCss$2(value, {
-		fallbackString: options.fallbackString,
-		scalar: false,
-		ensureSafe: options.ensureSafe
-	});
-	if (scalar) return toScalar(fromSrgTo8bit(rgb));
-	else return fromSrgTo8bit(rgb);
-}
-function toScalar(colour) {
-	if (typeof colour === `string`) return fromCss(colour, { scalar: true });
-	if (isHsl(colour) || isRgb(colour)) return toScalar(fromSrgTo8bit(toScalar$2(colour)));
-	guard(colour);
-	if (colour.unit === `scalar`) return colour;
-	const { y, cb, cr, opacity } = colour;
-	return scalar(y / 255, cb / 255, cr / 255, typeof opacity === `number` ? opacity / 255 : 1);
-}
-function guard(rgb) {
-	const { y, cb, cr, opacity, space, unit } = rgb;
-	if (space !== `ycbcr`) throw new Error(`Space is expected to be 'ycbcr'. Got: ${space}`);
-	if (unit === `8bit`) resultThrow(numberInclusiveRangeTest(y, 0, 255, `y`), numberInclusiveRangeTest(cb, 0, 255, `cb`), numberInclusiveRangeTest(cr, 0, 255, `cr`), () => {
-		if (typeof opacity === `number`) return numberInclusiveRangeTest(opacity, 0, 255, `opacity`);
-	});
-	else if (unit === `scalar`) resultThrow(numberTest(y, `percentage`, `y`), numberTest(cb, `percentage`, `cb`), numberTest(cr, `percentage`, `cr`), () => {
-		if (typeof opacity === `number`) return numberTest(opacity, `percentage`, `opacity`);
-	});
-	else throw new Error(`Unit is expected to be '8bit' or 'scalar'. Got: ${unit}`);
-}
-/**
-* Converts a YCbCr colour to a RGB hex string.
-* @param ycbcr
-* @returns
-*/
-function toHexString(ycbcr) {
-	return toHexString$2(toSrgb8bit(ycbcr));
-}
-var colour_exports = /* @__PURE__ */ __exportAll({
-	HslSpace: () => hsl_exports,
-	OklchSpace: () => oklch_exports,
-	SrgbSpace: () => srgb_exports,
-	YCbCrSpace: () => ycbcr_exports,
-	convert: () => convert,
-	convertScalar: () => convertScalar,
-	convertToString: () => convertToString,
-	createSteps: () => createSteps,
-	cssDefinedHexColours: () => cssDefinedHexColours,
-	cssLinearGradient: () => cssLinearGradient,
-	decodeRgbFrom16Bit565: () => decodeRgbFrom16Bit565,
-	decodeRgbFrom24Bit: () => decodeRgbFrom24Bit,
-	encodeRgbTo16Bit565: () => encodeRgbTo16Bit565,
-	encodeRgbTo24Bit: () => encodeRgbTo24Bit,
-	fromCssColour: () => fromCssColour,
-	goldenAngleColour: () => goldenAngleColour,
-	guard: () => guard$1,
-	interpolator: () => interpolator,
-	interpolatorDual: () => interpolatorDual,
-	interpolatorDualToString: () => interpolatorDualToString,
-	isColourish: () => isColourish,
-	isHsl: () => isHsl,
-	isOkLch: () => isOkLch,
-	isRgb: () => isRgb,
-	multiplyOpacity: () => multiplyOpacity,
-	randomHue: () => randomHue,
-	resolveCss: () => resolveCss,
-	rgbToHsl: () => rgbToHsl,
-	scale: () => scale,
-	setOpacity: () => setOpacity,
-	toColour: () => toColour,
-	toCssColour: () => toCssColour,
-	toHexColour: () => toHexColour,
-	toLibraryColour: () => toLibraryColour,
-	toStringFirst: () => toStringFirst,
-	tryParseObjectToHsl: () => tryParseObjectToHsl,
-	tryParseObjectToRgb: () => tryParseObjectToRgb,
-	withOpacity: () => withOpacity
-});
-//#endregion
-export { radiansNormalise as a, isEmpty as c, isPlaceholder as d, isPoint as f, piPi as i, isNaN as l, pointTest as m, average$1 as n, guard$5 as o, isPoint3d as p, averager as r, guardNonZeroPoint as s, colour_exports as t, isNull as u };
-
-//# sourceMappingURL=colour-C3MQIjFJ-vRCdr8W-.js.map