@atlaskit/tokens 13.1.0 → 13.2.0

package/dist/esm/utils/additional-contrast-checker.js

@@ -0,0 +1,36 @@
+import tokenValuesDark from '../artifacts/atlassian-dark-token-value-for-contrast-check';
+import tokenValuesLight from '../artifacts/atlassian-light-token-value-for-contrast-check';
+import { additionalChecks } from './custom-theme-token-contrast-check';
+import { getContrastRatio } from './get-contrast-ratio';
+var getColorFromTokenRaw = function getColorFromTokenRaw(tokenName, mode) {
+  return mode === 'light' ? tokenValuesLight[tokenName] : tokenValuesDark[tokenName];
+};
+export var additionalContrastChecker = function additionalContrastChecker(_ref) {
+  var customThemeTokenMap = _ref.customThemeTokenMap,
+    mode = _ref.mode,
+    themeRamp = _ref.themeRamp;
+  var updatedCustomThemeTokenMap = {};
+  var brandTokens = Object.keys(customThemeTokenMap);
+  additionalChecks.forEach(function (pairing) {
+    var backgroundLight = pairing.backgroundLight,
+      backgroundDark = pairing.backgroundDark,
+      foreground = pairing.foreground,
+      desiredContrast = pairing.desiredContrast,
+      updatedTokens = pairing.updatedTokens;
+    var background = mode === 'light' ? backgroundLight : backgroundDark;
+    var foregroundTokenValue = customThemeTokenMap[foreground];
+    var backgroundTokenValue = customThemeTokenMap[background];
+    var foregroundColor = brandTokens.includes(foreground) ? typeof foregroundTokenValue === 'string' ? foregroundTokenValue : themeRamp[foregroundTokenValue] : getColorFromTokenRaw(foreground, mode);
+    var backgroundColor = brandTokens.includes(background) ? typeof backgroundTokenValue === 'string' ? backgroundTokenValue : themeRamp[backgroundTokenValue] : getColorFromTokenRaw(background, mode);
+    var contrast = getContrastRatio(foregroundColor, backgroundColor);
+    if (contrast <= desiredContrast) {
+      updatedTokens.forEach(function (token) {
+        var rampValue = customThemeTokenMap[token];
+        if (typeof rampValue === 'number') {
+          updatedCustomThemeTokenMap[token] = mode === 'light' ? rampValue + 1 : rampValue - 1;
+        }
+      });
+    }
+  });
+  return updatedCustomThemeTokenMap;
+};

package/dist/esm/utils/custom-theme-loading-utils.js

@@ -1,5 +1,3 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import tokens from '../artifacts/token-names';
 import { CUSTOM_THEME_ATTRIBUTE, THEME_DATA_ATTRIBUTE } from '../constants';
 import { hash } from './hash';
 export function findMissingCustomStyleElements(UNSAFE_themeOptions, mode) {
@@ -16,16 +14,4 @@ export function findMissingCustomStyleElements(UNSAFE_themeOptions, mode) {
     }
   });
   return attrOfMissingCustomStyles;
-}
-
-// eslint-disable-next-line @atlaskit/volt-strict-mode/no-multiple-exports
-export function reduceTokenMap(tokenMap, themeRamp) {
-  return Object.entries(tokenMap).reduce(function (acc, _ref) {
-    var _ref2 = _slicedToArray(_ref, 2),
-      key = _ref2[0],
-      value = _ref2[1];
-    var cssVar = tokens[key];
-    return cssVar ? "".concat(acc, "\n  ").concat(cssVar, ": ").concat(typeof value === 'string' ? value : themeRamp[value], ";") : acc;
-  }, '');
-}
-export { limitSizeOfCustomStyleElements } from './limit-size-of-custom-style-elements';
+}

package/dist/esm/utils/custom-theme-token-contrast-check.js

