@sardine/colour 2.1.0-rc.0 → 2.1.0

package/dist/index.mjs

@@ -1,74 +1,172 @@
-function X(e, t) {
-  if (e === 0 && t === 0)
+function hue_d(x, y) {
+  if (x === 0 && y === 0) {
     return 0;
-  const n = Math.atan2(e, t) * (180 / Math.PI);
-  return n >= 0 ? n : n + 360;
-}
-function se({ C1: e, C2: t, h1_d: n, h2_d: r }) {
-  return e * t === 0 ? 0 : Math.abs(r - n) <= 180 ? r - n : r - n > 180 ? r - n - 360 : r - n < -180 ? r - n + 360 : 0;
-}
-function ce({ C1: e, C2: t, h1_d: n, h2_d: r }) {
-  return e * t === 0 ? r + n : Math.abs(n - r) <= 180 ? (r + n) / 2 : Math.abs(n - r) > 180 && n + r < 360 ? (r + n + 360) / 2 : Math.abs(n - r) > 180 && n + r >= 360 ? (r + n - 360) / 2 : 0;
-}
-const u = (e) => e * (Math.PI / 180), Y = (e) => Math.sqrt(e ** 7 / (e ** 7 + 25 ** 7));
-function l(e, t) {
-  const n = e / 255, r = t ? 0.03928 : 0.04045;
-  let o;
-  return n > r ? o = ((n + 0.055) / 1.055) ** 2.4 : o = n / 12.92, o;
-}
-function v(e) {
-  const t = 0.20689655172413793, n = t ** 3;
-  let r;
-  return e > n ? r = Math.cbrt(e) : r = e / (3 * t ** 2) + 4 / 29, r;
+  }
+  const angle = Math.atan2(x, y) * (180 / Math.PI);
+  if (angle >= 0) {
+    return angle;
+  }
+  return angle + 360;
 }
-function ie(e, t, n) {
-  return Math.min(Math.max(e, t), n);
+function deltaHue_d({ C1, C2, h1_d, h2_d }) {
+  if (C1 * C2 === 0) {
+    return 0;
+  }
+  if (Math.abs(h2_d - h1_d) <= 180) {
+    return h2_d - h1_d;
+  }
+  if (h2_d - h1_d > 180) {
+    return h2_d - h1_d - 360;
+  }
+  if (h2_d - h1_d < -180) {
+    return h2_d - h1_d + 360;
+  }
+  return 0;
 }
-function ue(e, t) {
-  const n = e.L, r = e.a, o = e.b, a = t.L, f = t.a, s = t.b, c = 1, i = 1, p = 1, m = Math.sqrt(r ** 2 + o ** 2), g = Math.sqrt(f ** 2 + s ** 2), ee = a - n, te = (m + g) / 2, w = 0.5 * (1 - Y(te)), N = r * (1 + w), M = f * (1 + w), k = Math.sqrt(N ** 2 + o ** 2), B = Math.sqrt(M ** 2 + s ** 2), $ = (k + B) / 2, H = B - k, L = X(o, N), q = X(s, M), ne = se({ C1: m, C2: g, h1_d: L, h2_d: q }), I = 2 * Math.sqrt(k * B) * Math.sin(u(ne) / 2), C = ce({ C1: m, C2: g, h1_d: L, h2_d: q }), A = (n + a) / 2, re = 1 - 0.17 * Math.cos(u(C - 30)) + 0.24 * Math.cos(u(2 * C)) + 0.32 * Math.cos(u(3 * C + 6)) - 0.2 * Math.cos(u(4 * C - 63)), oe = 1 + 0.015 * (A - 50) ** 2 / Math.sqrt(20 + (A - 50) ** 2), E = 0.045 * $ + 1, F = 1 + 0.015 * $ * re, ae = 30 * Math.exp(-(((C - 275) / 25) ** 2)), fe = -2 * Y($) * Math.sin(u(ae * 2));
-  return Math.sqrt(
-    (ee / (c * oe)) ** 2 + (H / (i * E)) ** 2 + (I / (p * F)) ** 2 + fe * (H / (i * E)) * (I / (p * F))
+function meanHue_d({ C1, C2, h1_d, h2_d }) {
+  if (C1 * C2 === 0) {
+    return h2_d + h1_d;
+  }
+  if (Math.abs(h1_d - h2_d) <= 180) {
+    return (h2_d + h1_d) / 2;
+  }
+  if (Math.abs(h1_d - h2_d) > 180 && h1_d + h2_d < 360) {
+    return (h2_d + h1_d + 360) / 2;
+  }
+  if (Math.abs(h1_d - h2_d) > 180 && h1_d + h2_d >= 360) {
+    return (h2_d + h1_d - 360) / 2;
+  }
+  return 0;
+}
+const toRadians = (n) => n * (Math.PI / 180);
+const bigSquare = (n) => Math.sqrt(n ** 7 / (n ** 7 + 25 ** 7));
+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;
+}
+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;
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function ciede2000(colour1, colour2) {
+  const L1 = colour1.L;
+  const a1 = colour1.a;
+  const b1 = colour1.b;
+  const L2 = colour2.L;
+  const a2 = colour2.a;
+  const b2 = colour2.b;
+  const kL = 1;
+  const kC = 1;
+  const kH = 1;
+  const C1 = Math.sqrt(a1 ** 2 + b1 ** 2);
+  const C2 = Math.sqrt(a2 ** 2 + b2 ** 2);
+  const ΔL_d = L2 - L1;
+  const C̅ = (C1 + C2) / 2;
+  const G = 0.5 * (1 - bigSquare(C̅));
+  const a1_d = a1 * (1 + G);
+  const a2_d = a2 * (1 + G);
+  const C1_d = Math.sqrt(a1_d ** 2 + b1 ** 2);
+  const C2_d = Math.sqrt(a2_d ** 2 + b2 ** 2);
+  const C̅_d = (C1_d + C2_d) / 2;
+  const ΔC̅_d = C2_d - C1_d;
+  const h1_d = hue_d(b1, a1_d);
+  const h2_d = hue_d(b2, a2_d);
+  const Δh_d = deltaHue_d({ C1, C2, h1_d, h2_d });
+  const ΔH_d = 2 * Math.sqrt(C1_d * C2_d) * Math.sin(toRadians(Δh_d) / 2);
+  const H̅_d = meanHue_d({ C1, C2, h1_d, h2_d });
+  const L̅ = (L1 + L2) / 2;
+  const T = 1 - 0.17 * Math.cos(toRadians(H̅_d - 30)) + 0.24 * Math.cos(toRadians(2 * H̅_d)) + 0.32 * Math.cos(toRadians(3 * H̅_d + 6)) - 0.2 * Math.cos(toRadians(4 * H̅_d - 63));
+  const SL = 1 + 0.015 * (L̅ - 50) ** 2 / Math.sqrt(20 + (L̅ - 50) ** 2);
+  const SC = 0.045 * C̅_d + 1;
+  const SH = 1 + 0.015 * C̅_d * T;
+  const rotation = 30 * Math.exp(-(((H̅_d - 275) / 25) ** 2));
+  const RT = -2 * bigSquare(C̅_d) * Math.sin(toRadians(rotation * 2));
+  const ΔE = Math.sqrt(
+    (ΔL_d / (kL * SL)) ** 2 + (ΔC̅_d / (kC * SC)) ** 2 + (ΔH_d / (kH * SH)) ** 2 + RT * (ΔC̅_d / (kC * SC)) * (ΔH_d / (kH * SH))
   );
-}
-function le(e) {
-  const { R: t, G: n, B: r } = e, o = l(t) * 100, a = l(n) * 100, f = l(r) * 100, s = o * 0.4124 + a * 0.3576 + f * 0.1805, c = o * 0.2126 + a * 0.7152 + f * 0.0722, i = o * 0.0193 + a * 0.1192 + f * 0.9505;
-  return { X: s, Y: c, Z: i };
-}
-function de(e) {
-  const { X: t, Y: n, Z: r } = e, o = t / 95.047, a = n / 100, f = r / 108.883, s = v(o), c = v(a), i = v(f), p = 116 * c - 16, m = 500 * (s - c), g = 200 * (c - i);
-  return { L: p, a: m, b: g };
-}
-function Z(e) {
-  const t = le(e);
-  return de(t);
-}
-const be = (e, t) => {
-  const n = Z(e), r = Z(t);
-  return ue(n, r);
-}, x = /^#[a-fA-F0-9]{6}$/, z = /^#[a-fA-F0-9]{8}$/, j = /^#[a-fA-F0-9]{3}$/, O = /^#[a-fA-F0-9]{4}$/, U = /^rgba*\(\s*([-+]?\d+)\s*(?:,)?\s*([-+]?\d+)\s*(?:,)?\s*([-+]?\d+)\s*(?:,*|\/*)\s*([-+]?\d*[.]?\d+[%]?)*\)$/i;
-function d(e) {
-  const t = e.match(U);
-  if (!t)
+  return ΔE;
+}
+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 };
+}
+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 convertRGBtoLab(colour) {
+  const XYZColour = convertRGBtoXYZ(colour);
+  return convertXYZtoLab(XYZColour);
+}
+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;
+function convertCSSRGBtoRGB(colour) {
+  const match = colour.match(cssRGBARegex);
+  if (!match) {
     throw new Error(
-      `convertCSSRGBtoHex expects a valid CSS RGB string but got ${e}`
+      `convertCSSRGBtoHex expects a valid CSS RGB string but got ${colour}`
     );
-  const n = (r) => r ? Number.parseFloat(r) : void 0;
+  }
+  const rgbNumber = (n) => n ? Number.parseFloat(n) : void 0;
   return {
-    R: n(t[1]),
-    G: n(t[2]),
-    B: n(t[3]),
-    A: n(t[4])
+    R: rgbNumber(match[1]),
+    G: rgbNumber(match[2]),
+    B: rgbNumber(match[3]),
+    A: rgbNumber(match[4])
   };
 }
-function S({ R: e, G: t, B: n, A: r }) {
-  const o = (a) => ie(a, 0, 255).toString(16).padStart(2, "0");
-  return `#${o(e)}${o(t)}${o(n)}${r ? o(Math.round(r * 255)) : ""}`;
+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)) : ""}`;
 }
-function he(e) {
-  const t = d(e);
-  return S(t);
+function convertCSSRGBtoHex(colour) {
+  const rgb = convertCSSRGBtoRGB(colour);
+  return convertRGBtoHex(rgb);
 }
-const y = /* @__PURE__ */ new Map([
+const namedCSSColours = /* @__PURE__ */ new Map([
   ["aliceblue", "#f0f8ff"],
   ["antiquewhite", "#faebd7"],
   ["aqua", "#00ffff"],
@@ -217,204 +315,283 @@ const y = /* @__PURE__ */ new Map([
   ["yellow", "#ffff00"],
   ["yellowgreen", "#9acd32"]
 ]);
-function me(e) {
-  for (const [t, n] of y.entries())
-    if (n === e)
-      return t;
-}
-function b(e) {
-  if (typeof e != "string")
-    throw new Error(`convertHextoRGB expects a string but got a ${typeof e}`);
-  if (e.match(x))
+function convertHextoNamedCSSColour(colour) {
+  for (const [name, hex] of namedCSSColours.entries()) {
+    if (hex === colour) {
+      return name;
+    }
+  }
+  return void 0;
+}
+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(`${e[1]}${e[2]}`, 16),
-      G: Number.parseInt(`${e[3]}${e[4]}`, 16),
-      B: Number.parseInt(`${e[5]}${e[6]}`, 16)
+      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 (e.match(j))
+  }
+  if (hex.match(shortHexRegex)) {
     return {
-      R: Number.parseInt(`${e[1]}${e[1]}`, 16),
-      G: Number.parseInt(`${e[2]}${e[2]}`, 16),
-      B: Number.parseInt(`${e[3]}${e[3]}`, 16)
+      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 (e.match(z))
+  }
+  if (hex.match(hexAlphaRegex)) {
     return {
-      R: Number.parseInt(`${e[1]}${e[2]}`, 16),
-      G: Number.parseInt(`${e[3]}${e[4]}`, 16),
-      B: Number.parseInt(`${e[5]}${e[6]}`, 16),
-      A: Number.parseInt(`${e[7]}${e[8]}`, 16) / 255
+      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: Number.parseInt(`${hex[7]}${hex[8]}`, 16) / 255
     };
-  if (e.match(O))
+  }
+  if (hex.match(shortAlphaHexRegex)) {
     return {
-      R: Number.parseInt(`${e[1]}${e[1]}`, 16),
-      G: Number.parseInt(`${e[2]}${e[2]}`, 16),
-      B: Number.parseInt(`${e[3]}${e[3]}`, 16),
-      A: Number.parseInt(`${e[4]}${e[4]}`, 16) / 255
+      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: Number.parseInt(`${hex[4]}${hex[4]}`, 16) / 255
     };
+  }
   throw new Error(
-    `convertHextoRGB expects an valid hexadecimal colour value but got ${e}`
+    `convertHextoRGB expects an valid hexadecimal colour value but got ${hex}`
   );
 }
-function V(e) {
-  return y.get(e);
-}
-function R(e) {
-  const t = V(e);
-  if (t)
-    return b(t);
-}
-function J({ R: e, G: t, B: n, A: r }) {
-  return `rgb(${e} ${t} ${n}${r ? ` / ${r}` : ""})`;
-}
-function K(e) {
-  const t = S(e);
-  return me(t);
-}
-function G(e, t) {
-  if (!t || t.length < 2)
-    return e;
-  const n = [];
-  for (const o of t) {
-    const a = be(e, o);
-    n.push([o, a]);
-  }
-  return n.sort((o, a) => o[1] - a[1])[0][0];
-}
-function Re(e, t) {
-  if (!t || t.length < 2)
-    return e;
-  const n = d(e), r = t.map(
-    (a) => d(a)
-  ), o = G(
-    n,
-    r
-  );
-  return J(o);
-}
-function D(e) {
-  return !!e.match(U);
-}
-function W(e) {
-  return !!e.match(x) || !!e.match(z) || !!e.match(O) || !!e.match(j);
-}
-function T(e) {
-  return y.has(e);
-}
-function Se(e, t) {
-  if (!t || t.length < 2)
-    return e;
-  let n, r;
-  const o = [];
-  if (W(e) && (n = b(e), r = "hex"), D(e) && (n = d(e), r = "cssRGB"), T(e) && (n = R(e), r = "namedCSS"), !n)
-    return;
-  for (const f of t)
-    W(f) && o.push(b(f)), D(f) && o.push(d(f)), T(f) && o.push(R(f));
-  if (o.length < 2)
-    return e;
-  const a = G(n, o);
-  if (r === "hex")
-    return S(a);
-  if (r === "cssRGB")
-    return J(a);
-  if (r === "namedCSS")
-    return K(a);
-}
-function Ge(e, t) {
-  if (!t || t.length < 2)
-    return e;
-  const n = b(e), r = t.map(
-    (a) => b(a)
-  ), o = G(
-    n,
-    r
-  );
-  return S(o);
-}
-function ke(e, t) {
-  if (!t || t.length < 2)
-    return e;
-  const n = R(e), o = t.map(
-    (f) => R(f)
-  ).filter(
-    (f) => f !== void 0
+function convertNamedCSSColourtoHex(name) {
+  return namedCSSColours.get(name);
+}
+function convertNamedCSSColourtoRGB(colour) {
+  const hex = convertNamedCSSColourtoHex(colour);
+  if (!hex) {
+    return void 0;
+  }
+  return convertHextoRGB(hex);
+}
+function convertRGBtoCSSRGB({ R, G, B, A }) {
+  return `rgb(${R} ${G} ${B}${A ? ` / ${A}` : ""})`;
+}
+function convertRGBtoNamedCSSColour(colour) {
+  const hex = convertRGBtoHex(colour);
+  return convertHextoNamedCSSColour(hex);
+}
+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];
+}
+function findNearestCSSRGBColour(colour, palette) {
+  if (!palette || palette.length < 2) {
+    return colour;
+  }
+  const baseRGBColour = convertCSSRGBtoRGB(colour);
+  const paletteRGBColours = palette.map(
+    (hexColour) => convertCSSRGBtoRGB(hexColour)
   );
-  if (!n || o.length < 2)
-    return e;
-  const a = G(
-    n,
-    o
+  const nearestRGBColour = findNearestRGBColour(
+    baseRGBColour,
+    paletteRGBColours
   );
-  return K(a);
+  return convertRGBtoCSSRGB(nearestRGBColour);
+}
+function isCSSRGBColour(colour) {
+  return !!colour.match(cssRGBARegex);
 }
-function Q({ R: e, G: t, B: n }, r) {
-  const o = r === "WCAG2.1", a = l(e, o), f = l(t, o), s = l(n, o);
-  return 0.2126 * a + 0.7152 * f + 0.0722 * s;
+function isHexColour(colour) {
+  return !!colour.match(hexRegex) || !!colour.match(hexAlphaRegex) || !!colour.match(shortAlphaHexRegex) || !!colour.match(shortHexRegex);
 }
-function h(e, t) {
-  const n = b(e);
-  return Q(n, t);
+function isNamedCSSColour(colour) {
+  return namedCSSColours.has(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);
+  }
+  if (colourType === "namedCSS") {
+    return convertRGBtoNamedCSSColour(nearest);
+  }
+  return;
 }
-function _(e, t) {
-  const n = h(e, t) + 0.05, r = 1.05 / n, o = n / 0.05;
-  return r > o;
+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);
 }
-function ge(e, t) {
-  const n = V(e);
-  if (n)
-    return _(n, t);
+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);
+}
+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;
+}
+function getSRGBLuminanceFromHex(colour, standard) {
+  const rgbColor = convertHextoRGB(colour);
+  return getSRGBLuminanceFromRGB(rgbColor, standard);
+}
+function isHexDarkColour(colour, standard) {
+  const colourLuminance = getSRGBLuminanceFromHex(colour, standard) + 0.05;
+  const whiteContrast = 1.05 / colourLuminance;
+  const blackContrast = colourLuminance / 0.05;
+  return whiteContrast > blackContrast;
+}
+function isCSSNamedDarkColour(name, standard) {
+  const hex = convertNamedCSSColourtoHex(name);
+  if (hex) {
+    return isHexDarkColour(hex, standard);
+  }
   throw new Error(
-    `${e} 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`
+    `${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`
   );
 }
-function Ce(e, t) {
-  const n = d(e), r = Q(n, t), o = 1.05 / r, a = r / 0.05;
-  return o > a;
+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;
 }
-function Be(e, t) {
+function isDarkColour(colour, standard) {
   try {
-    return e.startsWith("#") ? _(e, t) : e.startsWith("rgb") ? Ce(e, t) : ge(e, t);
-  } catch {
+    if (colour.startsWith("#")) {
+      return isHexDarkColour(colour, standard);
+    }
+    if (colour.startsWith("rgb")) {
+      return isCSSRGBDarkColour(colour, standard);
+    }
+    return isCSSNamedDarkColour(colour, standard);
+  } catch (error) {
     throw new Error(
-      `${e} 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.`
+      `${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 P = (e, t) => e > t ? e / t : t / e, $e = ({ backgroundColour: e, optionOneColour: t, optionTwoColour: n }, r) => {
-  const o = h(e, r) + 0.05, a = h(t, r) + 0.05, f = h(n, r) + 0.05, s = P(
-    a,
-    o
-  ), c = P(
-    f,
-    o
+const 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
   );
-  return s > c ? t : n;
+  const optionTwoContrast = relativeContrast(
+    optionTwoColourLuminance,
+    backgroundColourLuminance
+  );
+  if (optionOneContrast > optionTwoContrast) {
+    return optionOneColour;
+  }
+  return optionTwoColour;
 };
 export {
-  be as RGBdistance,
-  ue as ciede2000,
-  he as convertCSSRGBtoHex,
-  d as convertCSSRGBtoRGB,
-  me as convertHextoNamedCSSColour,
-  b as convertHextoRGB,
-  V as convertNamedCSSColourtoHex,
-  R as convertNamedCSSColourtoRGB,
-  J as convertRGBtoCSSRGB,
-  S as convertRGBtoHex,
-  Z as convertRGBtoLab,
-  K as convertRGBtoNamedCSSColour,
-  le as convertRGBtoXYZ,
-  de as convertXYZtoLab,
-  Re as findNearestCSSRGBColour,
-  Se as findNearestColour,
-  Ge as findNearestHexColour,
-  ke as findNearestNamedCSSColour,
-  G as findNearestRGBColour,
-  h as getSRGBLuminanceFromHex,
-  Q as getSRGBLuminanceFromRGB,
-  ge as isCSSNamedDarkColour,
-  D as isCSSRGBColour,
-  Ce as isCSSRGBDarkColour,
-  Be as isDarkColour,
-  _ as isHexDarkColour,
-  $e as pickHexColourContrast
+  RGBdistance,
+  ciede2000,
+  convertCSSRGBtoHex,
+  convertCSSRGBtoRGB,
+  convertHextoNamedCSSColour,
+  convertHextoRGB,
+  convertNamedCSSColourtoHex,
+  convertNamedCSSColourtoRGB,
+  convertRGBtoCSSRGB,
+  convertRGBtoHex,
+  convertRGBtoLab,
+  convertRGBtoNamedCSSColour,
+  convertRGBtoXYZ,
+  convertXYZtoLab,
+  findNearestCSSRGBColour,
+  findNearestColour,
+  findNearestHexColour,
+  findNearestNamedCSSColour,
+  findNearestRGBColour,
+  getSRGBLuminanceFromHex,
+  getSRGBLuminanceFromRGB,
+  isCSSNamedDarkColour,
+  isCSSRGBColour,
+  isCSSRGBDarkColour,
+  isDarkColour,
+  isHexDarkColour,
+  pickHexColourContrast
 };