@ixfx/components 0.2.4 → 0.2.5

package/dist/colour-C3MQIjFJ-BJV-QC-3.js

@@ -0,0 +1,4138 @@
+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-D7kJgnSE.js";
+//#region node_modules/.pnpm/@ixfx+visual@0.56.12/node_modules/@ixfx/visual/dist/chunk-pbuEa-1d.js
+var __defProp$2 = Object.defineProperty;
+var __exportAll$1 = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp$2(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp$2(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.12/node_modules/@ixfx/geometry/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.12/node_modules/@ixfx/geometry/dist/guard-CqkBirEd.js
+/**
+* Returns true if xy (and z, if present) are _null_.
+* @param p
+* @returns
+*/
+const 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.
+*/
+const isNaN = (p) => {
+	if (isPoint3d(p)) {
+		if (!Number.isNaN(p.z)) return false;
+	}
+	return Number.isNaN(p.x) || Number.isNaN(p.y);
+};
+function test(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(test(p, name, info));
+}
+/**
+* Throws if parameter is not a valid point, or either x or y is 0
+* @param pt
+* @returns
+*/
+const 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 
+*/
+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 
+*/
+const 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
+*/
+const 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
+*/
+const 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.12/node_modules/@ixfx/geometry/dist/to-jujzVMAL.js
+function getTwoPointParameters(a1, ab2, ab3, ab4, ab5, ab6) {
+	if (isPoint3d(a1) && isPoint3d(ab2)) return [a1, ab2];
+	if (isPoint(a1) && isPoint(ab2)) return [a1, ab2];
+	if (isPoint3d(a1)) {
+		const b = {
+			x: ab2,
+			y: ab3,
+			z: ab4
+		};
+		if (!isPoint3d(b)) throw new Error(`Expected x, y & z parameters`);
+		return [a1, b];
+	}
+	if (isPoint(a1)) {
+		const b = {
+			x: ab2,
+			y: ab3
+		};
+		if (!isPoint(b)) throw new Error(`Expected x & y parameters`);
+		return [a1, b];
+	}
+	if (typeof ab5 !== `undefined` && typeof ab4 !== `undefined`) {
+		const a = {
+			x: a1,
+			y: ab2,
+			z: ab3
+		};
+		const b = {
+			x: ab4,
+			y: ab5,
+			z: ab6
+		};
+		if (!isPoint3d(a)) throw new Error(`Expected x,y,z for first point`);
+		if (!isPoint3d(b)) throw new Error(`Expected x,y,z for second point`);
+		return [a, b];
+	}
+	const a = {
+		x: a1,
+		y: ab2
+	};
+	const b = {
+		x: ab3,
+		y: ab4
+	};
+	if (!isPoint(a)) throw new Error(`Expected x,y for first point`);
+	if (!isPoint(b)) throw new Error(`Expected x,y for second point`);
+	return [a, b];
+}
+/**
+* Returns a Point form of either a point, x,y params or x,y,z params.
+* If parameters are undefined, an empty point is returned (0, 0)
+* @ignore
+* @param a
+* @param b
+* @returns
+*/
+function getPointParameter(a, b, c) {
+	if (a === void 0) return {
+		x: 0,
+		y: 0
+	};
+	if (Array.isArray(a)) {
+		if (a.length === 0) return Object.freeze({
+			x: 0,
+			y: 0
+		});
+		if (a.length === 1) return Object.freeze({
+			x: a[0],
+			y: 0
+		});
+		if (a.length === 2) return Object.freeze({
+			x: a[0],
+			y: a[1]
+		});
+		if (a.length === 3) return Object.freeze({
+			x: a[0],
+			y: a[1],
+			z: a[2]
+		});
+		throw new Error(`Expected array to be 1-3 elements in length. Got ${a.length}.`);
+	}
+	if (isPoint(a)) return a;
+	else if (typeof a !== `number` || typeof b !== `number`) throw new TypeError(`Expected point or x,y as parameters. Got: a: ${JSON.stringify(a)} b: ${JSON.stringify(b)}`);
+	if (typeof c === `number`) return Object.freeze({
+		x: a,
+		y: b,
+		z: c
+	});
+	return Object.freeze({
+		x: a,
+		y: b
+	});
+}
+/**
+* Calculate distance between two points.
+* If both points have a `z` property, the distance is 3D distance is calculated.
+* If only one point has a `z`, it is ignored. To force 2D distance, use {@link distance2d}
+*
+* ```js
+* // Distance between two points
+* const ptA = { x: 0.5, y:0.8 };
+* const ptB = { x: 1, y: 0.4 };
+* distance(ptA, ptB);
+* // Or, provide x,y as parameters
+* distance(ptA, 0.4, 0.9);
+*
+* // Distance from ptA to x: 0.5, y:0.8, z: 0.1
+* const ptC = { x: 0.5, y:0.5, z: 0.3 };
+* // With x,y,z as parameters:
+* distance(ptC, 0.5, 0.8, 0.1);
+* ```
+* @param a First point
+* @param xOrB Second point, or x coord
+* @param y y coord, if x coord is given
+* @param z Optional z coord, if x and y are given.
+* @returns
+*/
+function distance(a, xOrB, y, z) {
+	const pt = getPointParameter(xOrB, y, z);
+	guard$5(pt, `b`);
+	guard$5(a, `a`);
+	return isPoint3d(pt) && isPoint3d(a) ? Math.hypot(pt.x - a.x, pt.y - a.y, pt.z - a.z) : Math.hypot(pt.x - a.x, pt.y - a.y);
+}
+/**
+* As {@link distance} but always compares by x,y only.
+* @param a
+* @param xOrB 
+* @param y
+* @returns 
+*/
+function distance2d(a, xOrB, y) {
+	const pt = getPointParameter(xOrB, y);
+	guard$5(pt, `b`);
+	guard$5(a, `a`);
+	return Math.hypot(pt.x - a.x, pt.y - a.y);
+}
+/**
+* Returns a Point with the x,y,z values of two points subtracted (a-b).
+* 
+* `z` parameter is used if present. Uses a default value of 0 for 'z' when subtracting a 2D point with a 3D one.
+*
+* Examples:
+*
+* ```js
+* subtract(ptA, ptB);
+* subtract(x1, y1, x2, y2);
+* subtract(ptA, x2, y2);
+* ```
+*/
+function subtract(a1, ab2, ab3, ab4, ab5, ab6) {
+	const [ptA, ptB] = getTwoPointParameters(a1, ab2, ab3, ab4, ab5, ab6);
+	guard$5(ptA, `a`);
+	guard$5(ptB, `b`);
+	const pt = {
+		x: ptA.x - ptB.x,
+		y: ptA.y - ptB.y
+	};
+	if (isPoint3d(ptA) || isPoint3d(ptB)) pt.z = (ptA.z ?? 0) - (ptB.z ?? 0);
+	return Object.freeze(pt);
+}
+/**
+* Returns a point with rounded x,y coordinates. By default uses `Math.round` to round.
+* ```js
+* toIntegerValues({x:1.234, y:5.567}); // Yields: {x:1, y:6}
+* ```
+*
+* ```js
+* toIntegerValues(pt, Math.ceil); // Use Math.ceil to round x,y of `pt`.
+* ```
+* @param pt Point to round
+* @param rounder Rounding function, or Math.round by default
+* @returns
+*/
+const toIntegerValues = (pt, rounder = Math.round) => {
+	guard$5(pt, `pt`);
+	return Object.freeze({
+		x: rounder(pt.x),
+		y: rounder(pt.y)
+	});
+};
+/**
+* Returns a copy of `pt` with `z` field omitted.
+* If it didn't have one to begin within, a copy is still returned.
+* @param pt 
+* @returns 
+*/
+const to2d = (pt) => {
+	guard$5(pt, `pt`);
+	let copy = { ...pt };
+	delete copy.z;
+	return Object.freeze(copy);
+};
+/**
+* Returns a copy of `pt` with a `z` field set.
+* Defaults to a z value of 0.
+* @param pt Point
+* @param z Z-value, defaults to 0
+* @returns 
+*/
+const to3d = (pt, z = 0) => {
+	guard$5(pt, `pt`);
+	return Object.freeze({
+		...pt,
+		z
+	});
+};
+/**
+* Returns a human-friendly string representation `(x, y)`.
+* If `precision` is supplied, this will be the number of significant digits.
+* @param p
+* @returns
+*/
+function toString(p, digits) {
+	if (p === void 0) return `(undefined)`;
+	if (p === null) return `(null)`;
+	guard$5(p, `pt`);
+	const x = digits ? p.x.toFixed(digits) : p.x;
+	const y = digits ? p.y.toFixed(digits) : p.y;
+	if (p.z === void 0) return `(${x},${y})`;
+	else return `(${x},${y},${digits ? p.z.toFixed(digits) : p.z})`;
+}
+//#endregion
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.12/node_modules/@ixfx/geometry/dist/polar-LvwxTwIf.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 
+*/
+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` }
+* ```
+* 
+* Once parsed in this format, use {@link angleConvert} to convert to
+* a different unit.
+* @param value 
+* @returns 
+*/
+const 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)) throw new Error(`Invalid angle (bad value?)`);
+	if (unit.length === 0) throw new Error(`Invalid angle (no unit)`);
+	return {
+		value: numberValue,
+		unit
+	};
+};
+const 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 
+*/
+const angleConvert = (angleOrDegrees, destination) => {
+	const angle = typeof angleOrDegrees === `object` ? angleOrDegrees : angleParse(angleOrDegrees);
+	switch (destination) {
+		case `deg`:
+			if (angle.unit === `deg`) return angle;
+			if (angle.unit === `rad`) return {
+				value: radianToDegree(angle.value),
+				unit: `deg`
+			};
+			if (angle.unit === `grad`) return {
+				value: gradianToDegree(angle.value),
+				unit: `deg`
+			};
+			if (angle.unit === `turn`) return {
+				value: turnToDegree(angle.value),
+				unit: `deg`
+			};
+			throw new Error(`Unknown unit: ${angle.unit}`);
+		case `grad`:
+			if (angle.unit === `deg`) return {
+				value: degreeToGradian(angle.value),
+				unit: `grad`
+			};
+			if (angle.unit === `rad`) return {
+				value: radianToGradian(angle.value),
+				unit: `grad`
+			};
+			if (angle.unit === `grad`) return angle;
+			if (angle.unit === `turn`) return {
+				value: radianToGradian(turnToRadian(angle.value)),
+				unit: `grad`
+			};
+			throw new Error(`Unknown unit: ${angle.unit}`);
+		case `rad`:
+			if (angle.unit === `deg`) return {
+				value: degreeToRadian(angle.value),
+				unit: `rad`
+			};
+			if (angle.unit === `rad`) return angle;
+			if (angle.unit === `grad`) return {
+				value: gradianToRadian(angle.value),
+				unit: `rad`
+			};
+			if (angle.unit === `turn`) return {
+				value: radianToGradian(turnToRadian(angle.value)),
+				unit: `grad`
+			};
+			throw new Error(`Unknown unit: ${angle.unit}`);
+		case `turn`:
+			if (angle.unit === `deg`) return {
+				value: degreeToTurn(angle.value),
+				unit: `turn`
+			};
+			if (angle.unit === `rad`) return {
+				value: radianToTurn(angle.value),
+				unit: `turn`
+			};
+			if (angle.unit === `grad`) return {
+				value: radianToTurn(gradianToRadian(angle.value)),
+				unit: `turn`
+			};
+			if (angle.unit === `turn`) return angle;
+			throw new Error(`Unknown unit: ${angle.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 
+*/
+const turnToDegree = (turns, wrap = true) => {
+	if (wrap) return turns * 360 % 360;
+	return turns * 360;
+};
+const turnToRadian = (turns) => turns * piPi;
+const degreeToTurn = (degrees) => degrees / 360;
+const radianToTurn = (radians) => radians / piPi;
+/**
+* Normalise a radian angle to 0..2*PI range
+* @param angleRadian 
+* @returns 
+*/
+const radiansNormalise = (angleRadian) => {
+	angleRadian %= piPi;
+	return angleRadian < 0 ? angleRadian + piPi : angleRadian;
+};
+/**
+* Returns true if `p` seems to be a {@link Polar.Coord} (ie has both distance & angleRadian fields)
+* @param p
+* @returns True if `p` seems to be a PolarCoord
+*/
+const isPolarCoord = (p) => {
+	if (p.distance === void 0) return false;
+	if (p.angleRadian === void 0) return false;
+	return true;
+};
+/**
+* Returns a rotated coordinate
+* @param c Coordinate
+* @param amountRadian Amount to rotate, in radians
+* @returns
+*/
+const rotate$1 = (c, amountRadian) => Object.freeze({
+	...c,
+	angleRadian: c.angleRadian + amountRadian
+});
+/**
+* An empty point of `{ x: 0, y: 0 }`.
+*
+* Use `isEmpty` to check if a point is empty.
+* Use `Empty3d` to get an empty point with `z`.
+*/
+const Empty = {
+	x: 0,
+	y: 0
+};
+/**
+* Returns { x:1, y:1 }
+*/
+const Unit = {
+	x: 1,
+	y: 1
+};
+/**
+* An empty Point of `{ x: 0, y: 0, z: 0}`
+* Use `isEmpty` to check if a point is empty.
+* Use `Empty` to get an empty point without `z`.
+*/
+const Empty3d = {
+	x: 0,
+	y: 0,
+	z: 0
+};
+/**
+* Returns { x:1,y:1,z:1 }
+*/
+const Unit3d = {
+	x: 1,
+	y: 1,
+	z: 1
+};
+/**
+* Converts to Cartesian coordinate from polar.
+*
+* ```js
+*
+* const origin = { x: 50, y: 50}; // Polar origin
+* // Yields: { x, y }
+* const polar = Polar.toCartesian({ distance: 10, angleRadian: 0 }, origin);
+* ```
+*
+* Distance and angle can be provided as numbers intead:
+*
+* ```
+* // Yields: { x, y }
+* const polar = Polar.toCartesian(10, 0, origin);
+* ```
+*
+* @param a
+* @param b
+* @param c
+* @returns
+*/
+const toCartesian$1 = (a, b, c) => {
+	if (isPolarCoord(a)) {
+		if (typeof b === `undefined`) b = Empty;
+		if (isPoint(b)) return polarToCartesian(a.distance, a.angleRadian, b);
+		throw new Error(`Expecting (Coord, Point). Second parameter is not a point`);
+	} else if (typeof a === `object`) throw new TypeError(`First param is an object, but not a Coord: ${JSON.stringify(a)}`);
+	else if (typeof a === `number` && typeof b === `number`) {
+		if (typeof c === `undefined`) c = Empty;
+		if (!isPoint(c)) throw new Error(`Expecting (number, number, Point). Point param wrong type`);
+		return polarToCartesian(a, b, c);
+	} else throw new TypeError(`Expecting parameters of (number, number). Got: (${typeof a}, ${typeof b}, ${typeof c}). a: ${JSON.stringify(a)}`);
+};
+/**
+* Converts a Cartesian coordinate to polar
+*
+* ```js
+*
+* // Yields: { angleRadian, distance }
+* const polar = Polar.fromCartesian({x: 50, y: 50}, origin);
+* ```
+*
+* Any additional properties of `point` are copied to object.
+* 
+* Options:
+* * fullCircle: If _true_ (default) returns values on 0..2PI range. If _false_, 0....PI..-PI range.
+* * digits: Rounding to apply
+* @param point Point
+* @param origin Origin. If unspecified, {x:0,y:0} is used
+* @param options Options
+* @returns
+*/
+const fromCartesian = (point, origin, options = {}) => {
+	if (typeof point !== `object`) throw new TypeError(`Param 'point' wrong. Expecting a Point, got: ${typeof point}`);
+	const fullCircle = options.fullCircle ?? true;
+	if (typeof origin === `object`) point = subtract(point, origin);
+	let angle = Math.atan2(point.y, point.x);
+	if (fullCircle) angle = radiansNormalise(angle);
+	let distance = Math.hypot(point.x, point.y);
+	if (typeof options.digits === `number`) {
+		angle = parseFloat(angle.toFixed(options.digits));
+		distance = parseFloat(distance.toFixed(options.digits));
+	}
+	const polar = {
+		...point,
+		angleRadian: angle,
+		distance
+	};
+	delete polar.x;
+	delete polar.y;
+	return Object.freeze(polar);
+};
+/**
+* Converts a polar coordinate to Cartesian
+* @param distance Distance
+* @param angleRadians Angle in radians
+* @param origin Origin, or 0,0 by default.
+* @returns
+*/
+const polarToCartesian = (distance, angleRadians, origin = Empty) => {
+	guard$5(origin);
+	return Object.freeze({
+		x: origin.x + distance * Math.cos(angleRadians),
+		y: origin.y + distance * Math.sin(angleRadians)
+	});
+};
+/**
+* Returns the angle in radians between `a` and `b`.
+*
+* Eg if `a` is the origin, and `b` is another point,
+* in degrees one would get 0 to -180 when `b` was above `a`.
+*  -180 would be `b` in line with `a`.
+* Same for under `a`.
+*
+* Providing a third point `c` gives the interior angle, where `b` is the middle point.
+* 
+* See also {@link angleRadianCircle} which returns coordinates on 0..Math.Pi*2
+* range. This avoids negative numbers.
+* 
+* @example Calculate angle between a middle of canvas and the cursor
+* ```js
+* const canvasEl = document.querySelector('canvas');
+* const middle = { x: canvasEl.width/2, y: canvasEl.height /2 }
+* 
+* canvasEl.addEventListener(`pointermove`, event => { 
+*  const cursor = {
+*    x: event.offsetX,
+*    y: event.offsetY
+*  }
+*  const a = G.Points.angleRadian(middle, cursor);
+*});
+* ```
+* @param a
+* @param b
+* @param c
+* @returns
+*/
+const angleRadian = (a, b, c) => {
+	guard$5(a, `a`);
+	if (b === void 0) return Math.atan2(a.y, a.x);
+	guard$5(b, `b`);
+	if (c === void 0) return Math.atan2(b.y - a.y, b.x - a.x);
+	guard$5(c, `c`);
+	return Math.atan2(b.y - a.y, b.x - a.x) - Math.atan2(c.y - a.y, c.x - a.x);
+};
+/**
+* Returns the angle between point(s) using a radian circle system.
+* ```
+*       90deg
+*       Pi/2
+*        |
+* Pi  ---+--- 0
+* 180    |
+*       3PI/2
+*       270deg
+* ```
+* @param a 
+* @param b 
+* @param c 
+* @returns 
+*/
+const angleRadianCircle = (a, b, c) => {
+	const angle = angleRadian(a, b, c);
+	if (angle < 0) return angle + piPi;
+	return angle;
+};
+/**
+* Return the angle of a wedge, defined by a, b and C points, where 'b'
+* could be thought of as the origin or pivot.
+* 
+* @param a 
+* @param b 
+* @param c 
+* @returns 
+*/
+const angleRadianThreePoint = (a, b, c) => {
+	const ab = Math.sqrt(Math.pow(b.x - a.x, 2) + Math.pow(b.y - a.y, 2));
+	const bc = Math.sqrt(Math.pow(b.x - c.x, 2) + Math.pow(b.y - c.y, 2));
+	const ac = Math.sqrt(Math.pow(c.x - a.x, 2) + Math.pow(c.y - a.y, 2));
+	return Math.acos((bc * bc + ab * ab - ac * ac) / (2 * bc * ab));
+};
+//#endregion
+//#region node_modules/.pnpm/@ixfx+visual@0.56.12/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$1({
+	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$1({
+	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$1({
+	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$1({
+	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$1({
+	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 { isPoint3d as A, guard$5 as C, isNull as D, isNaN as E, __exportAll as M, isPlaceholder as O, toString as S, isEmpty as T, getTwoPointParameters as _, Unit3d as a, to3d as b, angleRadianThreePoint as c, fromCartesian as d, rotate$1 as f, getPointParameter as g, distance2d as h, Unit as i, test as j, isPoint as k, average$1 as l, distance as m, Empty as n, angleRadian as o, toCartesian$1 as p, Empty3d as r, angleRadianCircle as s, colour_exports as t, averager as u, subtract as v, guardNonZeroPoint as w, toIntegerValues as x, to2d as y };
+
+//# sourceMappingURL=colour-C3MQIjFJ-BJV-QC-3.js.map