@sardine/colour 2.4.0 → 4.0.0

package/dist/index.cjs

@@ -1,646 +1,1081 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/util/namedCSSColours.ts
+/**
+* Named list from https://developer.mozilla.org/en-US/docs/Web/CSS/named-color
+*/
+var namedCSSColours = new Map([
+	["aliceblue", "#f0f8ff"],
+	["antiquewhite", "#faebd7"],
+	["aqua", "#00ffff"],
+	["aquamarine", "#7fffd4"],
+	["azure", "#f0ffff"],
+	["beige", "#f5f5dc"],
+	["bisque", "#ffe4c4"],
+	["black", "#000000"],
+	["blanchedalmond", "#ffebcd"],
+	["blue", "#0000ff"],
+	["blueviolet", "#8a2be2"],
+	["brown", "#a52a2a"],
+	["burlywood", "#deb887"],
+	["cadetblue", "#5f9ea0"],
+	["chartreuse", "#7fff00"],
+	["chocolate", "#d2691e"],
+	["coral", "#ff7f50"],
+	["cornflowerblue", "#6495ed"],
+	["cornsilk", "#fff8dc"],
+	["crimson", "#dc143c"],
+	["cyan", "#00ffff"],
+	["darkblue", "#00008b"],
+	["darkcyan", "#008b8b"],
+	["darkgoldenrod", "#b8860b"],
+	["darkgray", "#a9a9a9"],
+	["darkgreen", "#006400"],
+	["darkgrey", "#a9a9a9"],
+	["darkkhaki", "#bdb76b"],
+	["darkmagenta", "#8b008b"],
+	["darkolivegreen", "#556b2f"],
+	["darkorange", "#ff8c00"],
+	["darkorchid", "#9932cc"],
+	["darkred", "#8b0000"],
+	["darksalmon", "#e9967a"],
+	["darkseagreen", "#8fbc8f"],
+	["darkslateblue", "#483d8b"],
+	["darkslategray", "#2f4f4f"],
+	["darkslategrey", "#2f4f4f"],
+	["darkturquoise", "#00ced1"],
+	["darkviolet", "#9400d3"],
+	["deeppink", "#ff1493"],
+	["deepskyblue", "#00bfff"],
+	["dimgray", "#696969"],
+	["dimgrey", "#696969"],
+	["dodgerblue", "#1e90ff"],
+	["firebrick", "#b22222"],
+	["floralwhite", "#fffaf0"],
+	["forestgreen", "#228b22"],
+	["fuchsia", "#ff00ff"],
+	["gainsboro", "#dcdcdc"],
+	["ghostwhite", "#f8f8ff"],
+	["gold", "#ffd700"],
+	["goldenrod", "#daa520"],
+	["gray", "#808080"],
+	["green", "#008000"],
+	["greenyellow", "#adff2f"],
+	["grey", "#808080"],
+	["honeydew", "#f0fff0"],
+	["hotpink", "#ff69b4"],
+	["indianred", "#cd5c5c"],
+	["indigo", "#4b0082"],
+	["ivory", "#fffff0"],
+	["khaki", "#f0e68c"],
+	["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"],
+	["transparent", "#00000000"],
+	["turquoise", "#40e0d0"],
+	["violet", "#ee82ee"],
+	["wheat", "#f5deb3"],
+	["white", "#ffffff"],
+	["whitesmoke", "#f5f5f5"],
+	["yellow", "#ffff00"],
+	["yellowgreen", "#9acd32"]
+]);
+//#endregion
+//#region src/util/regexers.ts
+/** Any valid hexadecimal colour: 3, 4, 6, or 8 hex digits after `#` */
+var hexAnyRegex = /^#(?:[0-9a-fA-F]{8}|[0-9a-fA-F]{6}|[0-9a-fA-F]{4}|[0-9a-fA-F]{3})$/;
+/**
+* Captures the following CSS RGB formats:
+* - `rgb(0,0,0)`
+* - `rgba(0, 0, 0, 0.4)`
+* - `rgba(0,0,0,50%)`
+* - `rgb(0 0 0)`
+* - `rgba(0 0 0 / 0.4)`
+* - `rgb(0 0 0 / 0.5)`
+* - `rgb(0 0 0 / 50%)`
+* - `rgb(50%, 25%, 100%)`
+* - `rgba(50%, 25%, 100%, 0.8)`
+* - `rgba(50%, 25%, 100%, 80%)`
+*/
+var cssRGBARegex = /^rgba?\(\s*([-+]?\d*\.?\d+%?)\s*[,\s]\s*([-+]?\d*\.?\d+%?)\s*[,\s]\s*([-+]?\d*\.?\d+%?)\s*(?:[,/]\s*([-+]?\d*\.?\d+%?))?\s*\)$/i;
+//#endregion
+//#region src/assertions.ts
+/**
+* Determines whether a string represents a valid CSS RGB or RGBA colour value.
+*
+* Captures the following CSS RGB formats:
+* - `rgb(0,0,0)`
+* - `rgba(0, 0, 0, 0.4)`
+* - `rgba(0,0,0,50%)`
+* - `rgb(0 0 0)`
+* - `rgba(0 0 0 / 0.4)`
+* - `rgb(0 0 0 / 0.5)`
+* - `rgb(0 0 0 / 50%)`
+* - `rgb(50%, 25%, 100%)`
+* - `rgba(50%, 25%, 100%, 0.8)`
+* - `rgba(50%, 25%, 100%, 80%)`
+*
+* @param {string} colour - The string to test.
+* @returns {boolean} `true` if the string represents a valid CSS RGB or RGBA colour value, `false` otherwise.
+*/
+function isCSSRGBColour(colour) {
+	return cssRGBARegex.test(colour);
+}
+/**
+* Determines whether a string represents a valid hexadecimal colour value.
+*
+* @param {string} colour - The string to test.
+* @returns {boolean} True if the string represents a valid hexadecimal colour value, false otherwise.
+*/
+function isHexColour(colour) {
+	return hexAnyRegex.test(colour);
+}
+/**
+* Determines whether a string represents a valid named CSS colour.
+*
+* @param {NamedCSSColour} colour - The string to test.
+* @returns {boolean} `true` if the string represents a valid named CSS colour, `false` otherwise.
+*/
+function isNamedCSSColour(colour) {
+	return namedCSSColours.has(colour);
+}
+//#endregion
+//#region src/util/index.ts
+/**
+* Calculates the Hue derivative
+* @param x A numeric expression representing the cartesian x-coordinate.
+* @param y A numeric expression representing the cartesian y-coordinate.
+*/
 function hue_d(x, y) {
-  if (x === 0 && y === 0) {
-    return 0;
-  }
-  const angle = Math.atan2(x, y) * (180 / Math.PI);
-  if (angle >= 0) {
-    return angle;
-  }
-  return angle + 360;
+	if (x === 0 && y === 0) return 0;
+	/** The angle in degrees */
+	const angle = Math.atan2(x, y) * (180 / Math.PI);
+	if (angle >= 0) return angle;
+	return angle + 360;
 }
+/**
+* Calculates the difference between two Hue derivatives
+* @param HueHelper param
+*/
 function deltaHue_d({ C1, C2, h1_d, h2_d }) {
-  if (C1 * C2 === 0) {
-    return 0;
-  }
-  const delta = h2_d - h1_d;
-  if (Math.abs(delta) <= 180) {
-    return delta;
-  }
-  if (delta > 180) {
-    return delta - 360;
-  }
-  return delta + 360;
+	if (C1 * C2 === 0) return 0;
+	const delta = h2_d - h1_d;
+	if (Math.abs(delta) <= 180) return delta;
+	if (delta > 180) return delta - 360;
+	return delta + 360;
 }