@@ -1,6 +1,3 @@
-import tokenValuesDark from '../artifacts/atlassian-dark-token-value-for-contrast-check';
-import tokenValuesLight from '../artifacts/atlassian-light-token-value-for-contrast-check';
-import { getContrastRatio } from './color-utils';
 export var additionalChecks = [{
   foreground: 'color.text.brand',
   backgroundLight: 'elevation.surface.sunken',
@@ -42,38 +39,4 @@ export var additionalChecks = [{
   // In light mode: darken the following tokens by one base token
   // In dark mode: lighten the following tokens by one base token
   updatedTokens: ['color.chart.brand', 'color.chart.brand.hovered']
-}];
-var getColorFromTokenRaw = function getColorFromTokenRaw(tokenName, mode) {
-  return mode === 'light' ? tokenValuesLight[tokenName] : tokenValuesDark[tokenName];
-};
-
-// eslint-disable-next-line @atlaskit/volt-strict-mode/no-multiple-exports
-export var additionalContrastChecker = function additionalContrastChecker(_ref) {
-  var customThemeTokenMap = _ref.customThemeTokenMap,
-    mode = _ref.mode,
-    themeRamp = _ref.themeRamp;
-  var updatedCustomThemeTokenMap = {};
-  var brandTokens = Object.keys(customThemeTokenMap);
-  additionalChecks.forEach(function (pairing) {
-    var backgroundLight = pairing.backgroundLight,
-      backgroundDark = pairing.backgroundDark,
-      foreground = pairing.foreground,
-      desiredContrast = pairing.desiredContrast,
-      updatedTokens = pairing.updatedTokens;
-    var background = mode === 'light' ? backgroundLight : backgroundDark;
-    var foregroundTokenValue = customThemeTokenMap[foreground];
-    var backgroundTokenValue = customThemeTokenMap[background];
-    var foregroundColor = brandTokens.includes(foreground) ? typeof foregroundTokenValue === 'string' ? foregroundTokenValue : themeRamp[foregroundTokenValue] : getColorFromTokenRaw(foreground, mode);
-    var backgroundColor = brandTokens.includes(background) ? typeof backgroundTokenValue === 'string' ? backgroundTokenValue : themeRamp[backgroundTokenValue] : getColorFromTokenRaw(background, mode);
-    var contrast = getContrastRatio(foregroundColor, backgroundColor);
-    if (contrast <= desiredContrast) {
-      updatedTokens.forEach(function (token) {
-        var rampValue = customThemeTokenMap[token];
-        if (typeof rampValue === 'number') {
-          updatedCustomThemeTokenMap[token] = mode === 'light' ? rampValue + 1 : rampValue - 1;
-        }
-      });
-    }
-  });
-  return updatedCustomThemeTokenMap;
-};
+}];

package/dist/esm/utils/delta-e.js

@@ -0,0 +1,20 @@
+import { rgbToLab } from './rgb-to-lab';
+export function deltaE(rgbA, rgbB) {
+  var labA = rgbToLab(rgbA);
+  var labB = rgbToLab(rgbB);
+  var deltaL = labA[0] - labB[0];
+  var deltaA = labA[1] - labB[1];
+  var deltaB = labA[2] - labB[2];
+  var c1 = Math.sqrt(labA[1] * labA[1] + labA[2] * labA[2]);
+  var c2 = Math.sqrt(labB[1] * labB[1] + labB[2] * labB[2]);
+  var deltaC = c1 - c2;
+  var deltaH = deltaA * deltaA + deltaB * deltaB - deltaC * deltaC;
+  deltaH = deltaH < 0 ? 0 : Math.sqrt(deltaH);
+  var sc = 1.0 + 0.045 * c1;
+  var sh = 1.0 + 0.015 * c1;
+  var deltaLKlsl = deltaL / 1.0;
+  var deltaCkcsc = deltaC / sc;
+  var deltaHkhsh = deltaH / sh;
+  var i = deltaLKlsl * deltaLKlsl + deltaCkcsc * deltaCkcsc + deltaHkhsh * deltaHkhsh;
+  return i < 0 ? 0 : Math.sqrt(i);
+}

package/dist/esm/utils/generate-colors.js

