@digdir/designsystemet 0.1.0-alpha.14 → 0.1.0-alpha.16

package/dist/src/colors/colorUtils.js

@@ -1,364 +1,322 @@
-// src/colors/colorUtils.ts
 import { Hsluv } from "hsluv";
 import chroma from "chroma-js";
-
-// ../../node_modules/apca-w3/src/apca-w3.js
-var SA98G = {
-  mainTRC: 2.4,
-  // 2.4 exponent for emulating actual monitor perception
-  // For reverseAPCA
-  get mainTRCencode() {
-    return 1 / this.mainTRC;
-  },
-  // sRGB coefficients
-  sRco: 0.2126729,
-  sGco: 0.7151522,
-  sBco: 0.072175,
-  // G-4g constants for use with 2.4 exponent
-  normBG: 0.56,
-  normTXT: 0.57,
-  revTXT: 0.62,
-  revBG: 0.65,
-  // G-4g Clamps and Scalers
-  blkThrs: 0.022,
-  blkClmp: 1.414,
-  scaleBoW: 1.14,
-  scaleWoB: 1.14,
-  loBoWoffset: 0.027,
-  loWoBoffset: 0.027,
-  deltaYmin: 5e-4,
-  loClip: 0.1,
-  ///// MAGIC NUMBERS for UNCLAMP, for use with 0.022 & 1.414 /////
-  // Magic Numbers for reverseAPCA
-  mFactor: 1.9468554433171,
-  get mFactInv() {
-    return 1 / this.mFactor;
-  },
-  mOffsetIn: 0.0387393816571401,
-  mExpAdj: 0.283343396420869,
-  get mExp() {
-    return this.mExpAdj / this.blkClmp;
-  },
-  mOffsetOut: 0.312865795870758
-};
-function APCAcontrast(txtY, bgY, places = -1) {
-  const icp = [0, 1.1];
-  if (isNaN(txtY) || isNaN(bgY) || Math.min(txtY, bgY) < icp[0] || Math.max(txtY, bgY) > icp[1]) {
-    return 0;
-  }
-  ;
-  let SAPC = 0;
-  let outputContrast = 0;
-  let polCat = "BoW";
-  txtY = txtY > SA98G.blkThrs ? txtY : txtY + Math.pow(SA98G.blkThrs - txtY, SA98G.blkClmp);
-  bgY = bgY > SA98G.blkThrs ? bgY : bgY + Math.pow(SA98G.blkThrs - bgY, SA98G.blkClmp);
-  if (Math.abs(bgY - txtY) < SA98G.deltaYmin) {
-    return 0;
-  }
-  if (bgY > txtY) {
-    SAPC = (Math.pow(bgY, SA98G.normBG) - Math.pow(txtY, SA98G.normTXT)) * SA98G.scaleBoW;
-    outputContrast = SAPC < SA98G.loClip ? 0 : SAPC - SA98G.loBoWoffset;
-  } else {
-    polCat = "WoB";
-    SAPC = (Math.pow(bgY, SA98G.revBG) - Math.pow(txtY, SA98G.revTXT)) * SA98G.scaleWoB;
-    outputContrast = SAPC > -SA98G.loClip ? 0 : SAPC + SA98G.loWoBoffset;
-  }
-  if (places < 0) {
-    return outputContrast * 100;
-  } else if (places == 0) {
-    return Math.round(Math.abs(outputContrast) * 100) + "<sub>" + polCat + "</sub>";
-  } else if (Number.isInteger(places)) {
-    return (outputContrast * 100).toFixed(places);
-  } else {
-    return 0;
-  }
-}
-function sRGBtoY(rgb = [0, 0, 0]) {
-  function simpleExp(chan) {
-    return Math.pow(chan / 255, SA98G.mainTRC);
-  }
-  ;
-  return SA98G.sRco * simpleExp(rgb[0]) + SA98G.sGco * simpleExp(rgb[1]) + SA98G.sBco * simpleExp(rgb[2]);
-}
-
-// src/colors/colorUtils.ts
-var hexToCssHsl = (hex, valuesOnly = false) => {
-  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-  let r = 0;
-  let g = 0;
-  let b = 0;
-  let cssString = "";
-  if (result) {
-    r = parseInt(result[1], 16);
-    g = parseInt(result[2], 16);
-    b = parseInt(result[3], 16);
-  }
-  r /= 255, g /= 255, b /= 255;
-  const max = Math.max(r, g, b), min = Math.min(r, g, b);
-  let h, s, l = (max + min) / 2;
-  if (max == min) {
-    h = s = 0;
-  } else {
-    const d = max - min;
-    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
-    switch (max) {
-      case r:
-        h = (g - b) / d + (g < b ? 6 : 0);
-        break;
-      case g:
-        h = (b - r) / d + 2;
-        break;
-      case b:
-        h = (r - g) / d + 4;
-        break;
+import { APCAcontrast, sRGBtoY } from "apca-w3";
+/**
+ * Converts a HEX color '#xxxxxx' into a CSS HSL string 'hsl(x,x,x)'
+ *
+ * @param hex A hex color string
+ * @param valuesOnly If true, only the values are returned
+ * @returns A CSS HSL string
+ */ export const hexToCssHsl = (hex, valuesOnly = false)=>{
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    let r = 0;
+    let g = 0;
+    let b = 0;
+    let cssString = '';
+    if (result) {
+        r = parseInt(result[1], 16);
+        g = parseInt(result[2], 16);
+        b = parseInt(result[3], 16);
     }
-  }
-  h = Math.round(h ? h * 360 : 0);
-  s = Math.round(s * 100);
-  l = Math.round(l * 100);
-  cssString = h + "," + s + "%," + l + "%";
-  cssString = !valuesOnly ? "hsl(" + cssString + ")" : cssString;
-  return cssString;
+    r /= 255, g /= 255, b /= 255;
+    const max = Math.max(r, g, b), min = Math.min(r, g, b);
+    let h, s, l = (max + min) / 2;
+    if (max == min) {
+        h = s = 0; // achromatic
+    } else {
+        const d = max - min;
+        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+        switch(max){
+            case r:
+                h = (g - b) / d + (g < b ? 6 : 0);
+                break;
+            case g:
+                h = (b - r) / d + 2;
+                break;
+            case b:
+                h = (r - g) / d + 4;
+                break;
+        }
+    }
+    h = Math.round(h ? h * 360 : 0);
+    s = Math.round(s * 100);
+    l = Math.round(l * 100);
+    cssString = h + ',' + s + '%,' + l + '%';
+    cssString = !valuesOnly ? 'hsl(' + cssString + ')' : cssString;
+    return cssString;
 };
-var hexToHSL = (H) => {
-  let r = 0, g = 0, b = 0;
-  if (H.length == 4) {
-    r = parseInt("0x" + H[1] + H[1]);
-    g = parseInt("0x" + H[2] + H[2]);
-    b = parseInt("0x" + H[3] + H[3]);
-  } else if (H.length == 7) {
-    r = parseInt("0x" + H[1] + H[2]);
-    g = parseInt("0x" + H[3] + H[4]);
-    b = parseInt("0x" + H[5] + H[6]);
-  }
-  r /= 255;
-  g /= 255;
-  b /= 255;
-  let h = 0, s = 0, l = 0;
-  const cmin = Math.min(r, g, b), cmax = Math.max(r, g, b), delta = cmax - cmin;
-  if (delta == 0) h = 0;
-  else if (cmax == r) h = (g - b) / delta % 6;
-  else if (cmax == g) h = (b - r) / delta + 2;
-  else h = (r - g) / delta + 4;
-  h = Math.round(h * 60);
-  if (h < 0) h += 360;
-  l = (cmax + cmin) / 2;
-  s = delta == 0 ? 0 : delta / (1 - Math.abs(2 * l - 1));
-  s = +(s * 100).toFixed(1);
-  l = +(l * 100).toFixed(1);
-  return [h, s, l];
+/**
+ * Converts a HEX string '#xxxxxx' into an array of HSL values '[h,s,l]'
+ *
+ * @param H A Hex color string
+ * @returns HSL values in an array
+ */ export const hexToHSL = (H)=>{
+    // Convert hex to RGB first
+    let r = 0, g = 0, b = 0;
+    if (H.length == 4) {
+        r = parseInt('0x' + H[1] + H[1]);
+        g = parseInt('0x' + H[2] + H[2]);
+        b = parseInt('0x' + H[3] + H[3]);
+    } else if (H.length == 7) {
+        r = parseInt('0x' + H[1] + H[2]);
+        g = parseInt('0x' + H[3] + H[4]);
+        b = parseInt('0x' + H[5] + H[6]);
+    }
+    // Then to HSL
+    r /= 255;
+    g /= 255;
+    b /= 255;
+    let h = 0, s = 0, l = 0;
+    const cmin = Math.min(r, g, b), cmax = Math.max(r, g, b), delta = cmax - cmin;
+    if (delta == 0) h = 0;
+    else if (cmax == r) h = (g - b) / delta % 6;
+    else if (cmax == g) h = (b - r) / delta + 2;
+    else h = (r - g) / delta + 4;
+    h = Math.round(h * 60);
+    if (h < 0) h += 360;
+    l = (cmax + cmin) / 2;
+    s = delta == 0 ? 0 : delta / (1 - Math.abs(2 * l - 1));
+    s = +(s * 100).toFixed(1);
+    l = +(l * 100).toFixed(1);
+    return [
+        h,
+        s,
+        l
+    ];
 };
-var hexToHsluv = (hex) => {
-  const conv = new Hsluv();
-  conv.hex = hex;
-  conv.hexToHsluv();
-  return [conv.hsluv_h, conv.hsluv_s, conv.hsluv_l];
+/**
+ * Converts a HEX color '#xxxxxx' into an array of HSLuv values '[h,s,l]'
+ *
+ * @param hex A hex color string
+ * @returns
+ */ export const hexToHsluv = (hex)=>{
+    const conv = new Hsluv();
+    conv.hex = hex;
+    conv.hexToHsluv();
+    return [
+        conv.hsluv_h,
+        conv.hsluv_s,
+        conv.hsluv_l
+    ];
 };
-var hslArrToCss = (HSL) => {
-  return "hsl(" + HSL[0] + "," + HSL[1] + "%," + HSL[2] + "%)";
+/**
+ * Converts a HSL number array '[h,s,l]' into HSL CSS string 'hsl(x,x,x)'
+ *
+ * @param HSL A HSL number array '[h,s,l]'
+ * @returns A hex color string
+ */ export const hslArrToCss = (HSL)=>{
+    return 'hsl(' + HSL[0] + ',' + HSL[1] + '%,' + HSL[2] + '%)';
 };
-var HSLToHex = (h, s, l) => {
-  s /= 100;
-  l /= 100;
-  let r = 0, g = 0, b = 0;
-  const c = (1 - Math.abs(2 * l - 1)) * s, x = c * (1 - Math.abs(h / 60 % 2 - 1)), m = l - c / 2;
-  if (0 <= h && h < 60) {
-    r = c;
-    g = x;
-    b = 0;
-  } else if (60 <= h && h < 120) {
-    r = x;
-    g = c;
-    b = 0;
-  } else if (120 <= h && h < 180) {
-    r = 0;
-    g = c;
-    b = x;
-  } else if (180 <= h && h < 240) {
-    r = 0;
-    g = x;
-    b = c;
-  } else if (240 <= h && h < 300) {
-    r = x;
-    g = 0;
-    b = c;
-  } else if (300 <= h && h < 360) {
-    r = c;
-    g = 0;
-    b = x;
-  }
-  r = parseInt(Math.round((r + m) * 255).toString(16), 16);
-  g = parseInt(Math.round((g + m) * 255).toString(16), 16);
-  b = parseInt(Math.round((b + m) * 255).toString(16), 16);
-  if (r.toString().length == 1) r = parseInt("0" + r.toString(), 10);
-  if (g.toString().length == 1) g = parseInt("0" + g.toString(), 10);
-  if (b.toString().length == 1) b = parseInt("0" + b.toString(), 10);
-  return "#" + r + g + b;
+/**
+ * Converts a HSL CSS string 'hsl(x,x,x)' into an array of HSL values '[h,s,l]'
+ *
+ * @param h The HSL hue
+ * @param s The HSL saturation
+ * @param l The HSL lightness
+ * @returns HEX color string
+ */ export const HSLToHex = (h, s, l)=>{
+    s /= 100;
+    l /= 100;
+    let r = 0, g = 0, b = 0;
+    const c = (1 - Math.abs(2 * l - 1)) * s, x = c * (1 - Math.abs(h / 60 % 2 - 1)), m = l - c / 2;
+    if (0 <= h && h < 60) {
+        r = c;
+        g = x;
+        b = 0;
+    } else if (60 <= h && h < 120) {
+        r = x;
+        g = c;
+        b = 0;
+    } else if (120 <= h && h < 180) {
+        r = 0;
+        g = c;
+        b = x;
+    } else if (180 <= h && h < 240) {
+        r = 0;
+        g = x;
+        b = c;
+    } else if (240 <= h && h < 300) {
+        r = x;
+        g = 0;
+        b = c;
+    } else if (300 <= h && h < 360) {
+        r = c;
+        g = 0;
+        b = x;
+    }
+    // Having obtained RGB, convert channels to hex
+    r = parseInt(Math.round((r + m) * 255).toString(16), 16);
+    g = parseInt(Math.round((g + m) * 255).toString(16), 16);
+    b = parseInt(Math.round((b + m) * 255).toString(16), 16);
+    // Prepend 0s, if necessary
+    if (r.toString().length == 1) r = parseInt('0' + r.toString(), 10);
+    if (g.toString().length == 1) g = parseInt('0' + g.toString(), 10);
+    if (b.toString().length == 1) b = parseInt('0' + b.toString(), 10);
+    return '#' + r + g + b;
 };
-var hexToRgb = (hex) => {
-  const shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
-  hex = hex.replace(shorthandRegex, function(m, r, g, b) {
-    return r + r + g + g + b + b;
-  });
-  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-  return result ? {
-    r: parseInt(result[1], 16),
-    g: parseInt(result[2], 16),
-    b: parseInt(result[3], 16)
-  } : null;
+/**
+ * Converts a HEX color '#xxxxxx' into an array of RGB values '[R, G, B]'
+ *
+ * @param hex A hex color string
+ * @returns RGB values in an array
+ */ export const hexToRgb = (hex)=>{
+    const shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
+    hex = hex.replace(shorthandRegex, function(m, r, g, b) {
+        return r + r + g + g + b + b;
+    });
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result ? {
+        r: parseInt(result[1], 16),
+        g: parseInt(result[2], 16),
+        b: parseInt(result[3], 16)
+    } : null;
 };
-var luminanceFromRgb = (r, g, b) => {
-  const a = [Number(r), Number(g), Number(b)].map(function(v) {
-    v /= 255;
-    return v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
-  });
-  return a[0] * 0.2126 + a[1] * 0.7152 + a[2] * 0.0722;
+/**
+ * Get the luminance of an RGB color
+ *
+ * @param r RGB red value
+ * @param G RGB green value
+ * @param b RGB blue value
+ * @returns
+ */ export const luminanceFromRgb = (r, g, b)=>{
+    const a = [
+        Number(r),
+        Number(g),
+        Number(b)
+    ].map(function(v) {
+        v /= 255;
+        return v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+    });
+    return a[0] * 0.2126 + a[1] * 0.7152 + a[2] * 0.0722;
 };
-var luminanceFromHex = (hex) => {
-  const rgb = hexToRgb(hex);
-  if (rgb) {
-    const r = rgb.r.toString();
-    const g = rgb.g.toString();
-    const b = rgb.b.toString();
-    return luminanceFromRgb(r, g, b);
-  }
-  return 2;
+/**
+ * Get the luminance of a HEX color
+ *
+ * @param hex A hex color string
+ * @returns
+ */ export const luminanceFromHex = (hex)=>{
+    const rgb = hexToRgb(hex);
+    if (rgb) {
+        const r = rgb.r.toString();
+        const g = rgb.g.toString();
+        const b = rgb.b.toString();
+        return luminanceFromRgb(r, g, b);
+    }
+    return 2;
 };
-var getRatioFromLum = (lum1, lum2) => {
-  if (lum1 !== null && lum2 !== null) {
-    return (Math.max(lum1, lum2) + 0.05) / (Math.min(lum1, lum2) + 0.05);
-  } else {
-    return -1;
-  }
+/**
+ * Get the contrast ratio between two luminance values
+ *
+ * @param lum1 The first luminance value
+ * @param lum2 The second luminance value
+ * @returns
+ */ export const getRatioFromLum = (lum1, lum2)=>{
+    if (lum1 !== null && lum2 !== null) {
+        return (Math.max(lum1, lum2) + 0.05) / (Math.min(lum1, lum2) + 0.05);
+    } else {
+        return -1;
+    }
 };
-var getHslLightessFromHex = (hex) => {
-  return chroma(hex).hsl()[2];
+/**
+ * Get the HSL lightness from a HEX color
+ *
+ * @param hex A hex color string
+ * @returns
+ */ export const getHslLightessFromHex = (hex)=>{
+    return chroma(hex).hsl()[2];
 };
-var getHslSaturationFromHex = (hex) => {
-  return chroma(hex).hsl()[1];
+export const getHslSaturationFromHex = (hex)=>{
+    return chroma(hex).hsl()[1];
 };
-var getLightnessFromHex = (hex) => {
-  const conv = new Hsluv();
-  conv.hex = hex;
-  conv.hexToHsluv();
-  return Number(conv.hsluv_l.toFixed(0));
+/**
+ * Get the HSLuv lightness from a HEX color
+ *
+ * @param hex A hex color string
+ * @returns
+ */ export const getLightnessFromHex = (hex)=>{
+    const conv = new Hsluv();
+    conv.hex = hex;
+    conv.hexToHsluv();
+    return Number(conv.hsluv_l.toFixed(0));
 };
-var getContrastFromHex = (color1, color2) => {
-  const lum1 = luminanceFromHex(color1);
-  const lum2 = luminanceFromHex(color2);
-  if (lum1 !== null && lum2 !== null) {
-    return getRatioFromLum(lum1, lum2);
-  }
-  return -1;
+/**
+ * Get the contrast ratio between two HEX colors
+ *
+ * @param {CssColor} color1 The first color
+ * @param {CssColor} color2 The second color
+ * @returns
+ */ export const getContrastFromHex = (color1, color2)=>{
+    const lum1 = luminanceFromHex(color1);
+    const lum2 = luminanceFromHex(color2);
+    if (lum1 !== null && lum2 !== null) {
+        return getRatioFromLum(lum1, lum2);
+    }
+    return -1;
 };
-var getContrastFromLightness = (lightness, mainColor, backgroundColor) => {
-  const conv = new Hsluv();
-  conv.hex = mainColor;
-  conv.hexToHsluv();
-  conv.hsluv_l = lightness;
-  conv.hsluvToHex();
-  const lightMainColor = conv.hex;
-  const lum1 = luminanceFromHex(lightMainColor);
-  const lum2 = luminanceFromHex(backgroundColor);
-  const ratio = getRatioFromLum(lum1 ?? 0, lum2 ?? 0);
-  return ratio;
+/**
+ * Get the contrast ratio between two colors at a specific lightness
+ *
+ * @param lightness The lightness value
+ * @param mainColor The main color
+ * @param backgroundColor The background color
+ * @returns The contrast ratio
+ */ export const getContrastFromLightness = (lightness, mainColor, backgroundColor)=>{
+    const conv = new Hsluv();
+    conv.hex = mainColor;
+    conv.hexToHsluv();
+    conv.hsluv_l = lightness;
+    conv.hsluvToHex();
+    const lightMainColor = conv.hex;
+    const lum1 = luminanceFromHex(lightMainColor);
+    const lum2 = luminanceFromHex(backgroundColor);
+    const ratio = getRatioFromLum(lum1 ?? 0, lum2 ?? 0);
+    return ratio;
 };
-var areColorsContrasting = (color1, color2, type = "aa") => {
-  const contrast = getContrastFromHex(color1, color2);
-  if (contrast !== null) {
-    if (type === "aaa") {
-      return contrast >= 7;
-    } else if (type === "aa") {
-      return contrast >= 4.5;
-    } else {
-      return contrast >= 3;
+/**
+ * Maps the numbers from [start1 - end1] to the range [start2 - end2], maintaining the proportionality between the numbers in the ranges using lineaer interpolation.
+ */ // const mapRange = (value: number, start1: number, end1: number, start2: number, end2: number) => {
+//   return start2 + ((value - start1) * (end2 - start2)) / (end1 - start1);
+// };
+/**
+ * Check if two colors have enough contrast to be used together
+ *
+ * @param {CssColor} color1 The first color
+ * @param {CssColor} color2 The second color
+ * @returns {boolean} If the colors have enough contrast
+ */ export const areColorsContrasting = (color1, color2, type = 'aa')=>{
+    const contrast = getContrastFromHex(color1, color2);
+    if (contrast !== null) {
+        if (type === 'aaa') {
+            return contrast >= 7;
+        } else if (type === 'aa') {
+            return contrast >= 4.5;
+        } else {
+            return contrast >= 3;
+        }
     }
-  }
-  return false;
-};
-var getApcaContrastLc = (textColor, backgroundColor) => {
-  const textColorRgb = hexToRgb(textColor);
-  const backgroundColorRgb = hexToRgb(backgroundColor);
-  if (textColorRgb && backgroundColorRgb) {
-    return APCAcontrast(
-      sRGBtoY([textColorRgb.r, textColorRgb.g, textColorRgb.b]),
-      sRGBtoY([backgroundColorRgb.r, backgroundColorRgb.g, backgroundColorRgb.b])
-    );
-  }
-  return 0;
+    return false;
 };
-var isHexColor = (hex) => {
-  return typeof hex === "string" && hex.length === 6 && !isNaN(Number("0x" + hex));
+export const getApcaContrastLc = (textColor, backgroundColor)=>{
+    const textColorRgb = hexToRgb(textColor);
+    const backgroundColorRgb = hexToRgb(backgroundColor);
+    if (textColorRgb && backgroundColorRgb) {
+        return APCAcontrast(sRGBtoY([
+            textColorRgb.r,
+            textColorRgb.g,
+            textColorRgb.b
+        ]), sRGBtoY([
+            backgroundColorRgb.r,
+            backgroundColorRgb.g,
+            backgroundColorRgb.b
+        ]));
+    }
+    return 0;
 };
-export {
-  HSLToHex,
-  areColorsContrasting,
-  getApcaContrastLc,
-  getContrastFromHex,
-  getContrastFromLightness,
-  getHslLightessFromHex,
-  getHslSaturationFromHex,
-  getLightnessFromHex,
-  getRatioFromLum,
-  hexToCssHsl,
-  hexToHSL,
-  hexToHsluv,
-  hexToRgb,
-  hslArrToCss,
-  isHexColor,
-  luminanceFromHex,
-  luminanceFromRgb
+/**
+ * Check if aa string value is a HEX color
+ *
+ * @param {string} hex The string to check
+ * @returns {boolean} If the string is a HEX color
+ */ export const isHexColor = (hex)=>{
+    return typeof hex === 'string' && hex.length === 6 && !isNaN(Number('0x' + hex));
 };
-/*! Bundled license information:
-
-colorparsley/src/colorparsley.js:
-  (** @preserve
-  /////    CoLoR PaRsLeY  a simple set of color parsing thingies!
-  /////           Beta 0.1.8   Revision date: June 04, 2022
-  /////
-  /////    Functions to parse color values and return array
-  /////    Copyright (c) 2019-2022 by Andrew Somers. All Rights Reserved.
-  /////    LICENSE: AGPL 3
-  /////    CONTACT: Please use the ISSUES or DISCUSSIONS tab at:
-  /////    https://github.com/Myndex/colorparsley/
-  /////
-  ///////////////////////////////////////////////////////////////////////////////
-  /////
-  /////    IMPORT:
-  /////    import { colorParsley } from 'colorparsley';
-  /////
-  /////    let rgbaArray = colorParsley('#abcdef');
-  /////
-  /////    Output as array:  [r,g,b,a,isValid,colorspace]
-  /////    Example: [123,123,123,1.0,true,'sRGB']
-  // *)
-
-apca-w3/src/apca-w3.js:
-  (** @preserve
-  /////    SAPC APCA - Advanced Perceptual Contrast Algorithm
-  /////           Beta 0.1.9 W3 • contrast function only
-  /////           DIST: W3 • Revision date: July 3, 2022
-  /////    Function to parse color values and determine Lc contrast
-  /////    Copyright © 2019-2022 by Andrew Somers. All Rights Reserved.
-  /////    LICENSE: W3 LICENSE
-  /////    CONTACT: Please use the ISSUES or DISCUSSIONS tab at:
-  /////    https://github.com/Myndex/SAPC-APCA/
-  /////
-  ///////////////////////////////////////////////////////////////////////////////
-  /////
-  /////    MINIMAL IMPORTS:
-  /////      import { APCAcontrast, sRGBtoY, displayP3toY,
-  /////               calcAPCA, fontLookupAPCA } from 'apca-w3';
-  /////      import { colorParsley } from 'colorparsley';
-  /////
-  /////    FORWARD CONTRAST USAGE:
-  /////      Lc = APCAcontrast( sRGBtoY( TEXTcolor ) , sRGBtoY( BACKGNDcolor ) );
-  /////    Where the colors are sent as an rgba array [255,255,255,1]
-  /////
-  /////    Retrieving an array of font sizes for the contrast:
-  /////      fontArray = fontLookupAPCA(Lc);
-  /////
-  /////    Live Demonstrator at https://www.myndex.com/APCA/
-  // *)
-*/
-//# sourceMappingURL=colorUtils.js.map