+/**
+* Calculates the mean between two Hue derivatives
+* @param HueHelper param
+*/
 function meanHue_d({ C1, C2, h1_d, h2_d }) {
-  if (C1 * C2 === 0) {
-    return h2_d + h1_d;
-  }
-  const delta = Math.abs(h1_d - h2_d);
-  if (delta <= 180) {
-    return (h2_d + h1_d) / 2;
-  }
-  if (delta > 180 && h1_d + h2_d < 360) {
-    return (h2_d + h1_d + 360) / 2;
-  }
-  return (h2_d + h1_d - 360) / 2;
-}
-const toRadians = (n) => n * (Math.PI / 180);
-const bigSquare = (n) => Math.sqrt(n ** 7 / (n ** 7 + 25 ** 7));
+	if (C1 * C2 === 0) return h2_d + h1_d;
+	const delta = Math.abs(h1_d - h2_d);
+	if (delta <= 180) return (h2_d + h1_d) / 2;
+	if (delta > 180 && h1_d + h2_d < 360) return (h2_d + h1_d + 360) / 2;
+	return (h2_d + h1_d - 360) / 2;
+}
+/**
+* Converts a number in degrees to radians
+* @param n Number in degrees to be converted
+*/
+var DEG_TO_RAD = Math.PI / 180;
+var toRadians = (n) => n * DEG_TO_RAD;
+/**
+* Calculates a recurring square root
+* @param n Input number
+*/
+var POW_25_7 = 25 ** 7;
+var bigSquare = (n) => Math.sqrt(n ** 7 / (n ** 7 + POW_25_7));
+/**
+* Normalise black and white colorimetry as specified in IEC 61966-2-1
+* It takes a RGB channel in the range [0 - 255] and returns a value between 0 and 1
+* @param rgbValue number to be normalised
+*/
 function linearRGB(rgbValue, WCAG21) {
-  const rgbRatio = rgbValue / 255;
-  const threshold = WCAG21 ? 0.03928 : 0.04045;
-  let linearValue;
-  if (rgbRatio > threshold) {
-    linearValue = ((rgbRatio + 0.055) / 1.055) ** 2.4;
-  } else {
-    linearValue = rgbRatio / 12.92;
-  }
-  return linearValue;
+	const rgbRatio = rgbValue / 255;
+	const threshold = WCAG21 ? .03928 : .04045;
+	let linearValue;
+	if (rgbRatio > threshold) linearValue = ((rgbRatio + .055) / 1.055) ** 2.4;
+	else linearValue = rgbRatio / 12.92;
+	return linearValue;
 }
+/**
+* The division of the f function domain into two parts was done to prevent an infinite slope at n = 0
+* @param n Number to be constrained
+*/
+var LAB_DELTA = 6 / 29;
+var LAB_DELTA_CUBE = LAB_DELTA ** 3;
+var LAB_DELTA_SQ_3 = 3 * LAB_DELTA ** 2;
 function constrainLab(n) {
-  const delta = 6 / 29;
-  const deltaCube = delta ** 3;
-  let t;
-  if (n > deltaCube) {
-    t = Math.cbrt(n);
-  } else {
-    t = n / (3 * delta ** 2) + 4 / 29;
-  }
-  return t;
+	if (n > LAB_DELTA_CUBE) return Math.cbrt(n);
+	return n / LAB_DELTA_SQ_3 + 4 / 29;
 }
+/**
+* Clamps a number between two values
+* @param {number} value - The value to be clamped
+* @param {number} min - The minimum value
+* @param {number} max - The maximum value
+* @returns {number} - A clamped value
+*/
 function clamp(value, min, max) {
-  return Math.min(Math.max(value, min), max);
+	return Math.min(Math.max(value, min), max);
 }
+/** MDN reference for CSS named colours — shared to avoid duplicating the URL string in the bundle */
+var NAMED_CSS_COLOUR_URL = "https://developer.mozilla.org/en-US/docs/Web/CSS/named-color";
+//#endregion
+//#region src/CIEDE2000.ts
+/**
+* Measures the colour difference between two colours in the Lab space
+*
+* Math taken from:
+*
+* https://en.wikipedia.org/wiki/Color_difference#CIEDE2000
+* http://www2.ece.rochester.edu/~gsharma/ciede2000/ciede2000noteCRNA.pdf
+* @param colour1 First colour to be compared
+* @param colour2 First colour to be compared
+*/
 function ciede2000(colour1, colour2) {
-  const lightness1 = colour1.L;
-  const greenRed1 = colour1.a;
-  const blueYellow1 = colour1.b;
-  const lightness2 = colour2.L;
-  const greenRed2 = colour2.a;
-  const blueYellow2 = colour2.b;
-  const luminanceWeight = 1;
-  const chromaWeight = 1;
-  const hueWeight = 1;
-  const chroma1 = Math.sqrt(greenRed1 ** 2 + blueYellow1 ** 2);
-  const chroma2 = Math.sqrt(greenRed2 ** 2 + blueYellow2 ** 2);
-  const deltaLightness = lightness2 - lightness1;
-  const meanChroma = (chroma1 + chroma2) / 2;
-  const G = 0.5 * (1 - bigSquare(meanChroma));
-  const greenRed1Prime = greenRed1 * (1 + G);
-  const greenRed2Prime = greenRed2 * (1 + G);
-  const chroma1Prime = Math.sqrt(greenRed1Prime ** 2 + blueYellow1 ** 2);
-  const chroma2Prime = Math.sqrt(greenRed2Prime ** 2 + blueYellow2 ** 2);
-  const meanChromaPrime = (chroma1Prime + chroma2Prime) / 2;
-  const deltaChromaPrime = chroma2Prime - chroma1Prime;
-  const hue1Prime = hue_d(blueYellow1, greenRed1Prime);
-  const hue2Prime = hue_d(blueYellow2, greenRed2Prime);
-  const deltaHuePrime = deltaHue_d({
-    C1: chroma1,
-    C2: chroma2,
-    h1_d: hue1Prime,
-    h2_d: hue2Prime
-  });
-  const deltaHue = 2 * Math.sqrt(chroma1Prime * chroma2Prime) * Math.sin(toRadians(deltaHuePrime) / 2);
-  const meanHuePrime = meanHue_d({
-    C1: chroma1,
-    C2: chroma2,
-    h1_d: hue1Prime,
-    h2_d: hue2Prime
-  });
-  const meanLightness = (lightness1 + lightness2) / 2;
-  const T = 1 - 0.17 * Math.cos(toRadians(meanHuePrime - 30)) + 0.24 * Math.cos(toRadians(2 * meanHuePrime)) + 0.32 * Math.cos(toRadians(3 * meanHuePrime + 6)) - 0.2 * Math.cos(toRadians(4 * meanHuePrime - 63));
-  const SL = 1 + 0.015 * (meanLightness - 50) ** 2 / Math.sqrt(20 + (meanLightness - 50) ** 2);
-  const SC = 0.045 * meanChromaPrime + 1;
-  const SH = 1 + 0.015 * meanChromaPrime * T;
-  const rotation = 30 * Math.exp(-(((meanHuePrime - 275) / 25) ** 2));
-  const RT = -2 * bigSquare(meanChromaPrime) * Math.sin(toRadians(rotation * 2));
-  const deltaE = Math.sqrt(
-    (deltaLightness / (luminanceWeight * SL)) ** 2 + (deltaChromaPrime / (chromaWeight * SC)) ** 2 + (deltaHue / (hueWeight * SH)) ** 2 + RT * (deltaChromaPrime / (chromaWeight * SC)) * (deltaHue / (hueWeight * SH))
-  );
-  return deltaE;
+	/** Lightness for colour 1 */
+	const lightness1 = colour1.L;
+	/** green–red colour opponent for colour 1 */
+	const greenRed1 = colour1.a;
+	/** blue–yellow colour opponent for colour 1 */
+	const blueYellow1 = colour1.b;
+	/** Lightness for colour 2 */
+	const lightness2 = colour2.L;
+	/** green–red colour opponent for colour 2 */
+	const greenRed2 = colour2.a;
+	/** blue–yellow colour opponent for colour 2 */
+	const blueYellow2 = colour2.b;
+	/** Weighting factor for Luminance */
+	const luminanceWeight = 1;
+	/** Weighting factor for Chroma */
+	const chromaWeight = 1;
+	/** Weighting factor for Hue */
+	const hueWeight = 1;
+	/** Chroma for colour 1 */
+	const chroma1 = Math.sqrt(greenRed1 ** 2 + blueYellow1 ** 2);
+	/** Chroma for colour 2 */
+	const chroma2 = Math.sqrt(greenRed2 ** 2 + blueYellow2 ** 2);
+	/** Derivative of the Lightness difference */
+	const deltaLightness = lightness2 - lightness1;
+	const G = .5 * (1 - bigSquare((chroma1 + chroma2) / 2));
+	/** Derivative of greenRed1 */
+	const greenRed1Prime = greenRed1 * (1 + G);
+	/** Derivative of greenRed2 */
+	const greenRed2Prime = greenRed2 * (1 + G);
+	/** Derivative of chroma1 */
+	const chroma1Prime = Math.sqrt(greenRed1Prime ** 2 + blueYellow1 ** 2);
+	/** Derivative of chroma2 */
+	const chroma2Prime = Math.sqrt(greenRed2Prime ** 2 + blueYellow2 ** 2);
+	/** Derivative of Chroma mean */
+	const meanChromaPrime = (chroma1Prime + chroma2Prime) / 2;
+	/** Derivative of the mean difference of Chroma */
+	const deltaChromaPrime = chroma2Prime - chroma1Prime;
+	/** Derivative of colour 1 Hue */
+	const hue1Prime = hue_d(blueYellow1, greenRed1Prime);
+	/** Derivative of colour 2 Hue */
+	const hue2Prime = hue_d(blueYellow2, greenRed2Prime);
+	/** Hue difference */
+	const deltaHuePrime = deltaHue_d({
+		C1: chroma1,
+		C2: chroma2,
+		h1_d: hue1Prime,
+		h2_d: hue2Prime
+	});
+	const deltaHue = 2 * Math.sqrt(chroma1Prime * chroma2Prime) * Math.sin(toRadians(deltaHuePrime) / 2);
+	/** Derivative of mean hue */
+	const meanHuePrime = meanHue_d({
+		C1: chroma1,
+		C2: chroma2,
+		h1_d: hue1Prime,
+		h2_d: hue2Prime
+	});
+	/** Lightness Mean value*/
+	const meanLightness = (lightness1 + lightness2) / 2;
+	/** Compensation for neutral colours (the primed values in the L*C*h differences) */
+	const T = 1 - .17 * Math.cos(toRadians(meanHuePrime - 30)) + .24 * Math.cos(toRadians(2 * meanHuePrime)) + .32 * Math.cos(toRadians(3 * meanHuePrime + 6)) - .2 * Math.cos(toRadians(4 * meanHuePrime - 63));
+	/** Compensation for lightness */
+	const SL = 1 + .015 * (meanLightness - 50) ** 2 / Math.sqrt(20 + (meanLightness - 50) ** 2);
+	/** Compensation for chroma */
+	const SC = .045 * meanChromaPrime + 1;
+	/** Compensation for hue */
+	const SH = 1 + .015 * meanChromaPrime * T;
+	const rotation = 30 * Math.exp(-(((meanHuePrime - 275) / 25) ** 2));
+	/** A hue rotation term, to deal with the problematic blue region (hue angles in the neighborhood of 275°) */
+	const RT = -2 * bigSquare(meanChromaPrime) * Math.sin(toRadians(rotation * 2));
+	return Math.sqrt((deltaLightness / (luminanceWeight * SL)) ** 2 + (deltaChromaPrime / (chromaWeight * SC)) ** 2 + (deltaHue / (hueWeight * SH)) ** 2 + RT * (deltaChromaPrime / (chromaWeight * SC)) * (deltaHue / (hueWeight * SH)));
 }