@@ -0,0 +1,40 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { getClosestColorIndex } from './get-closest-color-index';
+import { argbFromRgba, Contrast, Hct, rgbaFromArgb } from './hct-color-utils';
+import { hexToHSL } from './hex-to-hsl';
+import { hexToRgbA } from './hex-to-rgb-a';
+import { HSLToRGB } from './hsl-to-rgb';
+import { relativeLuminanceW3C } from './relative-luminance-w3-c';
+import { rgbToHex } from './rgb-to-hex';
+var lowLuminanceContrastRatios = [1.12, 1.33, 2.03, 2.73, 3.33, 4.27, 5.2, 6.62, 12.46, 14.25];
+var highLuminanceContrastRatios = [1.08, 1.24, 1.55, 1.99, 2.45, 3.34, 4.64, 6.1, 10.19, 12.6];
+export var generateColors = function generateColors(brandColor) {
+  // Determine luminance
+  var HSLBrandColorHue = hexToHSL(brandColor)[0];
+  var baseRgb = HSLToRGB(HSLBrandColorHue, 100, 60);
+  var isLowLuminance = relativeLuminanceW3C(baseRgb[0], baseRgb[1], baseRgb[2]) < 0.4;
+  // Choose right palette
+  var themeRatios = isLowLuminance ? lowLuminanceContrastRatios : highLuminanceContrastRatios;
+  var brandRgba = hexToRgbA(brandColor);
+  var hctColor = Hct.fromInt(argbFromRgba({
+    r: brandRgba[0],
+    g: brandRgba[1],
+    b: brandRgba[2],
+    a: brandRgba[3]
+  }));
+  var themeRamp = themeRatios.map(function (contrast) {
+    var rgbaColor = rgbaFromArgb(Hct.from(hctColor.hue, hctColor.chroma, Contrast.darker(100, contrast) + 0.25 // Material's utils provide an offset
+    ).toInt());
+    return rgbToHex(rgbaColor.r, rgbaColor.g, rgbaColor.b);
+  });
+  var closestColorIndex = getClosestColorIndex(themeRamp, brandColor);
+
+  // Replace closet color with brandColor
+  var updatedThemeRamp = _toConsumableArray(themeRamp);
+  updatedThemeRamp[closestColorIndex] = brandColor;
+  return {
+    ramp: updatedThemeRamp,
+    // add the replaced color into the result
+    replacedColor: themeRamp[closestColorIndex]
+  };
+};

package/dist/esm/utils/generate-token-map-with-contrast-check.js

@@ -0,0 +1,25 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { additionalContrastChecker } from './additional-contrast-checker';
+import { generateColors } from './generate-colors';
+import { generateTokenMap } from './generate-token-map';
+export var generateTokenMapWithContrastCheck = function generateTokenMapWithContrastCheck(brandColor, mode, themeRamp) {
+  var colors = themeRamp || generateColors(brandColor).ramp;
+  var tokenMaps = generateTokenMap(brandColor, mode, colors);
+  var result = {};
+  Object.entries(tokenMaps).forEach(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      mode = _ref2[0],
+      map = _ref2[1];
+    if (mode === 'light' || mode === 'dark') {
+      result[mode] = _objectSpread(_objectSpread({}, map), additionalContrastChecker({
+        customThemeTokenMap: map,
+        mode: mode,
+        themeRamp: colors
+      }));
+    }
+  });
+  return result;
+};

package/dist/esm/utils/{generate-custom-color-ramp.js → generate-token-map.js}

@@ -1,49 +1,8 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import rawTokensDark from '../artifacts/atlassian-dark-token-value-for-contrast-check';
-import { getContrastRatio, hexToHSL, hexToRgbA } from './color-utils';
-import { additionalContrastChecker } from './custom-theme-token-contrast-check';
+import { generateColors } from './generate-colors';
 import { getClosestColorIndex } from './get-closest-color-index';
