@d3plus/color 3.0.0-alpha.0

package/umd/d3plus-color.full.js

@@ -0,0 +1,710 @@
+/*
+  @d3plus/color v3.0.0
+  Color functions that extent the ability of d3-color.
+  Copyright (c) 2025 D3plus - https://d3plus.org
+  @license MIT
+*/
+
+(function (factory) {
+  typeof define === 'function' && define.amd ? define(factory) :
+  factory();
+})((function () { 'use strict';
+
+  if (typeof window !== "undefined") {
+    (function () {
+      try {
+        if (typeof SVGElement === 'undefined' || Boolean(SVGElement.prototype.innerHTML)) {
+          return;
+        }
+      } catch (e) {
+          return;
+      }
+
+      function serializeNode (node) {
+        switch (node.nodeType) {
+          case 1:
+            return serializeElementNode(node);
+          case 3:
+            return serializeTextNode(node);
+          case 8:
+            return serializeCommentNode(node);
+        }
+      }
+
+      function serializeTextNode (node) {
+          return node.textContent.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+      }
+
+      function serializeCommentNode (node) {
+          return '<!--' + node.nodeValue + '-->'
+      }
+
+      function serializeElementNode (node) {
+          var output = '';
+
+          output += '<' + node.tagName;
+
+          if (node.hasAttributes()) {
+              [].forEach.call(node.attributes, function(attrNode) {
+                  output += ' ' + attrNode.name + '="' + attrNode.value + '"';
+              });
+          }
+
+          output += '>';
+
+          if (node.hasChildNodes()) {
+              [].forEach.call(node.childNodes, function(childNode) {
+                  output += serializeNode(childNode);
+              });
+          }
+
+          output += '</' + node.tagName + '>';
+
+          return output;
+      }
+
+      Object.defineProperty(SVGElement.prototype, 'innerHTML', {
+        get: function () {
+          var output = '';
+
+          [].forEach.call(this.childNodes, function(childNode) {
+              output += serializeNode(childNode);
+          });
+
+          return output;
+        },
+        set: function (markup) {
+          while (this.firstChild) {
+            this.removeChild(this.firstChild);
+          }
+
+          try {
+            var dXML = new DOMParser();
+            dXML.async = false;
+
+            var sXML = '<svg xmlns=\'http://www.w3.org/2000/svg\' xmlns:xlink=\'http://www.w3.org/1999/xlink\'>' + markup + '</svg>';
+            var svgDocElement = dXML.parseFromString(sXML, 'text/xml').documentElement;
+
+            [].forEach.call(svgDocElement.childNodes, function(childNode) {
+                this.appendChild(this.ownerDocument.importNode(childNode, true));
+            }.bind(this));
+          } catch (e) {
+              throw new Error('Error parsing markup string');
+          }
+        }
+      });
+
+      Object.defineProperty(SVGElement.prototype, 'innerSVG', {
+        get: function () {
+          return this.innerHTML;
+        },
+        set: function (markup) {
+          this.innerHTML = markup;
+        }
+      });
+
+    })();
+  }
+
+}));
+
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define('@d3plus/color', ['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.d3plus = {}));
+})(this, (function (exports) {
+  function define(constructor, factory, prototype) {
+      constructor.prototype = factory.prototype = prototype;
+      prototype.constructor = constructor;
+  }
+  function extend(parent, definition) {
+      var prototype = Object.create(parent.prototype);
+      for(var key in definition)prototype[key] = definition[key];
+      return prototype;
+  }
+
+  function Color() {}
+  var darker = 0.7;
+  var brighter = 1 / darker;
+  var reI = "\\s*([+-]?\\d+)\\s*", reN = "\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)\\s*", reP = "\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)%\\s*", reHex = /^#([0-9a-f]{3,8})$/, reRgbInteger = new RegExp(`^rgb\\(${reI},${reI},${reI}\\)$`), reRgbPercent = new RegExp(`^rgb\\(${reP},${reP},${reP}\\)$`), reRgbaInteger = new RegExp(`^rgba\\(${reI},${reI},${reI},${reN}\\)$`), reRgbaPercent = new RegExp(`^rgba\\(${reP},${reP},${reP},${reN}\\)$`), reHslPercent = new RegExp(`^hsl\\(${reN},${reP},${reP}\\)$`), reHslaPercent = new RegExp(`^hsla\\(${reN},${reP},${reP},${reN}\\)$`);
+  var named = {
+      aliceblue: 0xf0f8ff,
+      antiquewhite: 0xfaebd7,
+      aqua: 0x00ffff,
+      aquamarine: 0x7fffd4,
+      azure: 0xf0ffff,
+      beige: 0xf5f5dc,
+      bisque: 0xffe4c4,
+      black: 0x000000,
+      blanchedalmond: 0xffebcd,
+      blue: 0x0000ff,
+      blueviolet: 0x8a2be2,
+      brown: 0xa52a2a,
+      burlywood: 0xdeb887,
+      cadetblue: 0x5f9ea0,
+      chartreuse: 0x7fff00,
+      chocolate: 0xd2691e,
+      coral: 0xff7f50,
+      cornflowerblue: 0x6495ed,
+      cornsilk: 0xfff8dc,
+      crimson: 0xdc143c,
+      cyan: 0x00ffff,
+      darkblue: 0x00008b,
+      darkcyan: 0x008b8b,
+      darkgoldenrod: 0xb8860b,
+      darkgray: 0xa9a9a9,
+      darkgreen: 0x006400,
+      darkgrey: 0xa9a9a9,
+      darkkhaki: 0xbdb76b,
+      darkmagenta: 0x8b008b,
+      darkolivegreen: 0x556b2f,
+      darkorange: 0xff8c00,
+      darkorchid: 0x9932cc,
+      darkred: 0x8b0000,
+      darksalmon: 0xe9967a,
+      darkseagreen: 0x8fbc8f,
+      darkslateblue: 0x483d8b,
+      darkslategray: 0x2f4f4f,
+      darkslategrey: 0x2f4f4f,
+      darkturquoise: 0x00ced1,
+      darkviolet: 0x9400d3,
+      deeppink: 0xff1493,
+      deepskyblue: 0x00bfff,
+      dimgray: 0x696969,
+      dimgrey: 0x696969,
+      dodgerblue: 0x1e90ff,
+      firebrick: 0xb22222,
+      floralwhite: 0xfffaf0,
+      forestgreen: 0x228b22,
+      fuchsia: 0xff00ff,
+      gainsboro: 0xdcdcdc,
+      ghostwhite: 0xf8f8ff,
+      gold: 0xffd700,
+      goldenrod: 0xdaa520,
+      gray: 0x808080,
+      green: 0x008000,
+      greenyellow: 0xadff2f,
+      grey: 0x808080,
+      honeydew: 0xf0fff0,
+      hotpink: 0xff69b4,
+      indianred: 0xcd5c5c,
+      indigo: 0x4b0082,
+      ivory: 0xfffff0,
+      khaki: 0xf0e68c,
+      lavender: 0xe6e6fa,
+      lavenderblush: 0xfff0f5,
+      lawngreen: 0x7cfc00,
+      lemonchiffon: 0xfffacd,
+      lightblue: 0xadd8e6,
+      lightcoral: 0xf08080,
+      lightcyan: 0xe0ffff,
+      lightgoldenrodyellow: 0xfafad2,
+      lightgray: 0xd3d3d3,
+      lightgreen: 0x90ee90,
+      lightgrey: 0xd3d3d3,
+      lightpink: 0xffb6c1,
+      lightsalmon: 0xffa07a,
+      lightseagreen: 0x20b2aa,
+      lightskyblue: 0x87cefa,
+      lightslategray: 0x778899,
+      lightslategrey: 0x778899,
+      lightsteelblue: 0xb0c4de,
+      lightyellow: 0xffffe0,
+      lime: 0x00ff00,
+      limegreen: 0x32cd32,
+      linen: 0xfaf0e6,
+      magenta: 0xff00ff,
+      maroon: 0x800000,
+      mediumaquamarine: 0x66cdaa,
+      mediumblue: 0x0000cd,
+      mediumorchid: 0xba55d3,
+      mediumpurple: 0x9370db,
+      mediumseagreen: 0x3cb371,
+      mediumslateblue: 0x7b68ee,
+      mediumspringgreen: 0x00fa9a,
+      mediumturquoise: 0x48d1cc,
+      mediumvioletred: 0xc71585,
+      midnightblue: 0x191970,
+      mintcream: 0xf5fffa,
+      mistyrose: 0xffe4e1,
+      moccasin: 0xffe4b5,
+      navajowhite: 0xffdead,
+      navy: 0x000080,
+      oldlace: 0xfdf5e6,
+      olive: 0x808000,
+      olivedrab: 0x6b8e23,
+      orange: 0xffa500,
+      orangered: 0xff4500,
+      orchid: 0xda70d6,
+      palegoldenrod: 0xeee8aa,
+      palegreen: 0x98fb98,
+      paleturquoise: 0xafeeee,
+      palevioletred: 0xdb7093,
+      papayawhip: 0xffefd5,
+      peachpuff: 0xffdab9,
+      peru: 0xcd853f,
+      pink: 0xffc0cb,
+      plum: 0xdda0dd,
+      powderblue: 0xb0e0e6,
+      purple: 0x800080,
+      rebeccapurple: 0x663399,
+      red: 0xff0000,
+      rosybrown: 0xbc8f8f,
+      royalblue: 0x4169e1,
+      saddlebrown: 0x8b4513,
+      salmon: 0xfa8072,
+      sandybrown: 0xf4a460,
+      seagreen: 0x2e8b57,
+      seashell: 0xfff5ee,
+      sienna: 0xa0522d,
+      silver: 0xc0c0c0,
+      skyblue: 0x87ceeb,
+      slateblue: 0x6a5acd,
+      slategray: 0x708090,
+      slategrey: 0x708090,
+      snow: 0xfffafa,
+      springgreen: 0x00ff7f,
+      steelblue: 0x4682b4,
+      tan: 0xd2b48c,
+      teal: 0x008080,
+      thistle: 0xd8bfd8,
+      tomato: 0xff6347,
+      turquoise: 0x40e0d0,
+      violet: 0xee82ee,
+      wheat: 0xf5deb3,
+      white: 0xffffff,
+      whitesmoke: 0xf5f5f5,
+      yellow: 0xffff00,
+      yellowgreen: 0x9acd32
+  };
+  define(Color, color, {
+      copy (channels) {
+          return Object.assign(new this.constructor, this, channels);
+      },
+      displayable () {
+          return this.rgb().displayable();
+      },
+      hex: color_formatHex,
+      formatHex: color_formatHex,
+      formatHex8: color_formatHex8,
+      formatHsl: color_formatHsl,
+      formatRgb: color_formatRgb,
+      toString: color_formatRgb
+  });
+  function color_formatHex() {
+      return this.rgb().formatHex();
+  }
+  function color_formatHex8() {
+      return this.rgb().formatHex8();
+  }
+  function color_formatHsl() {
+      return hslConvert(this).formatHsl();
+  }
+  function color_formatRgb() {
+      return this.rgb().formatRgb();
+  }
+  function color(format) {
+      var m, l;
+      format = (format + "").trim().toLowerCase();
+      return (m = reHex.exec(format)) ? (l = m[1].length, m = parseInt(m[1], 16), l === 6 ? rgbn(m) // #ff0000
+       : l === 3 ? new Rgb(m >> 8 & 0xf | m >> 4 & 0xf0, m >> 4 & 0xf | m & 0xf0, (m & 0xf) << 4 | m & 0xf, 1) // #f00
+       : l === 8 ? rgba(m >> 24 & 0xff, m >> 16 & 0xff, m >> 8 & 0xff, (m & 0xff) / 0xff) // #ff000000
+       : l === 4 ? rgba(m >> 12 & 0xf | m >> 8 & 0xf0, m >> 8 & 0xf | m >> 4 & 0xf0, m >> 4 & 0xf | m & 0xf0, ((m & 0xf) << 4 | m & 0xf) / 0xff) // #f000
+       : null // invalid hex
+      ) : (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) // rgb(255, 0, 0)
+       : (m = reRgbPercent.exec(format)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) // rgb(100%, 0%, 0%)
+       : (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1)
+       : (m = reRgbaPercent.exec(format)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) // rgb(100%, 0%, 0%, 1)
+       : (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%)
+       : (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1)
+       : named.hasOwnProperty(format) ? rgbn(named[format]) // eslint-disable-line no-prototype-builtins
+       : format === "transparent" ? new Rgb(NaN, NaN, NaN, 0) : null;
+  }
+  function rgbn(n) {
+      return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1);
+  }
+  function rgba(r, g, b, a) {
+      if (a <= 0) r = g = b = NaN;
+      return new Rgb(r, g, b, a);
+  }
+  function rgbConvert(o) {
+      if (!(o instanceof Color)) o = color(o);
+      if (!o) return new Rgb;
+      o = o.rgb();
+      return new Rgb(o.r, o.g, o.b, o.opacity);
+  }
+  function rgb(r, g, b, opacity) {
+      return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity);
+  }
+  function Rgb(r, g, b, opacity) {
+      this.r = +r;
+      this.g = +g;
+      this.b = +b;
+      this.opacity = +opacity;
+  }
+  define(Rgb, rgb, extend(Color, {
+      brighter (k) {
+          k = k == null ? brighter : Math.pow(brighter, k);
+          return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
+      },
+      darker (k) {
+          k = k == null ? darker : Math.pow(darker, k);
+          return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
+      },
+      rgb () {
+          return this;
+      },
+      clamp () {
+          return new Rgb(clampi(this.r), clampi(this.g), clampi(this.b), clampa(this.opacity));
+      },
+      displayable () {
+          return -0.5 <= this.r && this.r < 255.5 && -0.5 <= this.g && this.g < 255.5 && -0.5 <= this.b && this.b < 255.5 && 0 <= this.opacity && this.opacity <= 1;
+      },
+      hex: rgb_formatHex,
+      formatHex: rgb_formatHex,
+      formatHex8: rgb_formatHex8,
+      formatRgb: rgb_formatRgb,
+      toString: rgb_formatRgb
+  }));
+  function rgb_formatHex() {
+      return `#${hex(this.r)}${hex(this.g)}${hex(this.b)}`;
+  }
+  function rgb_formatHex8() {
+      return `#${hex(this.r)}${hex(this.g)}${hex(this.b)}${hex((isNaN(this.opacity) ? 1 : this.opacity) * 255)}`;
+  }
+  function rgb_formatRgb() {
+      const a = clampa(this.opacity);
+      return `${a === 1 ? "rgb(" : "rgba("}${clampi(this.r)}, ${clampi(this.g)}, ${clampi(this.b)}${a === 1 ? ")" : `, ${a})`}`;
+  }
+  function clampa(opacity) {
+      return isNaN(opacity) ? 1 : Math.max(0, Math.min(1, opacity));
+  }
+  function clampi(value) {
+      return Math.max(0, Math.min(255, Math.round(value) || 0));
+  }
+  function hex(value) {
+      value = clampi(value);
+      return (value < 16 ? "0" : "") + value.toString(16);
+  }
+  function hsla(h, s, l, a) {
+      if (a <= 0) h = s = l = NaN;
+      else if (l <= 0 || l >= 1) h = s = NaN;
+      else if (s <= 0) h = NaN;
+      return new Hsl(h, s, l, a);
+  }
+  function hslConvert(o) {
+      if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity);
+      if (!(o instanceof Color)) o = color(o);
+      if (!o) return new Hsl;
+      if (o instanceof Hsl) return o;
+      o = o.rgb();
+      var r = o.r / 255, g = o.g / 255, b = o.b / 255, min = Math.min(r, g, b), max = Math.max(r, g, b), h = NaN, s = max - min, l = (max + min) / 2;
+      if (s) {
+          if (r === max) h = (g - b) / s + (g < b) * 6;
+          else if (g === max) h = (b - r) / s + 2;
+          else h = (r - g) / s + 4;
+          s /= l < 0.5 ? max + min : 2 - max - min;
+          h *= 60;
+      } else {
+          s = l > 0 && l < 1 ? 0 : h;
+      }
+      return new Hsl(h, s, l, o.opacity);
+  }
+  function hsl(h, s, l, opacity) {
+      return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity);
+  }
+  function Hsl(h, s, l, opacity) {
+      this.h = +h;
+      this.s = +s;
+      this.l = +l;
+      this.opacity = +opacity;
+  }
+  define(Hsl, hsl, extend(Color, {
+      brighter (k) {
+          k = k == null ? brighter : Math.pow(brighter, k);
+          return new Hsl(this.h, this.s, this.l * k, this.opacity);
+      },
+      darker (k) {
+          k = k == null ? darker : Math.pow(darker, k);
+          return new Hsl(this.h, this.s, this.l * k, this.opacity);
+      },
+      rgb () {
+          var h = this.h % 360 + (this.h < 0) * 360, s = isNaN(h) || isNaN(this.s) ? 0 : this.s, l = this.l, m2 = l + (l < 0.5 ? l : 1 - l) * s, m1 = 2 * l - m2;
+          return new Rgb(hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2), hsl2rgb(h, m1, m2), hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2), this.opacity);
+      },
+      clamp () {
+          return new Hsl(clamph(this.h), clampt(this.s), clampt(this.l), clampa(this.opacity));
+      },
+      displayable () {
+          return (0 <= this.s && this.s <= 1 || isNaN(this.s)) && 0 <= this.l && this.l <= 1 && 0 <= this.opacity && this.opacity <= 1;
+      },
+      formatHsl () {
+          const a = clampa(this.opacity);
+          return `${a === 1 ? "hsl(" : "hsla("}${clamph(this.h)}, ${clampt(this.s) * 100}%, ${clampt(this.l) * 100}%${a === 1 ? ")" : `, ${a})`}`;
+      }
+  }));
+  function clamph(value) {
+      value = (value || 0) % 360;
+      return value < 0 ? value + 360 : value;
+  }
+  function clampt(value) {
+      return Math.max(0, Math.min(1, value || 0));
+  }
+  /* From FvD 13.37, CSS Color Module Level 3 */ function hsl2rgb(h, m1, m2) {
+      return (h < 60 ? m1 + (m2 - m1) * h / 60 : h < 180 ? m2 : h < 240 ? m1 + (m2 - m1) * (240 - h) / 60 : m1) * 255;
+  }
+
+  /**
+      @function colorAdd
+      @desc Adds two colors together.
+      @param {String} c1 The first color, a valid CSS color string.
+      @param {String} c2 The second color, also a valid CSS color string.
+      @param {String} [o1 = 1] Value from 0 to 1 of the first color's opacity.
+      @param {String} [o2 = 1] Value from 0 to 1 of the first color's opacity.
+      @returns {String}
+  */ function add(c1, c2, o1 = 1, o2 = 1) {
+      c1 = hsl(c1);
+      c2 = hsl(c2);
+      let d = Math.abs(c2.h * o2 - c1.h * o1);
+      if (d > 180) d -= 360;
+      let h = (Math.min(c1.h, c2.h) + d / 2) % 360;
+      const l = c1.l + (c2.l * o2 - c1.l * o1) / 2, s = c1.s + (c2.s * o2 - c1.s * o1) / 2;
+      // a = o1 + (o2 - o1) / 2;
+      if (h < 0) h += 360;
+      return hsl(`hsl(${h},${s * 100}%,${l * 100}%)`).toString();
+  // return hsl(`hsl(${h},${s * 100}%,${l * 100}%,${a})`).toString();
+  }
+
+  class InternMap extends Map {
+      get(key) {
+          return super.get(intern_get(this, key));
+      }
+      has(key) {
+          return super.has(intern_get(this, key));
+      }
+      set(key, value) {
+          return super.set(intern_set(this, key), value);
+      }
+      delete(key) {
+          return super.delete(intern_delete(this, key));
+      }
+      constructor(entries, key = keyof){
+          super();
+          Object.defineProperties(this, {
+              _intern: {
+                  value: new Map()
+              },
+              _key: {
+                  value: key
+              }
+          });
+          if (entries != null) for (const [key, value] of entries)this.set(key, value);
+      }
+  }
+  function intern_get({ _intern, _key }, value) {
+      const key = _key(value);
+      return _intern.has(key) ? _intern.get(key) : value;
+  }
+  function intern_set({ _intern, _key }, value) {
+      const key = _key(value);
+      if (_intern.has(key)) return _intern.get(key);
+      _intern.set(key, value);
+      return value;
+  }
+  function intern_delete({ _intern, _key }, value) {
+      const key = _key(value);
+      if (_intern.has(key)) {
+          value = _intern.get(key);
+          _intern.delete(key);
+      }
+      return value;
+  }
+  function keyof(value) {
+      return value !== null && typeof value === "object" ? value.valueOf() : value;
+  }
+
+  function initRange(domain, range) {
+      switch(arguments.length){
+          case 0:
+              break;
+          case 1:
+              this.range(domain);
+              break;
+          default:
+              this.range(range).domain(domain);
+              break;
+      }
+      return this;
+  }
+
+  const implicit = Symbol("implicit");
+  function ordinal() {
+      var index = new InternMap(), domain = [], range = [], unknown = implicit;
+      function scale(d) {
+          let i = index.get(d);
+          if (i === undefined) {
+              if (unknown !== implicit) return unknown;
+              index.set(d, i = domain.push(d) - 1);
+          }
+          return range[i % range.length];
+      }
+      scale.domain = function(_) {
+          if (!arguments.length) return domain.slice();
+          domain = [], index = new InternMap();
+          for (const value of _){
+              if (index.has(value)) continue;
+              index.set(value, domain.push(value) - 1);
+          }
+          return scale;
+      };
+      scale.range = function(_) {
+          return arguments.length ? (range = Array.from(_), scale) : range.slice();
+      };
+      scale.unknown = function(_) {
+          return arguments.length ? (unknown = _, scale) : unknown;
+      };
+      scale.copy = function() {
+          return ordinal(domain, range).unknown(unknown);
+      };
+      initRange.apply(scale, arguments);
+      return scale;
+  }
+
+  /**
+      @namespace {Object} colorDefaults
+      @desc A set of default color values used when assigning colors based on data.
+        *
+        * | Name | Default | Description |
+        * |---|---|---|
+        * | dark | "#555555" | Used in the [contrast](#contrast) function when the color given is very light. |
+        * | light | "#f7f7f7" | Used in the [contrast](#contrast) function when the color given is very dark. |
+        * | missing | "#cccccc" | Used in the [assign](#assign) function when the value passed is `null` or `undefined`. |
+        * | off | "#C44536" | Used in the [assign](#assign) function when the value passed is `false`. |
+        * | on | "#6A994E" | Used in the [assign](#assign) function when the value passed is `true`. |
+        * | scale | "#4281A4", "#F6AE2D", "#C44536", "#2A9D8F", "#6A994E", "#CEB54A", "#5E548E", "#C08497", "#99582A", "#8C8C99", "#1D3557", "#D08C60", "#6D2E46", "#8BB19C", "#52796F", "#5E60CE", "#985277", "#5C374C" | An ordinal scale used in the [assign](#assign) function for non-valid color strings and numbers. |
+  */ const defaults = {
+      dark: "#555555",
+      light: "#f7f7f7",
+      missing: "#cccccc",
+      off: "#C44536",
+      on: "#6A994E",
+      scale: ordinal().range([
+          "#4281A4",
+          "#F6AE2D",
+          "#C44536",
+          "#2A9D8F",
+          "#6A994E",
+          "#CEB54A",
+          "#5E548E",
+          "#C08497",
+          "#99582A",
+          "#8C8C99",
+          "#1D3557",
+          "#D08C60",
+          "#6D2E46",
+          "#8BB19C",
+          "#52796F",
+          "#5E60CE",
+          "#985277",
+          "#5C374C"
+      ])
+  };
+  /**
+      Returns a color based on a key, whether it is present in a user supplied object or in the default object.
+      @returns {String}
+      @private
+  */ function getColor(k, u = {}) {
+      return k in u ? u[k] : k in defaults ? defaults[k] : defaults.missing;
+  }
+
+  /**
+      @function colorAssign
+      @desc Assigns a color to a value using a predefined set of defaults.
+      @param {String} c A valid CSS color string.
+      @param {Object} [u = defaults] An object containing overrides of the default colors.
+      @returns {String}
+  */ function assign(c, u = {}) {
+      // If the value is null or undefined, set to grey.
+      if ([
+          null,
+          void 0
+      ].indexOf(c) >= 0) return getColor("missing", u);
+      else if (c === true) return getColor("on", u);
+      else if (c === false) return getColor("off", u);
+      const p = color(c);
+      // If the value is not a valid color string, use the color scale.
+      if (!p) return getColor("scale", u)(c);
+      return c.toString();
+  }
+
+  /**
+      @function colorContrast
+      @desc A set of default color values used when assigning colors based on data.
+      @param {String} c A valid CSS color string.
+      @param {Object} [u = defaults] An object containing overrides of the default colors.
+      @returns {String}
+  */ function contrast(c, u = {}) {
+      c = rgb(c);
+      const yiq = (c.r * 299 + c.g * 587 + c.b * 114) / 1000;
+      return yiq >= 128 ? getColor("dark", u) : getColor("light", u);
+  }
+
+  /**
+      @function colorLegible
+      @desc Darkens a color so that it will appear legible on a white background.
+      @param {String} c A valid CSS color string.
+      @returns {String}
+  */ function legible(c) {
+      c = hsl(c);
+      if (c.l > 0.45) {
+          if (c.s > 0.8) c.s = 0.8;
+          c.l = 0.45;
+      }
+      return c.toString();
+  }
+
+  /**
+      @function colorLighter
+      @desc Similar to d3.color.brighter, except that this also reduces saturation so that colors don't appear neon.
+      @param {String} c A valid CSS color string.
+      @param {String} [i = 0.5] A value from 0 to 1 dictating the strength of the function.
+      @returns {String}
+  */ function lighter(c, i = 0.5) {
+      c = hsl(c);
+      i *= 1 - c.l;
+      c.l += i;
+      c.s -= i;
+      return c.toString();
+  }
+
+  /**
+      @function colorSubtract
+      @desc Subtracts one color from another.
+      @param {String} c1 The base color, a valid CSS color string.
+      @param {String} c2 The color to remove from the base color, also a valid CSS color string.
+      @param {String} [o1 = 1] Value from 0 to 1 of the first color's opacity.
+      @param {String} [o2 = 1] Value from 0 to 1 of the first color's opacity.
+      @returns {String}
+  */ function subtract(c1, c2, o1 = 1, o2 = 1) {
+      c1 = hsl(c1);
+      c2 = hsl(c2);
+      let d = c2.h * o2 - c1.h * o1;
+      if (Math.abs(d) > 180) d -= 360;
+      let h = (c1.h - d) % 360;
+      const l = c1.l - (c2.l * o2 - c1.l * o1) / 2, s = c1.s - (c2.s * o2 - c1.s * o1) / 2;
+      // a = o1 - (o2 - o1) / 2;
+      if (h < 0) h += 360;
+      return hsl(`hsl(${h},${s * 100}%,${l * 100}%)`).toString();
+  // return hsl(`hsl(${h},${s * 100}%,${l * 100}%,${a})`).toString();
+  }
+
+  exports.colorAdd = add;
+  exports.colorAssign = assign;
+  exports.colorContrast = contrast;
+  exports.colorDefaults = defaults;
+  exports.colorLegible = legible;
+  exports.colorLighter = lighter;
+  exports.colorSubtract = subtract;
+
+}));
+//# sourceMappingURL=d3plus-color.full.js.map