-function convertRGBtoXYZ(colour) {
-  const { R, G, B } = colour;
-  const _R = linearRGB(R) * 100;
-  const _G = linearRGB(G) * 100;
-  const _B = linearRGB(B) * 100;
-  const X = _R * 0.4124 + _G * 0.3576 + _B * 0.1805;
-  const Y = _R * 0.2126 + _G * 0.7152 + _B * 0.0722;
-  const Z = _R * 0.0193 + _G * 0.1192 + _B * 0.9505;
-  return { X, Y, Z };
+//#endregion
+//#region src/convertCSSRGBtoRGB.ts
+/**
+* Converts a CSS RGB/Alpha value to its numeric equivalent
+* @param value - The value string (e.g., "50%", "127", "0.5")
+* @param isAlpha - Whether this is an alpha channel value
+* @returns The numeric value
+*/
+function convertCssValueToNumber(value, isAlpha = false) {
+	if (value.endsWith("%")) {
+		const percentage = Number.parseFloat(value.slice(0, -1));
+		if (isAlpha) return percentage / 100;
+		return Math.round(percentage / 100 * 255);
+	}
+	return Number.parseFloat(value);
 }
-function convertXYZtoLab(colour) {
-  const { X, Y, Z } = colour;
-  const _X = X / 95.047;
-  const _Y = Y / 100;
-  const _Z = Z / 108.883;
-  const fX = constrainLab(_X);
-  const fY = constrainLab(_Y);
-  const fZ = constrainLab(_Z);
-  const L = 116 * fY - 16;
-  const a = 500 * (fX - fY);
-  const b = 200 * (fY - fZ);
-  return { L, a, b };
+function convertCssRgbChannelValue(value) {
+	if (!value) return void 0;
+	return convertCssValueToNumber(value);
 }
-function convertRGBtoLab(colour) {
-  const XYZColour = convertRGBtoXYZ(colour);
-  return convertXYZtoLab(XYZColour);
+function convertCssAlphaChannelValue(value) {
+	if (!value) return void 0;
+	return convertCssValueToNumber(value, true);
 }
-const RGBdistance = (colour1, colour2) => {
-  const c1 = convertRGBtoLab(colour1);
-  const c2 = convertRGBtoLab(colour2);
-  return ciede2000(c1, c2);
-};
-const hexRegex = /^#[a-fA-F0-9]{6}$/;
-const hexAlphaRegex = /^#[a-fA-F0-9]{8}$/;
-const shortHexRegex = /^#[a-fA-F0-9]{3}$/;
-const shortAlphaHexRegex = /^#[a-fA-F0-9]{4}$/;
-const cssRGBARegex = /^rgba*\(\s*([-+]?\d+)\s*(?:,)?\s*([-+]?\d+)\s*(?:,)?\s*([-+]?\d+)\s*(?:,*|\/*)\s*([-+]?\d*[.]?\d+[%]?)*\)$/i;
+/**
+* Converts CSS RGB colour format into RGB colour object.
+* @param {string} colour - A CSS RGB colour in the format:
+*
+* - `rgb(0,0,0)`
+* - `rgba(0,0,0,0.4)`
+* - `rgb(0 0 0)`
+* - `rgba(0 0 0 / 0.4)`
+* - `rgb(50%, 25%, 100%)`
+* - `rgba(50%, 25%, 100%, 0.8)`
+* - `rgba(50%, 25%, 100%, 80%)`
+*
+* @returns {RGBColour} - RGB colour object.
+*/
 function convertCSSRGBtoRGB(colour) {
-  const match = colour.match(cssRGBARegex);
-  if (!match) {
-    throw new Error(
-      `convertCSSRGBtoHex expects a valid CSS RGB string but got ${colour}`
-    );
-  }
-  const rgbNumber = (n) => n ? Number.parseFloat(n) : void 0;
-  return {
-    R: rgbNumber(match[1]),
-    G: rgbNumber(match[2]),
-    B: rgbNumber(match[3]),
-    A: rgbNumber(match[4])
-  };
+	const match = colour.match(cssRGBARegex);
+	if (!match) throw new Error(`convertCSSRGBtoRGB expects a valid CSS RGB string but got ${colour}`);
+	return {
+		R: convertCssRgbChannelValue(match[1]),
+		G: convertCssRgbChannelValue(match[2]),
+		B: convertCssRgbChannelValue(match[3]),
+		A: convertCssAlphaChannelValue(match[4])
+	};
 }
+//#endregion
+//#region src/convertRGBtoHex.ts
+/**
+* Converts a colour in the RGB format to Hexadecimal.
+* It accepts an option Alpha channel `A`
+* @param {RGBColour} colour - An object representing RGB Colour.
+* @param {number} colour.R - A number between 0 and 255 to describe the Red colour channel
+* @param {number} colour.G - A number between 0 and 255 to describe the Green colour channel
+* @param {number} colour.B - A number between 0 and 255 to describe the Blue colour channel
+* @param {number} colour.A - An optional number between 0 and 1 to describe the Alpha colour channel
+* @returns - An hexadecimal string
+*/
 function convertRGBtoHex({ R, G, B, A }) {
-  const hex = (n) => {
-    const value = clamp(n, 0, 255);
-    return value.toString(16).padStart(2, "0");
-  };
-  return `#${hex(R)}${hex(G)}${hex(B)}${A ? hex(Math.round(A * 255)) : ""}`;
+	const hex = (n) => {
+		return clamp(n, 0, 255).toString(16).padStart(2, "0");
+	};
+	return `#${hex(R)}${hex(G)}${hex(B)}${A ? hex(Math.round(A * 255)) : ""}`;
 }
+//#endregion
+//#region src/convertCSSRGBtoHex.ts
+/**
+* Converts CSS RGB colour format into Hexadecimal.
+* @param {string} colour - A CSS RGB colour in the format:
+*
+* - `rgb(0,0,0)`
+* - `rgba(0,0,0,0.4)`
+* - `rgb(0 0 0)`
+* - `rgba(0 0 0 / 0.4)`
+* - `rgb(50%, 25%, 100%)`
+* - `rgba(50%, 25%, 100%, 0.8)`
+* - `rgba(50%, 25%, 100%, 80%)`
+*
+* @returns {string} - An hexadecimal string
+*/
 function convertCSSRGBtoHex(colour) {
-  const rgb = convertCSSRGBtoRGB(colour);
-  return convertRGBtoHex(rgb);
+	return convertRGBtoHex(convertCSSRGBtoRGB(colour));
 }
+//#endregion
+//#region src/convertHextoRGB.ts
+/**
+* Converts an hexadecimal colour into RGB colour object.
+* @param {string} hex - An hexadecimal colour in the format:
+*
+* - `#000`
+* - `#102030`
+* - `#ffff`
+* - `#102030ff`
+*
+* @returns {RGBColour | null} RGB colour object, or `null` if the input is not a valid hexadecimal colour.
+*/
 function convertHextoRGB(hex) {
-  if (typeof hex !== "string") {
-    throw new Error(`convertHextoRGB expects a string but got a ${typeof hex}`);
-  }
-  if (hex.match(hexRegex)) {
-    return {
-      R: Number.parseInt(`${hex[1]}${hex[2]}`, 16),
-      G: Number.parseInt(`${hex[3]}${hex[4]}`, 16),
-      B: Number.parseInt(`${hex[5]}${hex[6]}`, 16)
-    };
-  }
-  if (hex.match(shortHexRegex)) {
-    return {
-      R: Number.parseInt(`${hex[1]}${hex[1]}`, 16),
-      G: Number.parseInt(`${hex[2]}${hex[2]}`, 16),
-      B: Number.parseInt(`${hex[3]}${hex[3]}`, 16)
-    };
-  }
-  if (hex.match(hexAlphaRegex)) {
-    return {
-      R: Number.parseInt(`${hex[1]}${hex[2]}`, 16),
-      G: Number.parseInt(`${hex[3]}${hex[4]}`, 16),
-      B: Number.parseInt(`${hex[5]}${hex[6]}`, 16),
-      A: Math.round(Number.parseInt(`${hex[7]}${hex[8]}`, 16) / 255 * 100) / 100
-    };
-  }
-  if (hex.match(shortAlphaHexRegex)) {
-    return {
-      R: Number.parseInt(`${hex[1]}${hex[1]}`, 16),
-      G: Number.parseInt(`${hex[2]}${hex[2]}`, 16),
-      B: Number.parseInt(`${hex[3]}${hex[3]}`, 16),
-      A: Math.round(Number.parseInt(`${hex[4]}${hex[4]}`, 16) / 255 * 100) / 100
-    };
-  }
-  throw new Error(
-    `convertHextoRGB expects an valid hexadecimal colour value but got ${hex}`
-  );
+	if (typeof hex !== "string" || !hexAnyRegex.test(hex)) return null;
+	switch (hex.length) {
+		case 7: return {
+			R: parseInt(hex.slice(1, 3), 16),
+			G: parseInt(hex.slice(3, 5), 16),
+			B: parseInt(hex.slice(5, 7), 16)
+		};
+		case 4: return {
+			R: parseInt(hex.slice(1, 2).repeat(2), 16),
+			G: parseInt(hex.slice(2, 3).repeat(2), 16),
+			B: parseInt(hex.slice(3, 4).repeat(2), 16)
+		};
+		case 9: return {
+			R: parseInt(hex.slice(1, 3), 16),
+			G: parseInt(hex.slice(3, 5), 16),
+			B: parseInt(hex.slice(5, 7), 16),
+			A: Math.round(parseInt(hex.slice(7, 9), 16) / 255 * 100) / 100
+		};
+		default: return {
+			R: parseInt(hex.slice(1, 2).repeat(2), 16),
+			G: parseInt(hex.slice(2, 3).repeat(2), 16),
+			B: parseInt(hex.slice(3, 4).repeat(2), 16),
+			A: Math.round(parseInt(hex.slice(4, 5).repeat(2), 16) / 255 * 100) / 100
+		};
+	}
 }
+//#endregion
+//#region src/convertHextoCSSRGB.ts
+/**
+* Converts an hexadecimal colour into CSS RGB/A colour.
+* @param {string} hex - An hexadecimal colour in the format:
+*
+* - `#000`
+* - `#102030`
+* - `#ffff`
+* - `#102030ff`
+*
+* @returns {string} either a CSS RGB or CSS RGBA string.
+*/
 function convertHextoCSSRGB(hex) {
-  const rgb = convertHextoRGB(hex);
-  if (rgb.A) {
-    return `rgba(${rgb.R},${rgb.G},${rgb.B},${rgb.A})`;
-  }
-  return `rgb(${rgb.R},${rgb.G},${rgb.B})`;
-}
-const namedCSSColours = /* @__PURE__ */ new Map([
-  ["aliceblue", "#f0f8ff"],
-  ["antiquewhite", "#faebd7"],
-  ["aqua", "#00ffff"],
-  ["aquamarine", "#7fffd4"],
-  ["azure", "#f0ffff"],
-  ["beige", "#f5f5dc"],
-  ["bisque", "#ffe4c4"],
-  ["black", "#000000"],
-  ["blanchedalmond", "#ffebcd"],
-  ["blue", "#0000ff"],
-  ["blueviolet", "#8a2be2"],
-  ["brown", "#a52a2a"],
-  ["burlywood", "#deb887"],
-  ["cadetblue", "#5f9ea0"],
-  ["chartreuse", "#7fff00"],
-  ["chocolate", "#d2691e"],
-  ["coral", "#ff7f50"],
-  ["cornflowerblue", "#6495ed"],
-  ["cornsilk", "#fff8dc"],
-  ["crimson", "#dc143c"],
-  ["cyan", "#00ffff"],
-  ["darkblue", "#00008b"],
-  ["darkcyan", "#008b8b"],
-  ["darkgoldenrod", "#b8860b"],
-  ["darkgray", "#a9a9a9"],
-  ["darkgreen", "#006400"],
-  ["darkgrey", "#a9a9a9"],
-  ["darkkhaki", "#bdb76b"],
-  ["darkmagenta", "#8b008b"],
-  ["darkolivegreen", "#556b2f"],
-  ["darkorange", "#ff8c00"],
-  ["darkorchid", "#9932cc"],
-  ["darkred", "#8b0000"],
-  ["darksalmon", "#e9967a"],
-  ["darkseagreen", "#8fbc8f"],
-  ["darkslateblue", "#483d8b"],
-  ["darkslategray", "#2f4f4f"],
-  ["darkslategrey", "#2f4f4f"],
-  ["darkturquoise", "#00ced1"],
-  ["darkviolet", "#9400d3"],
-  ["deeppink", "#ff1493"],
-  ["deepskyblue", "#00bfff"],
-  ["dimgray", "#696969"],
-  ["dimgrey", "#696969"],
-  ["dodgerblue", "#1e90ff"],
-  ["firebrick", "#b22222"],
-  ["floralwhite", "#fffaf0"],
-  ["forestgreen", "#228b22"],
-  ["fuchsia", "#ff00ff"],
-  ["gainsboro", "#dcdcdc"],
-  ["ghostwhite", "#f8f8ff"],
-  ["gold", "#ffd700"],
-  ["goldenrod", "#daa520"],
-  ["gray", "#808080"],
-  ["green", "#008000"],
-  ["greenyellow", "#adff2f"],
-  ["grey", "#808080"],
-  ["honeydew", "#f0fff0"],
-  ["hotpink", "#ff69b4"],
-  ["indianred", "#cd5c5c"],
-  ["indigo", "#4b0082"],
-  ["ivory", "#fffff0"],
-  ["khaki", "#f0e68c"],
-  ["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"],
-  ["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"],
-  ["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"],
-  ["transparent", "#00000000"],
-  ["turquoise", "#40e0d0"],
-  ["violet", "#ee82ee"],
-  ["wheat", "#f5deb3"],
-  ["white", "#ffffff"],
-  ["whitesmoke", "#f5f5f5"],
-  ["yellow", "#ffff00"],
-  ["yellowgreen", "#9acd32"]
-]);
+	const rgb = convertHextoRGB(hex);
+	if (!rgb) return null;
+	if (rgb.A) return `rgba(${rgb.R},${rgb.G},${rgb.B},${rgb.A})`;
+	return `rgb(${rgb.R},${rgb.G},${rgb.B})`;
+}
+//#endregion
+//#region src/convertHextoNamedCSSColour.ts
+/**
+* Converts a hexadecimal colour value to a named CSS colour.
+*
+* @param {string} colour - The hexadecimal colour value to convert.
+* @returns {NamedCSSColour | undefined} The named CSS colour that corresponds to the given hexadecimal colour value, or undefined if no named CSS colour matches the given value.
+*/
 function convertHextoNamedCSSColour(colour) {
-  for (const [name, hex] of namedCSSColours.entries()) {
-    if (hex === colour) {
-      return name;
-    }
-  }
-  return void 0;
+	for (const [name, hex] of namedCSSColours.entries()) if (hex === colour) return name;
 }
+//#endregion
+//#region src/convertNamedCSSColourtoHex.ts
+/**
+* Converts a named CSS Colour in an hexadecimal one.
+*
+* List of colours sourced here:
+* https://developer.mozilla.org/en-US/docs/Web/CSS/named-color
+* @param {NamedCSSColour} name - A named CSS colour
+* @returns {string} - An hexadecimal string
+*/
 function convertNamedCSSColourtoHex(name) {
-  return namedCSSColours.get(name);
+	return namedCSSColours.get(name);
 }
+//#endregion
+//#region src/convertNamedCSSColourtoRGB.ts
+/**
+* Converts a named CSS colour to an RGB colour object.
+*
+* @param {NamedCSSColour} colour - The named CSS colour to convert.
+* @returns {RGBColour | undefined} An RGB colour object representing the named CSS colour, or undefined if the named CSS colour is not recognized.
+*/
 function convertNamedCSSColourtoRGB(colour) {
-  const hex = convertNamedCSSColourtoHex(colour);
-  if (!hex) {
-    return void 0;
-  }
-  return convertHextoRGB(hex);
+	const hex = convertNamedCSSColourtoHex(colour);
+	if (!hex) return;
+	return convertHextoRGB(hex) || void 0;
 }
+//#endregion
+//#region src/convertRGBtoCSSRGB.ts
+/**
+* Converts an RGB colour object to a CSS RGB colour string.
+*
+* @param {RGBColour} colour - The RGB colour object to convert.
+* @returns {string} The CSS RGB colour string in the format `rgb(R G B)` or `rgb(R G B / A)` if the alpha channel is present.
+*/
 function convertRGBtoCSSRGB({ R, G, B, A }) {
-  return `rgb(${R} ${G} ${B}${A ? ` / ${A}` : ""})`;
-}
-function convertRGBtoNamedCSSColour(colour) {
-  const hex = convertRGBtoHex(colour);
-  return convertHextoNamedCSSColour(hex);
+	return `rgb(${R} ${G} ${B}${A ? ` / ${A}` : ""})`;
 }
-function findNearestRGBColour(colour, palette) {
-  if (!palette || palette.length < 2) {
-    return colour;
-  }
-  const map = [];
-  for (const paletteColour of palette) {
-    const distance = RGBdistance(colour, paletteColour);
-    map.push([paletteColour, distance]);
-  }
-  const closest = map.sort((a, b) => a[1] - b[1]);
-  return closest[0][0];
+//#endregion
+//#region src/convertRGBtoXYZ.ts
+/**
+* Converts sRGB colour space to XYZ.
+* Math comes from https://en.wikipedia.org/wiki/SRGB#The_reverse_transformation
+* @param {RGBColour} colour sRGB colour
+* @return {XYZColour} XYZ colour
+*/
+function convertRGBtoXYZ(colour) {
+	const { R, G, B } = colour;
+	const _R = linearRGB(R) * 100;
+	const _G = linearRGB(G) * 100;
+	const _B = linearRGB(B) * 100;
+	return {
+		X: _R * .4124 + _G * .3576 + _B * .1805,
+		Y: _R * .2126 + _G * .7152 + _B * .0722,
+		Z: _R * .0193 + _G * .1192 + _B * .9505
+	};
 }
-function findNearestCSSRGBColour(colour, palette) {
-  if (!palette || palette.length < 2) {
-    return colour;
-  }
-  const baseRGBColour = convertCSSRGBtoRGB(colour);
-  const paletteRGBColours = palette.map(
-    (hexColour) => convertCSSRGBtoRGB(hexColour)
-  );
-  const nearestRGBColour = findNearestRGBColour(
-    baseRGBColour,
-    paletteRGBColours
-  );
-  return convertRGBtoCSSRGB(nearestRGBColour);
+//#endregion
+//#region src/convertXYZtoLab.ts
+/**
+* Converts XYZ colour space to Lab
+* Math comes from https://en.wikipedia.org/wiki/CIELAB_color_space#From_CIEXYZ_to_CIELAB[11]
+* @param colour XYZ colour
+* @return {LabColour} Lab colour
+*/
+function convertXYZtoLab(colour) {
+	const { X, Y, Z } = colour;
+	const _X = X / 95.047;
+	const _Y = Y / 100;
+	const _Z = Z / 108.883;
+	const fX = constrainLab(_X);
+	const fY = constrainLab(_Y);
+	const fZ = constrainLab(_Z);
+	return {
+		L: 116 * fY - 16,
+		a: 500 * (fX - fY),
+		b: 200 * (fY - fZ)
+	};
 }
-function isCSSRGBColour(colour) {
-  return !!colour.match(cssRGBARegex);
+//#endregion
+//#region src/convertRGBtoLab.ts
+/**
+* Indirectly converts RGB to Lab.
+* First converts RGB to XYZ, then converts XYZ to Lab.
+* @param {RGBColour} colour sRGB colour
+* @return {LabColour} Lab colour
+*/
+function convertRGBtoLab(colour) {
+	return convertXYZtoLab(convertRGBtoXYZ(colour));
 }
-function isHexColour(colour) {
-  return !!colour.match(hexRegex) || !!colour.match(hexAlphaRegex) || !!colour.match(shortAlphaHexRegex) || !!colour.match(shortHexRegex);
+//#endregion
+//#region src/convertRGBtoNamedCSSColour.ts
+/**
+* Converts an RGB colour object to a named CSS colour.
+*
+* @param {RGBColour} colour - The RGB colour object to convert.
+* @returns {NamedCSSColour | undefined} The named CSS colour that corresponds to the given RGB colour, or undefined if no named CSS colour matches the given colour.
+*/
+function convertRGBtoNamedCSSColour(colour) {
+	return convertHextoNamedCSSColour(convertRGBtoHex(colour));
 }
-function isNamedCSSColour(colour) {
-  return namedCSSColours.has(colour);
+//#endregion
+//#region src/RGBdistance.ts
+/**
+* Calculate the distance between two RGB colours using the CIEDE2000 colour-difference formula.
+*
+* The CIEDE2000 colour-difference formula is a standard method for calculating the perceptual difference
+* between two colours in the CIELAB colour space. It takes into account human visual perception and the
+* non-linearities in how we perceive colour differences.
+*
+* @param colour1 - The first colour to compare.
+* @param colour2 - The second colour to compare.
+* @returns The distance between the two colours. Smaller numbers (minimum 0) mean the colours are more similar,
+* larger numbers (typically not exceeding 100 for visible colours) indicate more dissimilar colours.
+*/
+var RGBdistance = (colour1, colour2) => {
+	return ciede2000(convertRGBtoLab(colour1), convertRGBtoLab(colour2));
+};
+//#endregion
+//#region src/findNearestRGBColour.ts
+/**
+* Finds the nearest RGB colour in a palette to the given RGB colour.
+*
+* @param {RGBColour} colour - The RGB colour to find the nearest match for.
+* @param {RGBColour[]} palette - An array of RGB colours to search for the nearest match in.
+* @returns {RGBColour} The RGB colour in the palette that is closest to the given colour.
+* If the palette has fewer than 2 colours, or if it is undefined or null, the original colour is returned.
+*/
+function findNearestRGBColour(colour, palette) {
+	if (!palette || palette.length < 2) return colour;
+	let nearest = colour;
+	let minDistance = Number.POSITIVE_INFINITY;
+	for (const paletteColour of palette) {
+		const distance = RGBdistance(colour, paletteColour);
+		if (distance < minDistance) {
+			minDistance = distance;
+			nearest = paletteColour;
+		}
+	}
+	return nearest;
 }
+//#endregion
+//#region src/findNearestColour.ts
+/**
+* Finds the nearest colour in a palette to a given colour.
+*
+* @param {string | NamedCSSColour} colour - The colour to match. It can be a hexadecimal colour, a CSS RGB colour, or a named CSS colour.
+* @param {string[] | NamedCSSColour[]} palette - The palette of colours to search.
+* @returns {string} The nearest colour in the palette to the given colour.
+*/
 function findNearestColour(colour, palette) {
-  if (!palette || palette.length < 2) {
-    return colour;
-  }
-  let baseColour;
-  let colourType;
-  const paletteRGB = [];
-  if (isHexColour(colour)) {
-    baseColour = convertHextoRGB(colour);
-    colourType = "hex";
-  }
-  if (isCSSRGBColour(colour)) {
-    baseColour = convertCSSRGBtoRGB(colour);
-    colourType = "cssRGB";
-  }
-  if (isNamedCSSColour(colour)) {
-    baseColour = convertNamedCSSColourtoRGB(colour);
-    colourType = "namedCSS";
-  }
-  if (!baseColour) {
-    return void 0;
-  }
-  for (const paletteColour of palette) {
-    if (isHexColour(paletteColour)) {
-      paletteRGB.push(convertHextoRGB(paletteColour));
-    }
-    if (isCSSRGBColour(paletteColour)) {
-      paletteRGB.push(convertCSSRGBtoRGB(paletteColour));
-    }
-    if (isNamedCSSColour(paletteColour)) {
-      paletteRGB.push(convertNamedCSSColourtoRGB(paletteColour));
-    }
-  }
-  if (paletteRGB.length < 2) {
-    return colour;
-  }
-  const nearest = findNearestRGBColour(baseColour, paletteRGB);
-  if (colourType === "hex") {
-    return convertRGBtoHex(nearest);
-  }
-  if (colourType === "cssRGB") {
-    return convertRGBtoCSSRGB(nearest);
-  }
-  return convertRGBtoNamedCSSColour(nearest);
+	if (!palette || palette.length < 2) return colour;
+	let baseColour;
+	let colourType;
+	const paletteRGB = [];
+	if (isHexColour(colour)) {
+		baseColour = convertHextoRGB(colour);
+		colourType = "hex";
+	} else if (isCSSRGBColour(colour)) {
+		baseColour = convertCSSRGBtoRGB(colour);
+		colourType = "cssRGB";
+	} else if (isNamedCSSColour(colour)) {
+		baseColour = convertNamedCSSColourtoRGB(colour);
+		colourType = "namedCSS";
+	}
+	if (!baseColour) return;
+	for (const paletteColour of palette) if (isHexColour(paletteColour)) {
+		const rgb = convertHextoRGB(paletteColour);
+		if (rgb) paletteRGB.push(rgb);
+	} else if (isCSSRGBColour(paletteColour)) paletteRGB.push(convertCSSRGBtoRGB(paletteColour));
+	else if (isNamedCSSColour(paletteColour)) {
+		const rgb = convertNamedCSSColourtoRGB(paletteColour);
+		if (rgb) paletteRGB.push(rgb);
+	}
+	if (paletteRGB.length < 2) return colour;
+	const nearest = findNearestRGBColour(baseColour, paletteRGB);
+	if (colourType === "hex") return convertRGBtoHex(nearest);
+	if (colourType === "cssRGB") return convertRGBtoCSSRGB(nearest);
+	return convertRGBtoNamedCSSColour(nearest);
+}
+//#endregion
+//#region src/findNearestCSSRGBColour.ts
+/**
+* Finds the nearest CSS RGB colour in a palette to a given CSS RGB colour.
+*
+* @param {string} colour - The CSS RGB colour to find the nearest match for. Alpha channel is ignored.
+* @param {string[]} palette - An array of CSS RGB colours to search for the nearest match.
+* @returns {string} The CSS RGB colour in the palette that is closest to the given colour.
+* If the palette has fewer than 2 colours, or if it is undefined or null, the original colour is returned.
+* The CSS RGB colour string is in the format `rgb(R G B)`.
+*/
+function findNearestCSSRGBColour(colour, palette) {
+	if (!palette || palette.length < 2) return colour;
+	return convertRGBtoCSSRGB(findNearestRGBColour(convertCSSRGBtoRGB(colour), palette.map((hexColour) => convertCSSRGBtoRGB(hexColour))));
 }
+//#endregion
+//#region src/findNearestHexColour.ts
+/**
+* Finds the nearest hexadecimal colour in a palette to the given hex colour.
+*
+* @param {string} colour - The hexadecimal colour to find the nearest match for.
+* @param {string[]} palette - An array of hexadecimal colours to search for the nearest match in.
+* @returns {string} The hexadecimal colour in the palette that is closest to the given colour.
+* If the palette has fewer than 2 colours, or if it is undefined or null, the original colour is returned.
+*/
 function findNearestHexColour(colour, palette) {
-  if (!palette || palette.length < 2) {
-    return colour;
-  }
-  const baseRGBColour = convertHextoRGB(colour);
-  const paletteRGBColours = palette.map(
-    (hexColour) => convertHextoRGB(hexColour)
-  );
-  const nearestRGBColour = findNearestRGBColour(
-    baseRGBColour,
-    paletteRGBColours
-  );
-  return convertRGBtoHex(nearestRGBColour);
+	if (!palette || palette.length < 2) return colour;
+	const baseRGBColour = convertHextoRGB(colour);
+	if (!baseRGBColour) return colour;
+	return convertRGBtoHex(findNearestRGBColour(baseRGBColour, palette.map((hexColour) => convertHextoRGB(hexColour)).filter((rgb) => rgb !== null)));
 }
+//#endregion
+//#region src/findNearestNamedCSSColour.ts
 function findNearestNamedCSSColour(colour, palette) {
-  if (!palette || palette.length < 2) {
-    return colour;
-  }
-  const baseRGBColour = convertNamedCSSColourtoRGB(colour);
-  const paletteRGBColours = palette.map(
-    (hexColour) => convertNamedCSSColourtoRGB(hexColour)
-  );
-  const filteredPaletteRGBColours = paletteRGBColours.filter(
-    (paletteRGBColour) => paletteRGBColour !== void 0
-  );
-  if (!baseRGBColour || filteredPaletteRGBColours.length < 2) {
-    return colour;
-  }
-  const nearestRGBColour = findNearestRGBColour(
-    baseRGBColour,
-    filteredPaletteRGBColours
-  );
-  return convertRGBtoNamedCSSColour(nearestRGBColour);
+	if (!palette || palette.length < 2) return colour;
+	const baseRGBColour = convertNamedCSSColourtoRGB(colour);
+	const filteredPaletteRGBColours = palette.map((hexColour) => convertNamedCSSColourtoRGB(hexColour)).filter((paletteRGBColour) => paletteRGBColour !== void 0);
+	if (!baseRGBColour || filteredPaletteRGBColours.length < 2) return colour;
+	return convertRGBtoNamedCSSColour(findNearestRGBColour(baseRGBColour, filteredPaletteRGBColours));
 }
+//#endregion
+//#region src/getSRGBLuminanceFromRGB.ts
+/**
+* Returns the relative luminance of a colour in the sRGB space.
+*
+* The calculations are compatible with WCAG 3.0 as it aligns with the sRGB spec
+* and difference to WCAG 2.1 is minimal in a 8 bit channel.
+*
+* https://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef
+*
+* https://www.w3.org/WAI/GL/wiki/Relative_luminance
+* @param colour an hexadecimal colour
+*/
 function getSRGBLuminanceFromRGB({ R, G, B }, standard) {
-  const isWCAG21 = standard === "WCAG2.1";
-  const r = linearRGB(R, isWCAG21);
-  const g = linearRGB(G, isWCAG21);
-  const b = linearRGB(B, isWCAG21);
-  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+	const isWCAG21 = standard === "WCAG2.1";
+	const r = linearRGB(R, isWCAG21);
+	const g = linearRGB(G, isWCAG21);
+	const b = linearRGB(B, isWCAG21);
+	return .2126 * r + .7152 * g + .0722 * b;
 }
+//#endregion
+//#region src/getSRGBLuminanceFromHex.ts
+/**
+* Returns the relative luminance of a colour in the sRGB space.
+*
+* The calculations are compatible with WCAG 3.0 as it aligns with the sRGB spec
+* and difference to WCAG 2.1 is minimal in a 8 bit channel.
+*
+* https://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef
+*
+* https://www.w3.org/WAI/GL/wiki/Relative_luminance
+* @param colour an hexadecimal colour
+*/
 function getSRGBLuminanceFromHex(colour, standard) {
-  const rgbColor = convertHextoRGB(colour);
-  return getSRGBLuminanceFromRGB(rgbColor, standard);
+	const rgbColor = convertHextoRGB(colour);
+	if (!rgbColor) return null;
+	return getSRGBLuminanceFromRGB(rgbColor, standard);
 }
+//#endregion
+//#region src/util/calculateContrastRatio.ts
+/**
+* Calculate the contrast ratio between two colours
+* @param luminance1 The luminance of the first colour
+* @param luminance2 The luminance of the second colour
+* @returns The contrast ratio between the two colours truncated to 3 decimal places
+*/
 function calculateContrastRatio(luminance1, luminance2) {
-  const lighter = Math.max(luminance1, luminance2);
-  const darker = Math.min(luminance1, luminance2);
-  const ratio = (lighter + 0.05) / (darker + 0.05);
-  return Math.floor(ratio * 1e3) / 1e3;
+	const lighter = Math.max(luminance1, luminance2);
+	const darker = Math.min(luminance1, luminance2);
+	const ratio = (lighter + .05) / (darker + .05);
+	return Math.floor(ratio * 1e3) / 1e3;
 }
+//#endregion
+//#region src/getContrastRatioFromHex.ts
+/**
+* Calculates the contrast ratio between two colours in hexadecimal format.
+* @param colour1 The first colour in hexadecimal format
+* @param colour2 The second colour in hexadecimal format
+* @param standard The standard to evaluate the contrast ratio against, defaults to WCAG2.1
+* @returns The contrast ratio between the two colours truncated to 3 decimal places
+*/
 function getContrastRatioFromHex(colour1, colour2, standard) {
-  const luminance1 = getSRGBLuminanceFromHex(colour1, standard);
-  const luminance2 = getSRGBLuminanceFromHex(colour2, standard);
-  return calculateContrastRatio(luminance1, luminance2);
+	const luminance1 = getSRGBLuminanceFromHex(colour1, standard);
+	const luminance2 = getSRGBLuminanceFromHex(colour2, standard);
+	if (luminance1 === null || luminance2 === null) return null;
+	return calculateContrastRatio(luminance1, luminance2);
 }
+//#endregion
+//#region src/getContrastRatio.ts
+/**
+* Calculates the contrast ratio between two colours.
+* Accepts CSS RGB colours (including percentage values), named CSS colours, or hexadecimal colours.
+* @param colour1 The first colour (e.g., `#ff0000`, `rgb(255,0,0)`, `rgb(100%, 0%, 0%)`, or `red`)
+* @param colour2 The second colour (e.g., `#00ff00`, `rgb(0,255,0)`, `rgb(0%, 100%, 0%)`, or `lime`)
+* @param standard The standard to evaluate the contrast ratio against, defaults to WCAG2.1
+* @returns The contrast ratio between the two colours truncated to 3 decimal places
+*/
 function getContrastRatio(colour1, colour2, standard) {
-  let hexColour1;
-  let hexColour2;
-  if (colour1.startsWith("#")) {
-    hexColour1 = colour1;
-  } else if (colour1.startsWith("rgb")) {
-    hexColour1 = convertCSSRGBtoHex(colour1);
-  } else {
-    const _hexColour1 = convertNamedCSSColourtoHex(colour1);
-    if (_hexColour1 === void 0) {
-      throw new Error(
-        `getContrastRatio expects valid CSS named colours.
-					${colour1} is not a valid CSS named colour.
-					See https://developer.mozilla.org/en-US/docs/Web/CSS/named-color`
-      );
-    }
-    hexColour1 = _hexColour1;
-  }
-  if (colour2.startsWith("#")) {
-    hexColour2 = colour2;
-  } else if (colour2.startsWith("rgb")) {
-    hexColour2 = convertCSSRGBtoHex(colour2);
-  } else {
-    const _hexColour2 = convertNamedCSSColourtoHex(colour2);
-    if (_hexColour2 === void 0) {
-      throw new Error(`getContrastRatio expects valid CSS named colours.
-					${colour2} is not a valid CSS named colour.
-					See https://developer.mozilla.org/en-US/docs/Web/CSS/named-color`);
-    }
-    hexColour2 = _hexColour2;
-  }
-  return getContrastRatioFromHex(hexColour1, hexColour2, standard);
+	let hexColour1;
+	let hexColour2;
+	if (colour1.startsWith("#")) hexColour1 = colour1;
+	else if (colour1.startsWith("rgb")) hexColour1 = convertCSSRGBtoHex(colour1);
+	else {
+		const _hexColour1 = convertNamedCSSColourtoHex(colour1);
+		if (_hexColour1 === void 0) throw new Error(`getContrastRatio expects valid CSS named colours. ${colour1} is not a valid CSS named colour. See ${NAMED_CSS_COLOUR_URL}`);
+		hexColour1 = _hexColour1;
+	}
+	if (colour2.startsWith("#")) hexColour2 = colour2;
+	else if (colour2.startsWith("rgb")) hexColour2 = convertCSSRGBtoHex(colour2);
+	else {
+		const _hexColour2 = convertNamedCSSColourtoHex(colour2);
+		if (_hexColour2 === void 0) throw new Error(`getContrastRatio expects valid CSS named colours. ${colour2} is not a valid CSS named colour. See ${NAMED_CSS_COLOUR_URL}`);
+		hexColour2 = _hexColour2;
+	}
+	const result = getContrastRatioFromHex(hexColour1, hexColour2, standard);
+	if (result === null) throw new Error(`getContrastRatio expects valid hexadecimal colours but received ${hexColour1} or ${hexColour2}.`);
+	return result;
 }
+//#endregion
+//#region src/getContrastRatioFromCSSRGB.ts
+/**
+* Calculates the contrast ratio between two colours in CSSRGB format.
+* @param colour1 The first colour in CSSRGB format
+* @param colour2 The second colour in CSSRGB format
+* @param standard The standard to evaluate the contrast ratio against, defaults to WCAG2.1
+* @returns The contrast ratio between the two colours truncated to 3 decimal places
+*/
 function getContrastRatioFromCSSRGB(colour1, colour2, standard) {
-  const rgbColour1 = convertCSSRGBtoRGB(colour1);
-  const rgbColour2 = convertCSSRGBtoRGB(colour2);
-  const luminance1 = getSRGBLuminanceFromRGB(rgbColour1, standard);
-  const luminance2 = getSRGBLuminanceFromRGB(rgbColour2, standard);
-  return calculateContrastRatio(luminance1, luminance2);
+	const rgbColour1 = convertCSSRGBtoRGB(colour1);
+	const rgbColour2 = convertCSSRGBtoRGB(colour2);
+	return calculateContrastRatio(getSRGBLuminanceFromRGB(rgbColour1, standard), getSRGBLuminanceFromRGB(rgbColour2, standard));
 }
+//#endregion
+//#region src/getContrastRatioFromNamedCSSColour.ts
+/**
+* Calculates the contrast ratio between two named CSS colours in.
+*
+* See list here https://developer.mozilla.org/en-US/docs/Web/CSS/named-color
+* @param colour1 The first named CSS colour
+* @param colour2 The second named CSS colour
+* @param standard The standard to evaluate the contrast ratio against, defaults to WCAG2.1
+* @returns The contrast ratio between the two colours truncated to 3 decimal places
+*/
 function getContrastRatioFromNamedCSSColour(colour1, colour2, standard) {
-  const hexColour1 = convertNamedCSSColourtoHex(colour1);
-  const hexColour2 = convertNamedCSSColourtoHex(colour2);
-  if (hexColour1 === void 0 || hexColour2 === void 0) {
-    throw new Error(
-      `getContrastRatioFromNamedCSSColour expects valid CSS named colours.
-			${colour1} or ${colour2} are not valid CSS named colours.
-			See https://developer.mozilla.org/en-US/docs/Web/CSS/named-color`
-    );
-  }
-  return getContrastRatioFromHex(hexColour1, hexColour2, standard);
+	const hexColour1 = convertNamedCSSColourtoHex(colour1);
+	const hexColour2 = convertNamedCSSColourtoHex(colour2);
+	if (hexColour1 === void 0 || hexColour2 === void 0) throw new Error(`getContrastRatioFromNamedCSSColour expects valid CSS named colours. ${colour1} or ${colour2} are not valid CSS named colours. See ${NAMED_CSS_COLOUR_URL}`);
+	return getContrastRatioFromHex(hexColour1, hexColour2, standard);
 }
+//#endregion
+//#region src/isHexDarkColour.ts
+/**
+* Evaluates if a colour is dark by measuring the contrast ratio against black and white
+* @param {string} colour - A colour in the hexadecimal format
+* @param {"WCAG2.1" | "WCAG3.0"} standard - Evaluate agains "WCAG2.1" or "WCAG3.0"
+* @returns {boolean} Returns either `true` or `false`
+*/
 function isHexDarkColour(colour, standard) {
-  const colourLuminance = getSRGBLuminanceFromHex(colour, standard) + 0.05;
-  const whiteContrast = 1.05 / colourLuminance;
-  const blackContrast = colourLuminance / 0.05;
-  return whiteContrast > blackContrast;
+	const lum = getSRGBLuminanceFromHex(colour, standard);
+	if (lum === null) return false;
+	const colourLuminance = lum + .05;
+	return 1.05 / colourLuminance > colourLuminance / .05;
 }
+//#endregion
+//#region src/isCSSNameDarkColour.ts
+/**
+* Evaluates if a named CSS colour is dark by measuring the contrast ratio against black and white
+* @param {string} name - A named CSS colour, ie: `hotpink`
+* @param {"WCAG2.1" | "WCAG3.0"} standard - Evaluate agains "WCAG2.1" or "WCAG3.0"
+* @returns { boolean } Returns `true`, `false` or `undefined` if name is not a valid CSS named colour
+*/
 function isCSSNamedDarkColour(name, standard) {
-  const hex = convertNamedCSSColourtoHex(name);
-  if (hex) {
-    return isHexDarkColour(hex, standard);
-  }
-  throw new Error(
-    `${name} is not a valid colour format. isCSSNamedDarkColour only accepts CSS named colours. Check more details here https://developer.mozilla.org/en-US/docs/Web/CSS/named-color`
-  );
+	const hex = convertNamedCSSColourtoHex(name);
+	if (hex) return isHexDarkColour(hex, standard);
+	throw new Error(`${name} is not a valid colour format. isCSSNamedDarkColour only accepts CSS named colours. See ${NAMED_CSS_COLOUR_URL}`);
 }
+//#endregion
+//#region src/isCSSRGBDarkColour.ts
 function isCSSRGBDarkColour(colour, standard) {
-  const rgb = convertCSSRGBtoRGB(colour);
-  const colourLuminance = getSRGBLuminanceFromRGB(rgb, standard);
-  const whiteContrast = 1.05 / colourLuminance;
-  const blackContrast = colourLuminance / 0.05;
-  return whiteContrast > blackContrast;
+	const colourLuminance = getSRGBLuminanceFromRGB(convertCSSRGBtoRGB(colour), standard);
+	return 1.05 / colourLuminance > colourLuminance / .05;
 }
+//#endregion
+//#region src/isDarkColour.ts
+/**
+* Evaluates if a colour is dark by measuring the contrast ratio against black and white.
+* It accepts CSS RGB colours (including percentage values), named CSS or hexadecimal.
+*
+* If you know in advance the type of colour you want to evaluate consider using `isCSSNamedDarkColour`, `isCSSRGBDarkColour` or `isHexDarkColour` as they are smaller functions
+* @param {string | NamedCSSColour} colour - A colour value, ie: `hotpink`, `#333222`, `rgb(12,34,45)`, or `rgb(50%, 25%, 100%)`
+* @param {"WCAG2.1" | "WCAG3.0"} standard - Evaluate agains "WCAG2.1" or "WCAG3.0"
+* @returns {boolean} Returns `true`, `false` or `undefined` if name is not a valid CSS named colour
+*/
 function isDarkColour(colour, standard) {
-  try {
-    if (colour.startsWith("#")) {
-      return isHexDarkColour(colour, standard);
-    }
-    if (colour.startsWith("rgb")) {
-      return isCSSRGBDarkColour(colour, standard);
-    }
-    return isCSSNamedDarkColour(colour, standard);
-  } catch (error) {
-    throw new Error(
-      `${colour} is not a valid colour format. isDarkColour accepts CSS RGB formats, ie rgb(0,0,0) and rgba(255, 255, 255, 0.4), hexadecimal and CSS named colours.`
-    );
-  }
-}
-const relativeContrast = (firstColour, secondColour) => {
-  if (firstColour > secondColour) {
-    return firstColour / secondColour;
-  }
-  return secondColour / firstColour;
+	try {
+		if (colour.startsWith("#")) return isHexDarkColour(colour, standard);
+		if (colour.startsWith("rgb")) return isCSSRGBDarkColour(colour, standard);
+		return isCSSNamedDarkColour(colour, standard);
+	} catch (_error) {
+		throw new Error(`${colour} is not a valid colour format. isDarkColour accepts CSS RGB formats, ie rgb(0,0,0), rgba(255, 255, 255, 0.4), rgb(50%, 25%, 100%), and rgba(50%, 25%, 100%, 80%), hexadecimal and CSS named colours.`);
+	}
+}
+//#endregion
+//#region src/pickHexColourContrast.ts
+var relativeContrast = (firstColour, secondColour) => {
+	if (firstColour > secondColour) return firstColour / secondColour;
+	return secondColour / firstColour;
 };
-const pickHexColourContrast = ({ backgroundColour, optionOneColour, optionTwoColour }, standard) => {
-  const backgroundColourLuminance = getSRGBLuminanceFromHex(backgroundColour, standard) + 0.05;
-  const optionOneColourLuminance = getSRGBLuminanceFromHex(optionOneColour, standard) + 0.05;
-  const optionTwoColourLuminance = getSRGBLuminanceFromHex(optionTwoColour, standard) + 0.05;
-  const optionOneContrast = relativeContrast(
-    optionOneColourLuminance,
-    backgroundColourLuminance
-  );
-  const optionTwoContrast = relativeContrast(
-    optionTwoColourLuminance,
-    backgroundColourLuminance
-  );
-  if (optionOneContrast > optionTwoContrast) {
-    return optionOneColour;
-  }
-  return optionTwoColour;
+var pickHexColourContrast = ({ backgroundColour, optionOneColour, optionTwoColour }, standard) => {
+	const bgLum = getSRGBLuminanceFromHex(backgroundColour, standard);
+	const opt1Lum = getSRGBLuminanceFromHex(optionOneColour, standard);
+	const opt2Lum = getSRGBLuminanceFromHex(optionTwoColour, standard);
+	if (bgLum === null || opt1Lum === null || opt2Lum === null) return null;
+	const backgroundColourLuminance = bgLum + .05;
+	const optionOneColourLuminance = opt1Lum + .05;
+	const optionTwoColourLuminance = opt2Lum + .05;
+	if (relativeContrast(optionOneColourLuminance, backgroundColourLuminance) > relativeContrast(optionTwoColourLuminance, backgroundColourLuminance)) return optionOneColour;
+	return optionTwoColour;
 };
+//#endregion
+//#region src/convertRGBtoHSV.ts
+/**
+* Converts an RGB colour to HSV.
+* Conversion formula is based on the RGB to HSV conversion algorithm:
+* https://en.wikipedia.org/wiki/HSL_and_HSV#From_RGB
+*
+* https://www.niwa.nu/2013/05/math-behind-colorspace-conversions-rgb-hsl/
+* - Hue (h) is calculated based on the maximum RGB value.
+* - Saturation (s) is the chroma divided by the maximum RGB value.
+* - Value (v) is the maximum RGB value.
+* @param r Red channel (0-255)
+* @param g Green channel (0-255)
+* @param b Blue channel (0-255)
+* @returns HSVColour object with h (hue), s (saturation), v (value)
+*/
+function convertRGBtoHSV(r, g, b) {
+	const red = r / 255;
+	const green = g / 255;
+	const blue = b / 255;
+	const max = Math.max(red, green, blue);
+	const min = Math.min(red, green, blue);
+	let hue = 0;
+	let saturation = 0;
+	const value = max;
+	const delta = max - min;
+	if (max === 0) saturation = 0;
+	else saturation = delta / max;
+	if (delta !== 0) {
+		if (max === red) hue = (green - blue) / delta % 6;
+		else if (max === green) hue = (blue - red) / delta + 2;
+		else if (max === blue) hue = (red - green) / delta + 4;
+		hue = hue * 60;
+		if (hue < 0) hue = hue + 360;
+	}
+	return {
+		h: hue,
+		s: saturation,
+		v: value
+	};
+}
+//#endregion
+//#region src/sortHexColours.ts
+/**
+* Helper to parse hex and get HSV + alpha
+* @param hex Hex color string
+* @returns Object with hue, saturation, value, and alpha
+*/
+function getColorInfo(hex) {
+	const rgb = convertHextoRGB(hex);
+	if (!rgb) return null;
+	const { R, G, B, A } = rgb;
+	const a = typeof A === "number" ? A : 1;
+	const { h, s, v } = convertRGBtoHSV(R, G, B);
+	return {
+		h,
+		s,
+		v,
+		a
+	};
+}
+/**
+* Helper to get custom order for greyscale values
+* @param v HSV value (brightness) from 0 to 1
+* @returns Order priority: 0 for grey/other, 1 for black, 2 for white
+*/
+function getGreyscaleOrder(v) {
+	if (v === 0) return 1;
+	if (v === 1) return 2;
+	return 0;
+}
+/**
+* Sorts an array of hex colours by hue, then by saturation.
+* Colours with 0% saturation (greyscale) are shifted to the end.
+* Fully transparent colours (alpha = 0) are placed at the very end.
+* Accepts hex colours in #RRGGBB or #RRGGBBAA format.
+* @param hexColours Array of hex colour strings
+* @returns Sorted array of hex colour strings
+*/
+function sortHexColours(hexColours) {
+	const cache = /* @__PURE__ */ new Map();
+	for (const hex of hexColours) if (!cache.has(hex)) {
+		const info = getColorInfo(hex);
+		if (info) cache.set(hex, info);
+	}
+	const normal = [];
+	const greyscale = [];
+	const transparent = [];
+	for (const hex of hexColours) {
+		const info = cache.get(hex);
+		if (!info) continue;
+		const { s, a } = info;
+		if (a === 0) transparent.push(hex);
+		else if (s === 0) greyscale.push(hex);
+		else normal.push(hex);
+	}
+	normal.sort((a, b) => {
+		const ca = cache.get(a);
+		const cb = cache.get(b);
+		if (ca.h !== cb.h) return ca.h - cb.h;
+		return cb.s - ca.s;
+	});
+	greyscale.sort((a, b) => {
+		const ca = cache.get(a);
+		const cb = cache.get(b);
+		const orderA = getGreyscaleOrder(ca.v);
+		const orderB = getGreyscaleOrder(cb.v);
+		if (orderA !== orderB) return orderA - orderB;
+		return ca.v - cb.v;
+	});
+	transparent.sort((a, b) => {
+		const ca = cache.get(a);
+		const cb = cache.get(b);
+		return ca.v - cb.v;
+	});
+	return [
+		...normal,
+		...greyscale,
+		...transparent
+	];
+}
+//#endregion
 exports.RGBdistance = RGBdistance;
 exports.ciede2000 = ciede2000;
 exports.convertCSSRGBtoHex = convertCSSRGBtoHex;
@@ -675,3 +1110,4 @@ exports.isHexColour = isHexColour;
 exports.isHexDarkColour = isHexDarkColour;
 exports.isNamedCSSColour = isNamedCSSColour;
 exports.pickHexColourContrast = pickHexColourContrast;
+exports.sortHexColours = sortHexColours;