-import { argbFromRgba, Contrast, Hct, rgbaFromArgb } from './hct-color-utils';
-import { HSLToRGB } from './hsl-to-rgb';
-import { relativeLuminanceW3C } from './relative-luminance-w3-c';
-import { rgbToHex } from './rgb-to-hex';
-var lowLuminanceContrastRatios = [1.12, 1.33, 2.03, 2.73, 3.33, 4.27, 5.2, 6.62, 12.46, 14.25];
-var highLuminanceContrastRatios = [1.08, 1.24, 1.55, 1.99, 2.45, 3.34, 4.64, 6.1, 10.19, 12.6];
-export var generateColors = function generateColors(brandColor) {
-  // Determine luminance
-  var HSLBrandColorHue = hexToHSL(brandColor)[0];
-  var baseRgb = HSLToRGB(HSLBrandColorHue, 100, 60);
-  var isLowLuminance = relativeLuminanceW3C(baseRgb[0], baseRgb[1], baseRgb[2]) < 0.4;
-  // Choose right palette
-  var themeRatios = isLowLuminance ? lowLuminanceContrastRatios : highLuminanceContrastRatios;
-  var brandRgba = hexToRgbA(brandColor);
-  var hctColor = Hct.fromInt(argbFromRgba({
-    r: brandRgba[0],
-    g: brandRgba[1],
-    b: brandRgba[2],
-    a: brandRgba[3]
-  }));
-  var themeRamp = themeRatios.map(function (contrast) {
-    var rgbaColor = rgbaFromArgb(Hct.from(hctColor.hue, hctColor.chroma, Contrast.darker(100, contrast) + 0.25 // Material's utils provide an offset
-    ).toInt());
-    return rgbToHex(rgbaColor.r, rgbaColor.g, rgbaColor.b);
-  });
-  var closestColorIndex = getClosestColorIndex(themeRamp, brandColor);
-
-  // Replace closet color with brandColor
-  var updatedThemeRamp = _toConsumableArray(themeRamp);
-  updatedThemeRamp[closestColorIndex] = brandColor;
-  return {
-    ramp: updatedThemeRamp,
-    // add the replaced color into the result
-    replacedColor: themeRamp[closestColorIndex]
-  };
-};
-
+import { getContrastRatio } from './get-contrast-ratio';
 /**
  * Return the interaction tokens for a color, given its ramp position and the number of
  * needed interaction states. Use higher-indexed colors (i.e. darker colors) if possible;
@@ -63,8 +22,6 @@ function getInteractionStates(rampPosition, number, colors) {
   }
   return result;
 }
-
-// eslint-disable-next-line @atlaskit/volt-strict-mode/no-multiple-exports
 export var generateTokenMap = function generateTokenMap(brandColor, mode, themeRamp) {
   var _generateColors = generateColors(brandColor),
     ramp = _generateColors.ramp,
@@ -203,25 +160,4 @@ export var generateTokenMap = function generateTokenMap(brandColor, mode, themeR
     light: customThemeTokenMapLight,
     dark: customThemeTokenMapDark
   };
-};
-
-// eslint-disable-next-line @atlaskit/volt-strict-mode/no-multiple-exports
-export var generateTokenMapWithContrastCheck = function generateTokenMapWithContrastCheck(brandColor, mode, themeRamp) {
-  var colors = themeRamp || generateColors(brandColor).ramp;
-  var tokenMaps = generateTokenMap(brandColor, mode, colors);
-  var result = {};
-  Object.entries(tokenMaps).forEach(function (_ref3) {
-    var _ref4 = _slicedToArray(_ref3, 2),
-      mode = _ref4[0],
-      map = _ref4[1];
-    if (mode === 'light' || mode === 'dark') {
-      result[mode] = _objectSpread(_objectSpread({}, map), additionalContrastChecker({
-        customThemeTokenMap: map,
-        mode: mode,
-        themeRamp: colors
-      }));
-    }
-  });
-  return result;
-};
-export { getClosestColorIndex } from './get-closest-color-index';
+};

package/dist/esm/utils/get-closest-color-index.js

@@ -1,4 +1,5 @@
-import { deltaE, hexToRgb } from './color-utils';
+import { deltaE } from './delta-e';
+import { hexToRgb } from './hex-to-rgb';
 export var getClosestColorIndex = function getClosestColorIndex(themeRamp, brandColor) {
   // Iterate over themeRamp and find whichever color is closest to brandColor
   var closestColorIndex = 0;

package/dist/esm/utils/get-contrast-ratio.js

@@ -0,0 +1,16 @@
+import { hexToRgb } from './hex-to-rgb';
+import { isValidHex } from './is-valid-hex';
+import { relativeLuminanceW3C } from './relative-luminance-w3-c';
+export function getContrastRatio(foreground, background) {
+  if (!isValidHex(foreground) || !isValidHex(background)) {
+    throw new Error('Invalid HEX');
+  }
+  var foregroundRgb = hexToRgb(foreground);
+  var backgroundRgb = hexToRgb(background);
+  var foregroundLuminance = relativeLuminanceW3C(foregroundRgb[0], foregroundRgb[1], foregroundRgb[2]);
+  var backgroundLuminance = relativeLuminanceW3C(backgroundRgb[0], backgroundRgb[1], backgroundRgb[2]);
+  // calculate the color contrast ratio
+  var brightest = Math.max(foregroundLuminance, backgroundLuminance);
+  var darkest = Math.min(foregroundLuminance, backgroundLuminance);
+  return (brightest + 0.05) / (darkest + 0.05);
+}

package/dist/esm/utils/hct-color-utils/alpha-from-argb.js

@@ -0,0 +1,6 @@
+/**
+ * Returns the alpha component of a color in ARGB format.
+ */
+export function alphaFromArgb(argb) {
+  return argb >> 24 & 255;
+}

