@hero-design/colors 7.7.0 → 7.8.0

package/lib/index.js

@@ -1,90 +1,991 @@
 'use strict';
 
-const palette = {
-  black: '#000000',
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var hex2Rgb = require('hex-rgb');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var hex2Rgb__default = /*#__PURE__*/_interopDefaultLegacy(hex2Rgb);
+
+var colorName = {
+	"aliceblue": [240, 248, 255],
+	"antiquewhite": [250, 235, 215],
+	"aqua": [0, 255, 255],
+	"aquamarine": [127, 255, 212],
+	"azure": [240, 255, 255],
+	"beige": [245, 245, 220],
+	"bisque": [255, 228, 196],
+	"black": [0, 0, 0],
+	"blanchedalmond": [255, 235, 205],
+	"blue": [0, 0, 255],
+	"blueviolet": [138, 43, 226],
+	"brown": [165, 42, 42],
+	"burlywood": [222, 184, 135],
+	"cadetblue": [95, 158, 160],
+	"chartreuse": [127, 255, 0],
+	"chocolate": [210, 105, 30],
+	"coral": [255, 127, 80],
+	"cornflowerblue": [100, 149, 237],
+	"cornsilk": [255, 248, 220],
+	"crimson": [220, 20, 60],
+	"cyan": [0, 255, 255],
+	"darkblue": [0, 0, 139],
+	"darkcyan": [0, 139, 139],
+	"darkgoldenrod": [184, 134, 11],
+	"darkgray": [169, 169, 169],
+	"darkgreen": [0, 100, 0],
+	"darkgrey": [169, 169, 169],
+	"darkkhaki": [189, 183, 107],
+	"darkmagenta": [139, 0, 139],
+	"darkolivegreen": [85, 107, 47],
+	"darkorange": [255, 140, 0],
+	"darkorchid": [153, 50, 204],
+	"darkred": [139, 0, 0],
+	"darksalmon": [233, 150, 122],
+	"darkseagreen": [143, 188, 143],
+	"darkslateblue": [72, 61, 139],
+	"darkslategray": [47, 79, 79],
+	"darkslategrey": [47, 79, 79],
+	"darkturquoise": [0, 206, 209],
+	"darkviolet": [148, 0, 211],
+	"deeppink": [255, 20, 147],
+	"deepskyblue": [0, 191, 255],
+	"dimgray": [105, 105, 105],
+	"dimgrey": [105, 105, 105],
+	"dodgerblue": [30, 144, 255],
+	"firebrick": [178, 34, 34],
+	"floralwhite": [255, 250, 240],
+	"forestgreen": [34, 139, 34],
+	"fuchsia": [255, 0, 255],
+	"gainsboro": [220, 220, 220],
+	"ghostwhite": [248, 248, 255],
+	"gold": [255, 215, 0],
+	"goldenrod": [218, 165, 32],
+	"gray": [128, 128, 128],
+	"green": [0, 128, 0],
+	"greenyellow": [173, 255, 47],
+	"grey": [128, 128, 128],
+	"honeydew": [240, 255, 240],
+	"hotpink": [255, 105, 180],
+	"indianred": [205, 92, 92],
+	"indigo": [75, 0, 130],
+	"ivory": [255, 255, 240],
+	"khaki": [240, 230, 140],
+	"lavender": [230, 230, 250],
+	"lavenderblush": [255, 240, 245],
+	"lawngreen": [124, 252, 0],
+	"lemonchiffon": [255, 250, 205],
+	"lightblue": [173, 216, 230],
+	"lightcoral": [240, 128, 128],
+	"lightcyan": [224, 255, 255],
+	"lightgoldenrodyellow": [250, 250, 210],
+	"lightgray": [211, 211, 211],
+	"lightgreen": [144, 238, 144],
+	"lightgrey": [211, 211, 211],
+	"lightpink": [255, 182, 193],
+	"lightsalmon": [255, 160, 122],
+	"lightseagreen": [32, 178, 170],
+	"lightskyblue": [135, 206, 250],
+	"lightslategray": [119, 136, 153],
+	"lightslategrey": [119, 136, 153],
+	"lightsteelblue": [176, 196, 222],
+	"lightyellow": [255, 255, 224],
+	"lime": [0, 255, 0],
+	"limegreen": [50, 205, 50],
+	"linen": [250, 240, 230],
+	"magenta": [255, 0, 255],
+	"maroon": [128, 0, 0],
+	"mediumaquamarine": [102, 205, 170],
+	"mediumblue": [0, 0, 205],
+	"mediumorchid": [186, 85, 211],
+	"mediumpurple": [147, 112, 219],
+	"mediumseagreen": [60, 179, 113],
+	"mediumslateblue": [123, 104, 238],
+	"mediumspringgreen": [0, 250, 154],
+	"mediumturquoise": [72, 209, 204],
+	"mediumvioletred": [199, 21, 133],
+	"midnightblue": [25, 25, 112],
+	"mintcream": [245, 255, 250],
+	"mistyrose": [255, 228, 225],
+	"moccasin": [255, 228, 181],
+	"navajowhite": [255, 222, 173],
+	"navy": [0, 0, 128],
+	"oldlace": [253, 245, 230],
+	"olive": [128, 128, 0],
+	"olivedrab": [107, 142, 35],
+	"orange": [255, 165, 0],
+	"orangered": [255, 69, 0],
+	"orchid": [218, 112, 214],
+	"palegoldenrod": [238, 232, 170],
+	"palegreen": [152, 251, 152],
+	"paleturquoise": [175, 238, 238],
+	"palevioletred": [219, 112, 147],
+	"papayawhip": [255, 239, 213],
+	"peachpuff": [255, 218, 185],
+	"peru": [205, 133, 63],
+	"pink": [255, 192, 203],
+	"plum": [221, 160, 221],
+	"powderblue": [176, 224, 230],
+	"purple": [128, 0, 128],
+	"rebeccapurple": [102, 51, 153],
+	"red": [255, 0, 0],
+	"rosybrown": [188, 143, 143],
+	"royalblue": [65, 105, 225],
+	"saddlebrown": [139, 69, 19],
+	"salmon": [250, 128, 114],
+	"sandybrown": [244, 164, 96],
+	"seagreen": [46, 139, 87],
+	"seashell": [255, 245, 238],
+	"sienna": [160, 82, 45],
+	"silver": [192, 192, 192],
+	"skyblue": [135, 206, 235],
+	"slateblue": [106, 90, 205],
+	"slategray": [112, 128, 144],
+	"slategrey": [112, 128, 144],
+	"snow": [255, 250, 250],
+	"springgreen": [0, 255, 127],
+	"steelblue": [70, 130, 180],
+	"tan": [210, 180, 140],
+	"teal": [0, 128, 128],
+	"thistle": [216, 191, 216],
+	"tomato": [255, 99, 71],
+	"turquoise": [64, 224, 208],
+	"violet": [238, 130, 238],
+	"wheat": [245, 222, 179],
+	"white": [255, 255, 255],
+	"whitesmoke": [245, 245, 245],
+	"yellow": [255, 255, 0],
+	"yellowgreen": [154, 205, 50]
+};
+
+const pattern$8 = /^#([a-f0-9]{3,4}|[a-f0-9]{4}(?:[a-f0-9]{2}){1,2})\b$/;
+var hexRe$1 = new RegExp(pattern$8, 'i');
+
+const float$1 = '-?\\d*(?:\\.\\d+)';
+
+const number$1 = `(${float$1}?)`;
+const percentage$1 = `(${float$1}?%)`;
+const numberOrPercentage$1 = `(${float$1}?%?)`;
+
+const pattern$1$1 = `^
+  hsla?\\(
+    \\s*(-?\\d*(?:\\.\\d+)?(?:deg|rad|turn)?)\\s*,
+    \\s*${percentage$1}\\s*,
+    \\s*${percentage$1}\\s*
+    (?:,\\s*${numberOrPercentage$1}\\s*)?
+  \\)
+  $
+`.replace(/\n|\s/g, '');
+
+var hsl3Re$1 = new RegExp(pattern$1$1);
+
+const pattern$2$1 = `^
+  hsla?\\(
+    \\s*(-?\\d*(?:\\.\\d+)?(?:deg|rad|turn)?)\\s*
+    \\s+${percentage$1}
+    \\s+${percentage$1}
+    \\s*(?:\\s*\\/\\s*${numberOrPercentage$1}\\s*)?
+  \\)
+  $
+`.replace(/\n|\s/g, '');
+
+var hsl4Re$1 = new RegExp(pattern$2$1);
+
+const pattern$3$1 = `^
+  rgba?\\(
+    \\s*${number$1}\\s*,
+    \\s*${number$1}\\s*,
+    \\s*${number$1}\\s*
+    (?:,\\s*${numberOrPercentage$1}\\s*)?
+  \\)
+  $
+`.replace(/\n|\s/g, '');
+
+var rgb3NumberRe$1 = new RegExp(pattern$3$1);
+
+const pattern$4$1 = `^
+  rgba?\\(
+    \\s*${percentage$1}\\s*,
+    \\s*${percentage$1}\\s*,
+    \\s*${percentage$1}\\s*
+    (?:,\\s*${numberOrPercentage$1}\\s*)?
+  \\)
+  $
+`.replace(/\n|\s/g, '');
+
+var rgb3PercentageRe$1 = new RegExp(pattern$4$1);
+
+const pattern$5$1 = `^
+  rgba?\\(
+    \\s*${number$1}
+    \\s+${number$1}
+    \\s+${number$1}
+    \\s*(?:\\s*\\/\\s*${numberOrPercentage$1}\\s*)?
+  \\)
+$
+`.replace(/\n|\s/g, '');
+
+var rgb4NumberRe$1 = new RegExp(pattern$5$1);
+
+const pattern$6$1 = `^
+  rgba?\\(
+    \\s*${percentage$1}
+    \\s+${percentage$1}
+    \\s+${percentage$1}
+    \\s*(?:\\s*\\/\\s*${numberOrPercentage$1}\\s*)?
+  \\)
+$
+`.replace(/\n|\s/g, '');
+
+var rgb4PercentageRe$1 = new RegExp(pattern$6$1);
+
+const pattern$7$1 = /^transparent$/;
+var transparentRe$1 = new RegExp(pattern$7$1, 'i');
+
+const clamp$3 = (num, min, max) => Math.min(Math.max(min, num), max);
+
+/* 500 => 255, -10 => 0, 128 => 128 */
+const parseRGB$1 = (num) => {
+  let n = num;
+  if (typeof n !== 'number') n = n.endsWith('%') ? (parseFloat(n) * 255) / 100 : parseFloat(n);
+  return clamp$3(Math.round(n), 0, 255);
+};
+
+/* 200 => 100, -100 => 0, 50 => 50 */
+const parsePercentage$1 = (percentage) => clamp$3(parseFloat(percentage), 0, 100);
+
+/* '50%' => 5.0, 200 => 1, -10 => 0 */
+function parseAlpha$1(alpha) {
+  let a = alpha;
+  if (typeof a !== 'number') a = a.endsWith('%') ? parseFloat(a) / 100 : parseFloat(a);
+  return clamp$3(a, 0, 1);
+}
+
+function getHEX$1(hex) {
+  const [r, g, b, a] = hex2Rgb__default["default"](hex, { format: 'array' });
+  return getRGB$1([null, ...[r, g, b, a]]);
+}
+
+function getHSL$1([, h, s, l, a = 1]) {
+  let hh = h;
+  if (hh.endsWith('turn')) {
+    hh = (parseFloat(hh) * 360) / 1;
+  } else if (hh.endsWith('rad')) {
+    hh = Math.round((parseFloat(hh) * 180) / Math.PI);
+  } else {
+    hh = parseFloat(hh);
+  }
+  return {
+    type: 'hsl',
+    values: [hh, parsePercentage$1(s), parsePercentage$1(l)],
+    alpha: parseAlpha$1(a === null ? 1 : a)
+  };
+}
+
+function getRGB$1([, r, g, b, a = 1]) {
+  return {
+    type: 'rgb',
+    values: [r, g, b].map(parseRGB$1),
+    alpha: parseAlpha$1(a === null ? 1 : a)
+  };
+}
+
+/**
+ * parse-css-color
+ * @version v0.1.2
+ * @link http://github.com/noeldelgado/parse-css-color/
+ * @license MIT
+ */
+
+const parseCSSColor$1 = (str) => {
+  if (typeof str !== 'string') return null;
+
+  const hex = hexRe$1.exec(str);
+  if (hex) return getHEX$1(hex[0]);
+
+  const hsl = hsl4Re$1.exec(str) || hsl3Re$1.exec(str);
+  if (hsl) return getHSL$1(hsl);
+
+  const rgb =
+    rgb4NumberRe$1.exec(str) ||
+    rgb4PercentageRe$1.exec(str) ||
+    rgb3NumberRe$1.exec(str) ||
+    rgb3PercentageRe$1.exec(str);
+  if (rgb) return getRGB$1(rgb);
+
+  if (transparentRe$1.exec(str)) return getRGB$1([null, 0, 0, 0, 0]);
+
+  const cn = colorName[str.toLowerCase()];
+  if (cn) return getRGB$1([null, cn[0], cn[1], cn[2], 1]);
+
+  return null;
+};
+
+function hsl2rgb(hsl) {
+  var h = hsl[0] / 360,
+      s = hsl[1] / 100,
+      l = hsl[2] / 100,
+      t1, t2, t3, rgb, val;
+
+  if (s == 0) {
+    val = l * 255;
+    return [val, val, val];
+  }
+
+  if (l < 0.5)
+    t2 = l * (1 + s);
+  else
+    t2 = l + s - l * s;
+  t1 = 2 * l - t2;
+
+  rgb = [0, 0, 0];
+  for (var i = 0; i < 3; i++) {
+    t3 = h + 1 / 3 * - (i - 1);
+    t3 < 0 && t3++;
+    t3 > 1 && t3--;
+
+    if (6 * t3 < 1)
+      val = t1 + (t2 - t1) * 6 * t3;
+    else if (2 * t3 < 1)
+      val = t2;
+    else if (3 * t3 < 2)
+      val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+    else
+      val = t1;
+
+    rgb[i] = val * 255;
+  }
+
+  return rgb;
+}
+
+var hsl2rgb_1 = hsl2rgb;
+
+function clamp$2(val, min, max) {
+  return Math.min(Math.max(val, min), max);
+}
+
+var clamp_1 = clamp$2;
+
+var clamp$1 = clamp_1;
+
+function componentToHex(c) {
+  var value = Math.round(clamp$1(c, 0, 255));
+  var hex   = value.toString(16);
+
+  return hex.length == 1 ? "0" + hex : hex;
+}
+
+function rgb2hex(rgb) {
+  var alpha = rgb.length === 4 ? componentToHex(rgb[3] * 255) : "";
+
+  return "#" + componentToHex(rgb[0]) + componentToHex(rgb[1]) + componentToHex(rgb[2]) + alpha;
+}
+
+var rgb2hex_1 = rgb2hex;
+
+function rgb2hsl(rgb) {
+  var r = rgb[0]/255,
+      g = rgb[1]/255,
+      b = rgb[2]/255,
+      min = Math.min(r, g, b),
+      max = Math.max(r, g, b),
+      delta = max - min,
+      h, s, l;
+
+  if (max == min)
+    h = 0;
+  else if (r == max)
+    h = (g - b) / delta;
+  else if (g == max)
+    h = 2 + (b - r) / delta;
+  else if (b == max)
+    h = 4 + (r - g)/ delta;
+
+  h = Math.min(h * 60, 360);
+
+  if (h < 0)
+    h += 360;
+
+  l = (min + max) / 2;
+
+  if (max == min)
+    s = 0;
+  else if (l <= 0.5)
+    s = delta / (max + min);
+  else
+    s = delta / (2 - max - min);
+
+  return [h, s * 100, l * 100];
+}
+
+var rgb2hsl_1 = rgb2hsl;
+
+/**
+ * mix-css-color
+ * @version v0.2.0
+ * @link http://github.com/noeldelgado/mix-css-color/
+ * @license MIT
+ */
+
+function parseColor(color) {
+  const res = parseCSSColor$1(color);
+  if (res === null) return null;
+  if (res.type === 'hsl') res.values = hsl2rgb_1(res.values);
+  return res;
+}
+
+/**
+ * Mix two colors together in variable proportion. Opacity is included in the calculations.
+ * Copyright (c) 2006-2009 Hampton Catlin, Natalie Weizenbaum, and Chris Eppstein
+ * http://sass-lang.com
+ * @see https://github.com/less/less.js/blob/cae5021358a5fca932c32ed071f652403d07def8/lib/less/functions/color.js#L302
+ */
+function mix(color1, color2, percentage = 50) {
+  const c1 = parseColor(color1);
+  const c2 = parseColor(color2);
+
+  if (!c1 || !c2) return null;
+
+  const p = Math.min(Math.max(0, percentage), 100) / 100.0;
+  const w = p * 2 - 1;
+  const a = c1.alpha - c2.alpha;
+  const w1 = ((w * a === -1 ? w : (w + a) / (1 + w * a)) + 1) / 2.0;
+  const w2 = 1 - w1;
+  const [r, g, b] = c1.values.map((c, i) => Math.round(c1.values[i] * w1 + c2.values[i] * w2));
+  const alpha = parseFloat((c1.alpha * p + c2.alpha * (1 - p)).toFixed(8));
+
+  return {
+    hex: rgb2hex_1([r, g, b]),
+    hexa: rgb2hex_1([r, g, b, alpha]),
+    rgba: [r, g, b, alpha],
+    hsla: [...rgb2hsl_1([r, g, b]).map(Math.round), alpha]
+  };
+}
+
+const pattern = /^#([a-f0-9]{3,4}|[a-f0-9]{4}(?:[a-f0-9]{2}){1,2})\b$/;
+var hexRe = new RegExp(pattern, 'i');
+
+const float = '-?\\d*(?:\\.\\d+)';
+
+const number = `(${float}?)`;
+const percentage = `(${float}?%)`;
+const numberOrPercentage = `(${float}?%?)`;
+
+const pattern$1 = `^
+  hsla?\\(
+    \\s*(-?\\d*(?:\\.\\d+)?(?:deg|rad|turn)?)\\s*,
+    \\s*${percentage}\\s*,
+    \\s*${percentage}\\s*
+    (?:,\\s*${numberOrPercentage}\\s*)?
+  \\)
+  $
+`.replace(/\n|\s/g, '');
+
+var hsl3Re = new RegExp(pattern$1);
+
+const pattern$2 = `^
+  hsla?\\(
+    \\s*(-?\\d*(?:\\.\\d+)?(?:deg|rad|turn)?)\\s*
+    \\s+${percentage}
+    \\s+${percentage}
+    \\s*(?:\\s*\\/\\s*${numberOrPercentage}\\s*)?
+  \\)
+  $
+`.replace(/\n|\s/g, '');
+
+var hsl4Re = new RegExp(pattern$2);
+
+const pattern$3 = `^
+  rgba?\\(
+    \\s*${number}\\s*,
+    \\s*${number}\\s*,
+    \\s*${number}\\s*
+    (?:,\\s*${numberOrPercentage}\\s*)?
+  \\)
+  $
+`.replace(/\n|\s/g, '');
+
+var rgb3NumberRe = new RegExp(pattern$3);
+
+const pattern$4 = `^
+  rgba?\\(
+    \\s*${percentage}\\s*,
+    \\s*${percentage}\\s*,
+    \\s*${percentage}\\s*
+    (?:,\\s*${numberOrPercentage}\\s*)?
+  \\)
+  $
+`.replace(/\n|\s/g, '');
+
+var rgb3PercentageRe = new RegExp(pattern$4);
+
+const pattern$5 = `^
+  rgba?\\(
+    \\s*${number}
+    \\s+${number}
+    \\s+${number}
+    \\s*(?:\\s*\\/\\s*${numberOrPercentage}\\s*)?
+  \\)
+$
+`.replace(/\n|\s/g, '');
+
+var rgb4NumberRe = new RegExp(pattern$5);
+
+const pattern$6 = `^
+  rgba?\\(
+    \\s*${percentage}
+    \\s+${percentage}
+    \\s+${percentage}
+    \\s*(?:\\s*\\/\\s*${numberOrPercentage}\\s*)?
+  \\)
+$
+`.replace(/\n|\s/g, '');
+
+var rgb4PercentageRe = new RegExp(pattern$6);
+
+const pattern$7 = /^transparent$/;
+var transparentRe = new RegExp(pattern$7, 'i');
+
+const clamp = (num, min, max) => Math.min(Math.max(min, num), max);
+
+/* 500 => 255, -10 => 0, 128 => 128 */
+const parseRGB = (num) => {
+  let n = num;
+  if (typeof n !== 'number') n = n.endsWith('%') ? (parseFloat(n) * 255) / 100 : parseFloat(n);
+  return clamp(Math.round(n), 0, 255);
+};
+
+/* 200 => 100, -100 => 0, 50 => 50 */
+const parsePercentage = (percentage) => clamp(parseFloat(percentage), 0, 100);
+
+/* '50%' => 5.0, 200 => 1, -10 => 0 */
+function parseAlpha(alpha) {
+  let a = alpha;
+  if (typeof a !== 'number') a = a.endsWith('%') ? parseFloat(a) / 100 : parseFloat(a);
+  return clamp(a, 0, 1);
+}
+
+function getHEX(hex) {
+  const [r, g, b, a] = hex2Rgb__default["default"](hex, { format: 'array' });
+  return getRGB([null, ...[r, g, b, a]]);
+}
+
+function getHSL([, h, s, l, a = 1]) {
+  let hh = h;
+  if (hh.endsWith('turn')) {
+    hh = (parseFloat(hh) * 360) / 1;
+  } else if (hh.endsWith('rad')) {
+    hh = Math.round((parseFloat(hh) * 180) / Math.PI);
+  } else {
+    hh = parseFloat(hh);
+  }
+  return {
+    type: 'hsl',
+    values: [hh, parsePercentage(s), parsePercentage(l)],
+    alpha: parseAlpha(a === null ? 1 : a)
+  };
+}
+
+function getRGB([, r, g, b, a = 1]) {
+  return {
+    type: 'rgb',
+    values: [r, g, b].map(parseRGB),
+    alpha: parseAlpha(a === null ? 1 : a)
+  };
+}
+
+/**
+ * parse-css-color
+ * @version v0.2.0
+ * @link http://github.com/noeldelgado/parse-css-color/
+ * @license MIT
+ */
+
+const parseCSSColor = (str) => {
+  if (typeof str !== 'string') return null;
+
+  const hex = hexRe.exec(str);
+  if (hex) return getHEX(hex[0]);
+
+  const hsl = hsl4Re.exec(str) || hsl3Re.exec(str);
+  if (hsl) return getHSL(hsl);
+
+  const rgb =
+    rgb4NumberRe.exec(str) ||
+    rgb4PercentageRe.exec(str) ||
+    rgb3NumberRe.exec(str) ||
+    rgb3PercentageRe.exec(str);
+  if (rgb) return getRGB(rgb);
+
+  if (transparentRe.exec(str)) return getRGB([null, 0, 0, 0, 0]);
+
+  const cn = colorName[str.toLowerCase()];
+  if (cn) return getRGB([null, cn[0], cn[1], cn[2], 1]);
+
+  return null;
+};
+
+/**
+ * values.js - Get the tints and shades of a color
+ * @version v2.1.1
+ * @link http://noeldelgado.github.io/values.js/
+ * @license MIT
+ */
+const defaultNumberParam = (v, d) => (v === null || isNaN(v) || typeof v === 'string' ? d : v);
+class Values {
+  constructor(color = '#000', type = 'base', weight = 0) {
+    [this.rgb, this.alpha, this.type, this.weight] = [[0, 0, 0], 1, type, weight];
+    const c = color === null ? '#000' : color;
+    if (typeof c !== 'string') throw new TypeError(`Input should be a string: ${c}`);
+    const parsed = parseCSSColor(c);
+    if (!parsed) throw new Error(`Unable to parse color from string: ${c}`);
+    return this[`_setFrom${parsed.type.toUpperCase()}`]([...parsed.values, parsed.alpha]);
+  }
+  get hex() {
+    return this.hexString().replace(/^#/, '');
+  }
+  setColor(color) {
+    const parsed = parseCSSColor(color);
+    if (!parsed) return null;
+    return this[`_setFrom${parsed.type.toUpperCase()}`]([...parsed.values, parsed.alpha]);
+  }
+  tint(weight, w = defaultNumberParam(weight, 50)) {
+    return new Values(`rgb(${mix('#fff', this.rgbString(), w).rgba})`, 'tint', w);
+  }
+  shade(weight, w = defaultNumberParam(weight, 50)) {
+    return new Values(`rgb(${mix('#000', this.rgbString(), w).rgba})`, 'shade', w);
+  }
+  tints(weight, w = defaultNumberParam(weight, 10)) {
+    return Array.from({ length: 100 / w }, (_, i) => this.tint((i + 1) * w));
+  }
+  shades(weight, w = defaultNumberParam(weight, 10)) {
+    return Array.from({ length: 100 / w }, (_, i) => this.shade((i + 1) * w));
+  }
+  all(weight = 10) {
+    return [...this.tints(weight).reverse(), Object.assign(this), ...this.shades(weight)];
+  }
+  hexString() {
+    return rgb2hex_1(this.alpha >= 1 ? this.rgb : [...this.rgb, this.alpha]);
+  }
+  rgbString() {
+    const channels = (this.alpha >= 1 ? this.rgb : [...this.rgb, this.alpha]).join(', ');
+    return `${this.alpha >= 1 ? 'rgb' : 'rgba'}(${channels})`;
+  }
+  getBrightness() {
+    return Math.round((this.rgb.reduce((a, b) => a + b) / (255 * 3)) * 100);
+  }
+  _setFromRGB([r, g, b, a]) {
+    [this.rgb, this.alpha] = [[r, g, b], a];
+    return this;
+  }
+  _setFromHSL([h, s, l, a]) {
+    [this.rgb, this.alpha] = [hsl2rgb_1([h, s, l]).map(Math.round), a];
+    return this;
+  }
+}
+Values.VERSION = 'v2.1.1';
+
+var Values$1 = Values;
+
+const STEPS = [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95];
+
+const createColorScales = base => {
+  const colorValues = new Values$1(base);
+  return { ...STEPS.reduce((acc, step) => ({ ...acc,
+      [`lighten${step}`]: colorValues.tint(step).hexString(),
+      [`darken${step}`]: colorValues.shade(step).hexString()
+    }), {}),
+    base: colorValues.hexString()
+  };
+};
+
+const BASE_COLORS = {
+  antiFlashWhite: '#f1f2f3',
   blue: '#1dbeee',
-  blueDark30: '#1485a7',
-  blueDark75: '#07303c',
-  blueLight30: '#61d2f3',
-  blueLight75: '#c7effb',
-  blueLight90: '#e8f9fd',
-  dodgerBlue: '#4568fb',
-  dodgerBlueDark30: '#3049b0',
-  dodgerBlueLight30: '#7d95fc',
-  dodgerBlueLight75: '#d1d9fe',
-  dodgerBlueLight90: '#ecf0ff',
+  blue1: '#5a68e2',
+  nightBlue: '#353957',
+  darkBlue: '#25006e',
+  maasstrichtBlue: '#001f23',
+  ultramarineBlue: '#4568fb',
+  aliceBlue: '#ecf0ff',
+  jordyBlue: '#92abfc',
+  cornflowerBlue: '#5d80f0',
+  paua: '#130066',
   green: '#01b39c',
-  greenDark15: '#019885',
-  greenDark30: '#017d6d',
-  greenDark75: '#002d27',
-  greenLight30: '#4dcaba',
-  greenLight75: '#c0ece6',
-  greenLight90: '#e6f7f5',
+  emerald: '#5ace7d',
+  pineGreen: '#017d6d',
+  honeydew: '#f0fef4',
   grey: '#a3a6ac',
-  greyDark15: '#8b8d92',
-  greyDark30: '#727478',
-  greyDark45: '#5a5b5f',
-  greyDark60: '#414245',
-  greyDark75: '#292a2b',
-  greyLight45: '#ccced1',
-  greyLight60: '#dadbde',
-  greyLight75: '#e8e9ea',
-  greyLight85: '#f1f2f3',
-  greyLight90: '#f6f6f7',
-  greyLight95: '#fafbfb',
+  currant: '#48000a',
+  sonicSilver: '#737479',
   grotesqueGreen: '#6af293',
-  grotesqueGreenDark45: '#3a8551',
-  grotesqueGreenLight60: '#c3fad4',
-  grotesqueGreenLight75: '#dafce4',
-  grotesqueGreenLight90: '#f0fef4',
-  orange: '#ffa234',
-  orangeDark15: '#d98a2c',
-  orangeDark30: '#b37124',
-  orangeDark75: '#40290d',
-  orangeLight30: '#ffbe71',
-  orangeLight75: '#ffe8cc',
-  orangeLight90: '#fff6eb',
+  mellowApricot: '#ffbe71',
+  deepSaffron: '#ffa234',
   pink: '#fe56aa',
-  pinkDark15: '#cf4991',
-  pinkDark30: '#b23c77',
-  pinkDark45: '#8c2f5e',
-  pinkDark75: '#40162b',
-  pinkLight30: '#fe89c4',
-  pinkLight45: '#fea2d0',
-  pinkLight75: '#fcd5ea',
-  pinkLight90: '#ffeef7',
+  hitPink: '#ffad79',
+  apple: '#e3602a',
   purple: '#be83cf',
-  purpleDark15: '#a26fb0',
-  red: '#de350b',
-  redDark15: '#bd2d09',
-  redDark30: '#9b2508',
-  redDark75: '#380d03',
-  redLight15: '#e35330',
-  redLight30: '#e87254',
-  redLight60: '#f2ae9d',
-  redLight75: '#f7cdc2',
-  redLight90: '#fcebe7',
+  scarletGum: '#401960',
+  vodka: '#b5c3fd',
+  peach: '#f8ac7d',
+  pastelRed: '#f46363',
+  vermilion: '#de350b',
+  linen: '#fcebe7',
   smalt: '#003580',
-  smaltDark75: '#000d20',
-  smaltLight30: '#4d72a6',
-  smaltLight45: '#7390b9',
-  smaltLight75: '#bfcddf',
-  smaltLight90: '#e6ebf2',
   violet: '#7622d7',
-  violetDark15: '#641db7',
-  violetDark30: '#531897',
-  violetDark45: '#411376',
-  violetDark75: '#1e0936',
-  violetLight30: '#9f64e3',
-  violetLight60: '#c8a7ef',
-  violetLight75: '#ddc8f5',
-  violetLight90: '#f1e9fb',
-  white: '#ffffff',
+  violet1: '#8505a2',
+  mauve: '#c38cee',
   yellow: '#fadb14',
-  yellowDark15: '#d5ba11',
-  yellowDark75: '#3f3705',
-  yellowLight60: '#fdf1a1',
-  yellowLight90: '#fffbe8'
+  seashell: '#ebf4ff',
+  gold: '#ffd500'
+};
+const colorScales = Object.entries(BASE_COLORS).reduce((acc, [key, value]) => ({ ...acc,
+  [key]: createColorScales(value)
+}), {});
+
+const {
+  blue,
+  ultramarineBlue: ultramarineBlue$1,
+  green,
+  grey: grey$2,
+  grotesqueGreen,
+  deepSaffron: deepSaffron$2,
+  pink,
+  purple,
+  vermilion: vermilion$2,
+  smalt,
+  violet,
+  yellow
+} = colorScales;
+const palette$6 = {
+  black: '#000000',
+  white: '#ffffff',
+  blue: blue.base,
+  blueDark30: blue.darken30,
+  blueDark75: blue.darken75,
+  blueLight30: blue.lighten30,
+  blueLight75: blue.lighten75,
+  blueLight90: blue.lighten90,
+  dodgerBlue: ultramarineBlue$1.base,
+  dodgerBlueDark30: ultramarineBlue$1.darken30,
+  dodgerBlueLight30: ultramarineBlue$1.lighten30,
+  dodgerBlueLight75: ultramarineBlue$1.lighten75,
+  dodgerBlueLight90: ultramarineBlue$1.lighten90,
+  green: green.base,
+  greenDark15: green.darken15,
+  greenDark30: green.darken30,
+  greenDark75: green.darken75,
+  greenLight30: green.lighten30,
+  greenLight75: green.lighten75,
+  greenLight90: green.lighten90,
+  grey: grey$2.base,
+  greyDark15: grey$2.darken15,
+  greyDark30: grey$2.darken30,
+  greyDark45: grey$2.darken45,
+  greyDark60: grey$2.darken60,
+  greyDark75: grey$2.darken75,
+  greyLight45: grey$2.lighten45,
+  greyLight60: grey$2.lighten60,
+  greyLight75: grey$2.lighten75,
+  greyLight85: grey$2.lighten85,
+  greyLight90: grey$2.lighten90,
+  greyLight95: grey$2.lighten95,
+  grotesqueGreen: grotesqueGreen.base,
+  grotesqueGreenDark45: grotesqueGreen.darken45,
+  grotesqueGreenLight60: grotesqueGreen.lighten60,
+  grotesqueGreenLight75: grotesqueGreen.lighten75,
+  grotesqueGreenLight90: grotesqueGreen.lighten90,
+  orange: deepSaffron$2.base,
+  orangeDark15: deepSaffron$2.darken15,
+  orangeDark30: deepSaffron$2.darken30,
+  orangeDark75: deepSaffron$2.darken75,
+  orangeLight30: deepSaffron$2.lighten30,
+  orangeLight75: deepSaffron$2.lighten75,
+  orangeLight90: deepSaffron$2.lighten90,
+  pink: pink.base,
+  pinkDark15: pink.darken15,
+  pinkDark30: pink.darken30,
+  pinkDark45: pink.darken45,
+  pinkDark75: pink.darken75,
+  pinkLight30: pink.lighten30,
+  pinkLight45: pink.lighten45,
+  pinkLight75: pink.lighten75,
+  pinkLight90: pink.lighten90,
+  purple: purple.base,
+  purpleDark15: purple.darken15,
+  red: vermilion$2.base,
+  redDark15: vermilion$2.darken15,
+  redDark30: vermilion$2.darken30,
+  redDark75: vermilion$2.darken75,
+  redLight15: vermilion$2.lighten15,
+  redLight30: vermilion$2.lighten30,
+  redLight60: vermilion$2.lighten60,
+  redLight75: vermilion$2.lighten75,
+  redLight90: vermilion$2.lighten90,
+  smalt: smalt.base,
+  smaltDark75: smalt.darken75,
+  smaltLight30: smalt.lighten30,
+  smaltLight45: smalt.lighten45,
+  smaltLight75: smalt.lighten75,
+  smaltLight90: smalt.lighten90,
+  violet: violet.base,
+  violetDark15: violet.darken15,
+  violetDark30: violet.darken30,
+  violetDark45: violet.darken45,
+  violetDark75: violet.darken75,
+  violetLight30: violet.lighten30,
+  violetLight60: violet.lighten60,
+  violetLight75: violet.lighten75,
+  violetLight90: violet.lighten90,
+  yellow: yellow.base,
+  yellowDark15: yellow.darken15,
+  yellowDark75: yellow.darken75,
+  yellowLight60: yellow.lighten60,
+  yellowLight90: yellow.lighten90
+};
+
+const {
+  maasstrichtBlue,
+  grey: grey$1,
+  pastelRed: pastelRed$1,
+  mellowApricot,
+  emerald: emerald$1,
+  vodka,
+  vermilion: vermilion$1,
+  deepSaffron: deepSaffron$1,
+  pineGreen,
+  ultramarineBlue,
+  sonicSilver,
+  linen,
+  seashell,
+  honeydew,
+  aliceBlue,
+  antiFlashWhite,
+  apple: apple$1
+} = colorScales;
+const palette$5 = {
+  black: '#000000',
+  white: '#ffffff',
+  greyLight95: grey$1.lighten95,
+  greyLight90: grey$1.lighten90,
+  greyLight75: grey$1.lighten75,
+  greyLight45: grey$1.lighten45,
+  greyLight30: grey$1.lighten30,
+  grey: grey$1.base,
+  maasstrichtBlueLight90: maasstrichtBlue.lighten90,
+  maasstrichtBlueLight80: maasstrichtBlue.lighten80,
+  maasstrichtBlueLight50: maasstrichtBlue.lighten50,
+  maasstrichtBlueLight30: maasstrichtBlue.lighten30,
+  maasstrichtBlue: maasstrichtBlue.base,
+  pastelRed: pastelRed$1.base,
+  mellowApricot: mellowApricot.base,
+  emerald: emerald$1.base,
+  vodka: vodka.base,
+  vermilion: vermilion$1.base,
+  deepSaffron: deepSaffron$1.base,
+  pineGreen: pineGreen.base,
+  ultramarineBlue: ultramarineBlue.base,
+  sonicSilver: sonicSilver.base,
+  linen: linen.base,
+  seashell: seashell.base,
+  honeydew: honeydew.base,
+  aliceBlue: aliceBlue.base,
+  antiFlashWhite: antiFlashWhite.base,
+  apple: apple$1.base
+};
+
+const {
+  emerald,
+  blue1,
+  nightBlue,
+  darkBlue,
+  grey,
+  deepSaffron,
+  peach,
+  vermilion,
+  pastelRed,
+  mauve
+} = colorScales;
+const palette$4 = { ...palette$5,
+  nightBlue: nightBlue.base,
+  blueLight60: blue1.lighten60,
+  blue: blue1.base,
+  darkBlue: darkBlue.base,
+  darkBlueDark15: darkBlue.darken15,
+  green: emerald.base,
+  greyDark45: grey.darken45,
+  greyDark75: grey.darken75,
+  greyLight30: grey.lighten30,
+  greyLight45: grey.lighten45,
+  greyLight90: grey.lighten90,
+  orangeLight30: deepSaffron.lighten30,
+  peach: peach.base,
+  peachLight75: peach.lighten75,
+  red: vermilion.base,
+  pastelRed: pastelRed.base,
+  mauve: mauve.base
+};
+
+const {
+  apple,
+  currant
+} = colorScales;
+const palette$3 = { ...palette$5,
+  apple: apple.base,
+  currant: currant.base
+};
+
+const {
+  scarletGum,
+  violet1
+} = colorScales;
+const palette$2 = { ...palette$5,
+  scarletGumLight30: scarletGum.lighten30,
+  scarletGumLight50: scarletGum.lighten50,
+  scarletGumLight80: scarletGum.lighten80,
+  scarletGumLight90: scarletGum.lighten90,
+  scarletGum: scarletGum.base,
+  violetLight30: violet1.lighten30,
+  violetLight50: violet1.lighten50,
+  violetLight80: violet1.lighten80,
+  violetLight90: violet1.lighten90,
+  violet: violet1.base
+};
+
+const {
+  jordyBlue,
+  cornflowerBlue,
+  paua
+} = colorScales;
+const palette$1 = { ...palette$5,
+  jordyBlueLight30: jordyBlue.lighten30,
+  jordyBlueLight50: jordyBlue.lighten50,
+  jordyBlueLight70: jordyBlue.lighten70,
+  jordyBlueLight90: jordyBlue.lighten90,
+  jordyBlue: jordyBlue.base,
+  cornflowerBlue: cornflowerBlue.base,
+  paua: paua.base
+};
+
+const {
+  gold
+} = colorScales;
+const palette = { ...palette$5,
+  goldLight20: gold.lighten20,
+  goldLight50: gold.lighten50,
+  goldLight70: gold.lighten70,
+  goldLight90: gold.lighten90,
+  gold: gold.base
 };
 
-module.exports = palette;
+exports.colorScales = colorScales;
+exports["default"] = palette$6;
+exports.defaultMobilePalette = palette$5;
+exports.defaultWebPalette = palette$6;
+exports.eBensPalette = palette$4;
+exports.jobsPalette = palette$3;
+exports.swagPalette = palette$2;
+exports.walletPalette = palette$1;
+exports.workPalette = palette;