package/dist/esm/utils/hct-color-utils/argb-from-linrgb.js

@@ -0,0 +1,12 @@
+import { argbFromRgb } from './argb-from-rgb';
+import { delinearized } from './delinearized';
+
+/**
+ * Converts a color from linear RGB components to ARGB format.
+ */
+export function argbFromLinrgb(linrgb) {
+  var r = delinearized(linrgb[0]);
+  var g = delinearized(linrgb[1]);
+  var b = delinearized(linrgb[2]);
+  return argbFromRgb(r, g, b);
+}

package/dist/esm/utils/hct-color-utils/argb-from-lstar.js

@@ -0,0 +1,16 @@
+import { argbFromRgb } from './argb-from-rgb';
+import { delinearized } from './delinearized';
+import { yFromLstar } from './y-from-lstar';
+
+/**
+ * Converts an L* value to an ARGB representation.
+ *
+ * @param lstar L* in L*a*b*
+ * @return ARGB representation of grayscale color with lightness
+ * matching L*
+ */
+export function argbFromLstar(lstar) {
+  var y = yFromLstar(lstar);
+  var component = delinearized(y);
+  return argbFromRgb(component, component, component);
+}

package/dist/esm/utils/hct-color-utils/argb-from-rgba.js

@@ -0,0 +1,18 @@
+import { clampComponent } from './clamp-component';
+/**
+ * Return int32 color from a given RGBA component
+ *
+ * @param rgba RGBA representation of a int32 color.
+ * @returns ARGB representation of a int32 color.
+ */
+export function argbFromRgba(_ref) {
+  var r = _ref.r,
+    g = _ref.g,
+    b = _ref.b,
+    a = _ref.a;
+  var rValue = clampComponent(r);
+  var gValue = clampComponent(g);
+  var bValue = clampComponent(b);
+  var aValue = clampComponent(a);
+  return aValue << 24 | rValue << 16 | gValue << 8 | bValue;
+}

package/dist/esm/utils/hct-color-utils/argb-from-xyz.js

@@ -0,0 +1,24 @@
+import { argbFromRgb } from './argb-from-rgb';
+import { delinearized } from './delinearized';
+
+/**
+ * Color science utilities.
+ *
+ * Utility methods for color science constants and color space
+ * conversions that aren't HCT or CAM16.
+ */
+var XYZ_TO_SRGB = [[3.2413774792388685, -1.5376652402851851, -0.49885366846268053], [-0.9691452513005321, 1.8758853451067872, 0.04156585616912061], [0.05562093689691305, -0.20395524564742123, 1.0571799111220335]];
+
+/**
+ * Converts a color from ARGB to XYZ.
+ */
+export function argbFromXyz(x, y, z) {
+  var matrix = XYZ_TO_SRGB;
+  var linearR = matrix[0][0] * x + matrix[0][1] * y + matrix[0][2] * z;
+  var linearG = matrix[1][0] * x + matrix[1][1] * y + matrix[1][2] * z;
+  var linearB = matrix[2][0] * x + matrix[2][1] * y + matrix[2][2] * z;
+  var r = delinearized(linearR);
+  var g = delinearized(linearG);
+  var b = delinearized(linearB);
+  return argbFromRgb(r, g, b);
+}

package/dist/esm/utils/hct-color-utils/blue-from-argb.js

@@ -0,0 +1,6 @@
+/**
+ * Returns the blue component of a color in ARGB format.
+ */
+export function blueFromArgb(argb) {
+  return argb & 255;
+}

package/dist/esm/utils/hct-color-utils/clamp-component.js

@@ -0,0 +1,9 @@
+export function clampComponent(value) {
+  if (value < 0) {
+    return 0;
+  }
+  if (value > 255) {
+    return 255;
+  }
+  return value;
+}

package/dist/esm/utils/hct-color-utils/contrast.js

@@ -28,9 +28,9 @@ import _createClass from "@babel/runtime/helpers/createClass";
 //
 // tslint:disable:class-as-namespace
 
-import * as utils from './color-utils';
-import * as math from './math-utils';
-
+import { clampDouble } from './clamp-double';
+import { lstarFromY } from './lstar-from-y';
+import { yFromLstar } from './y-from-lstar';
 /**
  * Utility methods for calculating contrast given two colors, or calculating a
  * color given one color and a contrast ratio.
@@ -57,9 +57,9 @@ export var Contrast = /*#__PURE__*/function () {
      * @param toneB Tone between 0 and 100. Values outside will be clamped.
      */
     function ratioOfTones(toneA, toneB) {
-      toneA = math.clampDouble(0.0, 100.0, toneA);
-      toneB = math.clampDouble(0.0, 100.0, toneB);
-      return Contrast.ratioOfYs(utils.yFromLstar(toneA), utils.yFromLstar(toneB));
+      toneA = clampDouble(0.0, 100.0, toneA);
+      toneB = clampDouble(0.0, 100.0, toneB);
+      return Contrast.ratioOfYs(yFromLstar(toneA), yFromLstar(toneB));
     }
   }, {
     key: "ratioOfYs",
@@ -85,7 +85,7 @@ export var Contrast = /*#__PURE__*/function () {
       if (tone < 0.0 || tone > 100.0) {
         return -1.0;
       }
-      var darkY = utils.yFromLstar(tone);
+      var darkY = yFromLstar(tone);
       var lightY = ratio * (darkY + 5.0) - 5.0;
       var realContrast = Contrast.ratioOfYs(lightY, darkY);
       var delta = Math.abs(realContrast - ratio);
@@ -95,7 +95,7 @@ export var Contrast = /*#__PURE__*/function () {
 
       // Ensure gamut mapping, which requires a 'range' on tone, will still result
       // the correct ratio by darkening slightly.
-      var returnValue = utils.lstarFromY(lightY) + 0.4;
+      var returnValue = lstarFromY(lightY) + 0.4;
       if (returnValue < 0 || returnValue > 100) {
         return -1;
       }
@@ -118,7 +118,7 @@ export var Contrast = /*#__PURE__*/function () {
       if (tone < 0.0 || tone > 100.0) {
         return -1.0;
       }
-      var lightY = utils.yFromLstar(tone);
+      var lightY = yFromLstar(tone);
       var darkY = (lightY + 5.0) / ratio - 5.0;
       var realContrast = Contrast.ratioOfYs(lightY, darkY);
       var delta = Math.abs(realContrast - ratio);
@@ -128,7 +128,7 @@ export var Contrast = /*#__PURE__*/function () {
 
       // Ensure gamut mapping, which requires a 'range' on tone, will still result
       // the correct ratio by darkening slightly.
-      var returnValue = utils.lstarFromY(darkY) - 0.4;
+      var returnValue = lstarFromY(darkY) - 0.4;
       if (returnValue < 0 || returnValue > 100) {
         return -1;
       }

package/dist/esm/utils/hct-color-utils/green-from-argb.js

@@ -0,0 +1,6 @@
+/**
+ * Returns the green component of a color in ARGB format.
+ */
+export function greenFromArgb(argb) {
+  return argb >> 8 & 255;
+}

package/dist/esm/utils/hct-color-utils/hct.js

@@ -23,9 +23,16 @@ import _createClass from "@babel/runtime/helpers/createClass";
  * limitations under the License.
  */
 
-import * as utils from './color-utils';
+import { argbFromLinrgb } from './argb-from-linrgb';
+import { argbFromLstar } from './argb-from-lstar';
+import { argbFromXyz } from './argb-from-xyz';
+import { linearized } from './linearized';
+import { lstarFromArgb } from './lstar-from-argb';
+import { lstarFromY } from './lstar-from-y';
 import * as math from './math-utils';
 import { ViewingConditions } from './viewing-conditions';
+import { yFromLstar } from './y-from-lstar';
+
 /**
  * A color system built using CAM16 hue and chroma, and L* from
  * L*a*b*.
@@ -54,7 +61,7 @@ export var Hct = /*#__PURE__*/function () {
     var cam = Cam16.fromInt(argb);
     this.internalHue = cam.hue;
     this.internalChroma = cam.chroma;
-    this.internalTone = utils.lstarFromArgb(argb);
+    this.internalTone = lstarFromArgb(argb);
   }
   return _createClass(Hct, [{
     key: "toInt",
@@ -118,7 +125,7 @@ export var Hct = /*#__PURE__*/function () {
       var cam = Cam16.fromInt(argb);
       this.internalHue = cam.hue;
       this.internalChroma = cam.chroma;
-      this.internalTone = utils.lstarFromArgb(argb);
+      this.internalTone = lstarFromArgb(argb);
       this.argb = argb;
     }
 
@@ -149,7 +156,7 @@ export var Hct = /*#__PURE__*/function () {
       // 3. Create HCT from:
       // - CAM16 using default VC with XYZ coordinates in specified VC.
       // - L* converted from Y in XYZ coordinates in specified VC.
-      var recastHct = Hct.from(recastInVc.hue, recastInVc.chroma, utils.lstarFromY(viewedInVc[1]));
+      var recastHct = Hct.from(recastInVc.hue, recastInVc.chroma, lstarFromY(viewedInVc[1]));
       return recastHct;
     }
   }], [{
@@ -300,7 +307,7 @@ var Cam16 = /*#__PURE__*/function () {
       var x = 1.86206786 * rF - 1.01125463 * gF + 0.14918677 * bF;
       var y = 0.38752654 * rF + 0.62144744 * gF - 0.00897398 * bF;
       var z = -0.0158415 * rF - 0.03412294 * gF + 1.04996444 * bF;
-      var argb = utils.argbFromXyz(x, y, z);
+      var argb = argbFromXyz(x, y, z);
       return argb;
     }
 
@@ -358,9 +365,9 @@ var Cam16 = /*#__PURE__*/function () {
       var red = (argb & 0x00ff0000) >> 16;
       var green = (argb & 0x0000ff00) >> 8;
       var blue = argb & 0x000000ff;
-      var redL = utils.linearized(red);
-      var greenL = utils.linearized(green);
-      var blueL = utils.linearized(blue);
+      var redL = linearized(red);
+      var greenL = linearized(green);
+      var blueL = linearized(blue);
       var x = 0.41233895 * redL + 0.35762064 * greenL + 0.18051042 * blueL;
       var y = 0.2126 * redL + 0.7152 * greenL + 0.0722 * blueL;
       var z = 0.01932141 * redL + 0.11916382 * greenL + 0.95034478 * blueL;
@@ -881,7 +888,7 @@ var HctSolver = /*#__PURE__*/function () {
           if (linrgb[0] > 100.01 || linrgb[1] > 100.01 || linrgb[2] > 100.01) {
             return 0;
           }
-          return utils.argbFromLinrgb(linrgb);
+          return argbFromLinrgb(linrgb);
         }
         // Iterates with Newton method,
         // Using 2 * fn(j) / j as the approximation of fn'(j)
@@ -906,17 +913,17 @@ var HctSolver = /*#__PURE__*/function () {
     key: "solveToInt",
     value: function solveToInt(hueDegrees, chroma, lstar) {
       if (chroma < 0.0001 || lstar < 0.0001 || lstar > 99.9999) {
-        return utils.argbFromLstar(lstar);
+        return argbFromLstar(lstar);
       }
       hueDegrees = math.sanitizeDegreesDouble(hueDegrees);
       var hueRadians = hueDegrees / 180 * Math.PI;
-      var y = utils.yFromLstar(lstar);
+      var y = yFromLstar(lstar);
       var exactAnswer = HctSolver.findResultByJ(hueRadians, chroma, y);
       if (exactAnswer !== 0) {
         return exactAnswer;
       }
       var linrgb = HctSolver.bisectToLimit(y, hueRadians);
-      return utils.argbFromLinrgb(linrgb);
+      return argbFromLinrgb(linrgb);
     }
 
     /**

package/dist/esm/utils/hct-color-utils/index.js

@@ -1,3 +1,4 @@
 export { Hct } from './hct';
 export { Contrast } from './contrast';
-export { argbFromRgba, rgbaFromArgb } from './color-utils';
+export { argbFromRgba } from './argb-from-rgba';
+export { rgbaFromArgb } from './rgba-from-argb';

package/dist/esm/utils/hct-color-utils/lab-f.js

@@ -0,0 +1,9 @@
+export function labF(t) {
+  var e = 216.0 / 24389.0;
+  var kappa = 24389.0 / 27.0;
+  if (t > e) {
+    return Math.pow(t, 1.0 / 3.0);
+  } else {
+    return (kappa * t + 16) / 116;
+  }
+}

package/dist/esm/utils/hct-color-utils/lab-invf.js

@@ -0,0 +1,10 @@
+export function labInvf(ft) {
+  var e = 216.0 / 24389.0;
+  var kappa = 24389.0 / 27.0;
+  var ft3 = ft * ft * ft;
+  if (ft3 > e) {
+    return ft3;
+  } else {
+    return (116 * ft - 16) / kappa;
+  }
+}

package/dist/esm/utils/hct-color-utils/lstar-from-argb.js

@@ -0,0 +1,28 @@
+import { blueFromArgb } from './blue-from-argb';
+import { greenFromArgb } from './green-from-argb';
+import { labF } from './lab-f';
+import { linearized } from './linearized';
+import { matrixMultiply } from './matrix-multiply';
+import { redFromArgb } from './red-from-argb';
+var SRGB_TO_XYZ = [[0.41233895, 0.35762064, 0.18051042], [0.2126, 0.7152, 0.0722], [0.01932141, 0.11916382, 0.95034478]];
+
+/**
+ * Converts a color from XYZ to ARGB.
+ */
+function xyzFromArgb(argb) {
+  var r = linearized(redFromArgb(argb));
+  var g = linearized(greenFromArgb(argb));
+  var b = linearized(blueFromArgb(argb));
+  return matrixMultiply([r, g, b], SRGB_TO_XYZ);
+}
+
+/**
+ * Computes the L* value of a color in ARGB representation.
+ *
+ * @param argb ARGB representation of a color
+ * @return L*, from L*a*b*, coordinate of the color
+ */
+export function lstarFromArgb(argb) {
+  var y = xyzFromArgb(argb)[1];
+  return 116.0 * labF(y / 100.0) - 16.0;
+}

package/dist/esm/utils/hct-color-utils/lstar-from-y.js

@@ -0,0 +1,16 @@
+import { labF } from './lab-f';
+
+/**
+ * Converts a Y value to an L* value.
+ *
+ * L* in L*a*b* and Y in XYZ measure the same quantity, luminance.
+ *
+ * L* measures perceptual luminance, a linear scale. Y in XYZ
+ * measures relative luminance, a logarithmic scale.
+ *
+ * @param y Y in XYZ
+ * @return L* in L*a*b*
+ */
+export function lstarFromY(y) {
+  return labF(y / 100.0) * 116.0 - 16.0;
+}