@d3plus/format 3.0.0-alpha.0

package/umd/d3plus-format.full.js

@@ -0,0 +1,1745 @@
+/*
+  @d3plus/format v3.0.0
+  JavaScript formatters for localized numbers and dates.
+  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/format', ['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.d3plus = {}));
+})(this, (function (exports) {
+  function formatDecimal(x) {
+      return Math.abs(x = Math.round(x)) >= 1e21 ? x.toLocaleString("en").replace(/,/g, "") : x.toString(10);
+  }
+  // Computes the decimal coefficient and exponent of the specified number x with
+  // significant digits p, where x is positive and p is in [1, 21] or undefined.
+  // For example, formatDecimalParts(1.23) returns ["123", 0].
+  function formatDecimalParts(x, p) {
+      if ((i = (x = p ? x.toExponential(p - 1) : x.toExponential()).indexOf("e")) < 0) return null; // NaN, ±Infinity
+      var i, coefficient = x.slice(0, i);
+      // The string returned by toExponential either has the form \d\.\d+e[-+]\d+
+      // (e.g., 1.2e+3) or the form \de[-+]\d+ (e.g., 1e+3).
+      return [
+          coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient,
+          +x.slice(i + 1)
+      ];
+  }
+
+  function exponent(x) {
+      return x = formatDecimalParts(Math.abs(x)), x ? x[1] : NaN;
+  }
+
+  function formatGroup(grouping, thousands) {
+      return function(value, width) {
+          var i = value.length, t = [], j = 0, g = grouping[0], length = 0;
+          while(i > 0 && g > 0){
+              if (length + g + 1 > width) g = Math.max(1, width - length);
+              t.push(value.substring(i -= g, i + g));
+              if ((length += g + 1) > width) break;
+              g = grouping[j = (j + 1) % grouping.length];
+          }
+          return t.reverse().join(thousands);
+      };
+  }
+
+  function formatNumerals(numerals) {
+      return function(value) {
+          return value.replace(/[0-9]/g, function(i) {
+              return numerals[+i];
+          });
+      };
+  }
+
+  // [[fill]align][sign][symbol][0][width][,][.precision][~][type]
+  var re = /^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;
+  function formatSpecifier(specifier) {
+      if (!(match = re.exec(specifier))) throw new Error("invalid format: " + specifier);
+      var match;
+      return new FormatSpecifier({
+          fill: match[1],
+          align: match[2],
+          sign: match[3],
+          symbol: match[4],
+          zero: match[5],
+          width: match[6],
+          comma: match[7],
+          precision: match[8] && match[8].slice(1),
+          trim: match[9],
+          type: match[10]
+      });
+  }
+  formatSpecifier.prototype = FormatSpecifier.prototype; // instanceof
+  function FormatSpecifier(specifier) {
+      this.fill = specifier.fill === undefined ? " " : specifier.fill + "";
+      this.align = specifier.align === undefined ? ">" : specifier.align + "";
+      this.sign = specifier.sign === undefined ? "-" : specifier.sign + "";
+      this.symbol = specifier.symbol === undefined ? "" : specifier.symbol + "";
+      this.zero = !!specifier.zero;
+      this.width = specifier.width === undefined ? undefined : +specifier.width;
+      this.comma = !!specifier.comma;
+      this.precision = specifier.precision === undefined ? undefined : +specifier.precision;
+      this.trim = !!specifier.trim;
+      this.type = specifier.type === undefined ? "" : specifier.type + "";
+  }
+  FormatSpecifier.prototype.toString = function() {
+      return this.fill + this.align + this.sign + this.symbol + (this.zero ? "0" : "") + (this.width === undefined ? "" : Math.max(1, this.width | 0)) + (this.comma ? "," : "") + (this.precision === undefined ? "" : "." + Math.max(0, this.precision | 0)) + (this.trim ? "~" : "") + this.type;
+  };
+
+  // Trims insignificant zeros, e.g., replaces 1.2000k with 1.2k.
+  function formatTrim(s) {
+      out: for(var n = s.length, i = 1, i0 = -1, i1; i < n; ++i){
+          switch(s[i]){
+              case ".":
+                  i0 = i1 = i;
+                  break;
+              case "0":
+                  if (i0 === 0) i0 = i;
+                  i1 = i;
+                  break;
+              default:
+                  if (!+s[i]) break out;
+                  if (i0 > 0) i0 = 0;
+                  break;
+          }
+      }
+      return i0 > 0 ? s.slice(0, i0) + s.slice(i1 + 1) : s;
+  }
+
+  var prefixExponent;
+  function formatPrefixAuto(x, p) {
+      var d = formatDecimalParts(x, p);
+      if (!d) return x + "";
+      var coefficient = d[0], exponent = d[1], i = exponent - (prefixExponent = Math.max(-8, Math.min(8, Math.floor(exponent / 3))) * 3) + 1, n = coefficient.length;
+      return i === n ? coefficient : i > n ? coefficient + new Array(i - n + 1).join("0") : i > 0 ? coefficient.slice(0, i) + "." + coefficient.slice(i) : "0." + new Array(1 - i).join("0") + formatDecimalParts(x, Math.max(0, p + i - 1))[0]; // less than 1y!
+  }
+
+  function formatRounded(x, p) {
+      var d = formatDecimalParts(x, p);
+      if (!d) return x + "";
+      var coefficient = d[0], exponent = d[1];
+      return exponent < 0 ? "0." + new Array(-exponent).join("0") + coefficient : coefficient.length > exponent + 1 ? coefficient.slice(0, exponent + 1) + "." + coefficient.slice(exponent + 1) : coefficient + new Array(exponent - coefficient.length + 2).join("0");
+  }
+
+  var formatTypes = {
+      "%": (x, p)=>(x * 100).toFixed(p),
+      "b": (x)=>Math.round(x).toString(2),
+      "c": (x)=>x + "",
+      "d": formatDecimal,
+      "e": (x, p)=>x.toExponential(p),
+      "f": (x, p)=>x.toFixed(p),
+      "g": (x, p)=>x.toPrecision(p),
+      "o": (x)=>Math.round(x).toString(8),
+      "p": (x, p)=>formatRounded(x * 100, p),
+      "r": formatRounded,
+      "s": formatPrefixAuto,
+      "X": (x)=>Math.round(x).toString(16).toUpperCase(),
+      "x": (x)=>Math.round(x).toString(16)
+  };
+
+  function identity(x) {
+      return x;
+  }
+
+  var map = Array.prototype.map, prefixes = [
+      "y",
+      "z",
+      "a",
+      "f",
+      "p",
+      "n",
+      "µ",
+      "m",
+      "",
+      "k",
+      "M",
+      "G",
+      "T",
+      "P",
+      "E",
+      "Z",
+      "Y"
+  ];
+  function formatLocale$1(locale) {
+      var group = locale.grouping === undefined || locale.thousands === undefined ? identity : formatGroup(map.call(locale.grouping, Number), locale.thousands + ""), currencyPrefix = locale.currency === undefined ? "" : locale.currency[0] + "", currencySuffix = locale.currency === undefined ? "" : locale.currency[1] + "", decimal = locale.decimal === undefined ? "." : locale.decimal + "", numerals = locale.numerals === undefined ? identity : formatNumerals(map.call(locale.numerals, String)), percent = locale.percent === undefined ? "%" : locale.percent + "", minus = locale.minus === undefined ? "−" : locale.minus + "", nan = locale.nan === undefined ? "NaN" : locale.nan + "";
+      function newFormat(specifier) {
+          specifier = formatSpecifier(specifier);
+          var fill = specifier.fill, align = specifier.align, sign = specifier.sign, symbol = specifier.symbol, zero = specifier.zero, width = specifier.width, comma = specifier.comma, precision = specifier.precision, trim = specifier.trim, type = specifier.type;
+          // The "n" type is an alias for ",g".
+          if (type === "n") comma = true, type = "g";
+          else if (!formatTypes[type]) precision === undefined && (precision = 12), trim = true, type = "g";
+          // If zero fill is specified, padding goes after sign and before digits.
+          if (zero || fill === "0" && align === "=") zero = true, fill = "0", align = "=";
+          // Compute the prefix and suffix.
+          // For SI-prefix, the suffix is lazily computed.
+          var prefix = symbol === "$" ? currencyPrefix : symbol === "#" && /[boxX]/.test(type) ? "0" + type.toLowerCase() : "", suffix = symbol === "$" ? currencySuffix : /[%p]/.test(type) ? percent : "";
+          // What format function should we use?
+          // Is this an integer type?
+          // Can this type generate exponential notation?
+          var formatType = formatTypes[type], maybeSuffix = /[defgprs%]/.test(type);
+          // Set the default precision if not specified,
+          // or clamp the specified precision to the supported range.
+          // For significant precision, it must be in [1, 21].
+          // For fixed precision, it must be in [0, 20].
+          precision = precision === undefined ? 6 : /[gprs]/.test(type) ? Math.max(1, Math.min(21, precision)) : Math.max(0, Math.min(20, precision));
+          function format(value) {
+              var valuePrefix = prefix, valueSuffix = suffix, i, n, c;
+              if (type === "c") {
+                  valueSuffix = formatType(value) + valueSuffix;
+                  value = "";
+              } else {
+                  value = +value;
+                  // Determine the sign. -0 is not less than 0, but 1 / -0 is!
+                  var valueNegative = value < 0 || 1 / value < 0;
+                  // Perform the initial formatting.
+                  value = isNaN(value) ? nan : formatType(Math.abs(value), precision);
+                  // Trim insignificant zeros.
+                  if (trim) value = formatTrim(value);
+                  // If a negative value rounds to zero after formatting, and no explicit positive sign is requested, hide the sign.
+                  if (valueNegative && +value === 0 && sign !== "+") valueNegative = false;
+                  // Compute the prefix and suffix.
+                  valuePrefix = (valueNegative ? sign === "(" ? sign : minus : sign === "-" || sign === "(" ? "" : sign) + valuePrefix;
+                  valueSuffix = (type === "s" ? prefixes[8 + prefixExponent / 3] : "") + valueSuffix + (valueNegative && sign === "(" ? ")" : "");
+                  // Break the formatted value into the integer “value” part that can be
+                  // grouped, and fractional or exponential “suffix” part that is not.
+                  if (maybeSuffix) {
+                      i = -1, n = value.length;
+                      while(++i < n){
+                          if (c = value.charCodeAt(i), 48 > c || c > 57) {
+                              valueSuffix = (c === 46 ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix;
+                              value = value.slice(0, i);
+                              break;
+                          }
+                      }
+                  }
+              }
+              // If the fill character is not "0", grouping is applied before padding.
+              if (comma && !zero) value = group(value, Infinity);
+              // Compute the padding.
+              var length = valuePrefix.length + value.length + valueSuffix.length, padding = length < width ? new Array(width - length + 1).join(fill) : "";
+              // If the fill character is "0", grouping is applied after padding.
+              if (comma && zero) value = group(padding + value, padding.length ? width - valueSuffix.length : Infinity), padding = "";
+              // Reconstruct the final output based on the desired alignment.
+              switch(align){
+                  case "<":
+                      value = valuePrefix + value + valueSuffix + padding;
+                      break;
+                  case "=":
+                      value = valuePrefix + padding + value + valueSuffix;
+                      break;
+                  case "^":
+                      value = padding.slice(0, length = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length);
+                      break;
+                  default:
+                      value = padding + valuePrefix + value + valueSuffix;
+                      break;
+              }
+              return numerals(value);
+          }
+          format.toString = function() {
+              return specifier + "";
+          };
+          return format;
+      }
+      function formatPrefix(specifier, value) {
+          var f = newFormat((specifier = formatSpecifier(specifier), specifier.type = "f", specifier)), e = Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3, k = Math.pow(10, -e), prefix = prefixes[8 + e / 3];
+          return function(value) {
+              return f(k * value) + prefix;
+          };
+      }
+      return {
+          format: newFormat,
+          formatPrefix: formatPrefix
+      };
+  }
+
+  var locale$1;
+  var format$1;
+  defaultLocale$2({
+      thousands: ",",
+      grouping: [
+          3
+      ],
+      currency: [
+          "$",
+          ""
+      ]
+  });
+  function defaultLocale$2(definition) {
+      locale$1 = formatLocale$1(definition);
+      format$1 = locale$1.format;
+      locale$1.formatPrefix;
+      return locale$1;
+  }
+
+  /**
+      @namespace {Object} formatLocale
+      @desc A set of default locale formatters used when assigning suffixes and currency in numbers.
+        *
+        * | Name | Default | Description |
+        * |---|---|---|
+        * | separator | "" | Separation between the number with the suffix. |
+        * | suffixes | [] | List of suffixes used to format numbers. |
+        * | grouping | [3] | The array of group sizes, |
+        * | delimiters | {thousands: ",", decimal: "."} | Decimal and group separators. |
+        * | currency | ["$", ""] | The currency prefix and suffix. |
+  */ var defaultLocale$1 = {
+      "ar-SA": {
+          separator: "",
+          suffixes: [
+              "y",
+              "z",
+              "a",
+              "f",
+              "p",
+              "n",
+              "µ",
+              "m",
+              "",
+              " ألف",
+              " مليون",
+              " بليون",
+              " تريليون",
+              " كوادريليون",
+              " كوينتيليون",
+              " سكستليون",
+              "سبتيليون"
+          ],
+          grouping: [
+              3
+          ],
+          delimiters: {
+              thousands: ",",
+              decimal: "."
+          },
+          currency: [
+              "SAR ",
+              ""
+          ]
+      },
+      "en-GB": {
+          separator: "",
+          suffixes: [
+              "y",
+              "z",
+              "a",
+              "f",
+              "p",
+              "n",
+              "µ",
+              "m",
+              "",
+              "k",
+              "M",
+              "B",
+              "T",
+              "q",
+              "Q",
+              "Z",
+              "Y"
+          ],
+          grouping: [
+              3
+          ],
+          delimiters: {
+              thousands: ",",
+              decimal: "."
+          },
+          currency: [
+              "£",
+              ""
+          ]
+      },
+      "en-US": {
+          separator: "",
+          suffixes: [
+              "y",
+              "z",
+              "a",
+              "f",
+              "p",
+              "n",
+              "µ",
+              "m",
+              "",
+              "k",
+              "M",
+              "B",
+              "T",
+              "q",
+              "Q",
+              "Z",
+              "Y"
+          ],
+          grouping: [
+              3
+          ],
+          delimiters: {
+              thousands: ",",
+              decimal: "."
+          },
+          currency: [
+              "$",
+              ""
+          ]
+      },
+      "en-SA": {
+          separator: "",
+          suffixes: [
+              "y",
+              "z",
+              "a",
+              "f",
+              "p",
+              "n",
+              "µ",
+              "m",
+              "",
+              " thousand",
+              " million",
+              " billion",
+              " trillion",
+              " quadrillion",
+              " quintillion",
+              " sextillion",
+              "septillion"
+          ],
+          grouping: [
+              3
+          ],
+          delimiters: {
+              thousands: ",",
+              decimal: "."
+          },
+          currency: [
+              "$",
+              ""
+          ]
+      },
+      "es-CL": {
+          separator: "",
+          suffixes: [
+              "y",
+              "z",
+              "a",
+              "f",
+              "p",
+              "n",
+              "µ",
+              "m",
+              "",
+              "k",
+              "M",
+              "MM",
+              "B",
+              "T",
+              "Q",
+              "Z",
+              "Y"
+          ],
+          grouping: [
+              3
+          ],
+          delimiters: {
+              thousands: ".",
+              decimal: ","
+          },
+          currency: [
+              "$",
+              ""
+          ]
+      },
+      "es-MX": {
+          separator: "",
+          suffixes: [
+              "y",
+              "z",
+              "a",
+              "f",
+              "p",
+              "n",
+              "µ",
+              "m",
+              "",
+              "k",
+              "M",
+              "MM",
+              "B",
+              "T",
+              "Q",
+              "Z",
+              "Y"
+          ],
+          grouping: [
+              3
+          ],
+          delimiters: {
+              thousands: ",",
+              decimal: "."
+          },
+          currency: [
+              "$",
+              ""
+          ]
+      },
+      "es-ES": {
+          separator: "",
+          suffixes: [
+              "y",
+              "z",
+              "a",
+              "f",
+              "p",
+              "n",
+              "µ",
+              "m",
+              "",
+              "k",
+              "mm",
+              "b",
+              "t",
+              "q",
+              "Q",
+              "Z",
+              "Y"
+          ],
+          grouping: [
+              3
+          ],
+          delimiters: {
+              thousands: ".",
+              decimal: ","
+          },
+          currency: [
+              "€",
+              ""
+          ]
+      },
+      "et-EE": {
+          separator: " ",
+          suffixes: [
+              "y",
+              "z",
+              "a",
+              "f",
+              "p",
+              "n",
+              "µ",
+              "m",
+              "",
+              "tuhat",
+              "miljonit",
+              "miljardit",
+              "triljonit",
+              "q",
+              "Q",
+              "Z",
+              "Y"
+          ],
+          grouping: [
+              3
+          ],
+          delimiters: {
+              thousands: " ",
+              decimal: ","
+          },
+          currency: [
+              "",
+              "eurot"
+          ]
+      },
+      "fr-FR": {
+          suffixes: [
+              "y",
+              "z",
+              "a",
+              "f",
+              "p",
+              "n",
+              "µ",
+              "m",
+              "",
+              "k",
+              "m",
+              "b",
+              "t",
+              "q",
+              "Q",
+              "Z",
+              "Y"
+          ],
+          grouping: [
+              3
+          ],
+          delimiters: {
+              thousands: " ",
+              decimal: ","
+          },
+          currency: [
+              "€",
+              ""
+          ]
+      },
+      "zh-CN": {
+          separator: "",
+          suffixes: [
+              "幺",
+              "仄",
+              "阿",
+              "飞",
+              "皮",
+              "纳",
+              "微",
+              "毫",
+              "",
+              "千",
+              "兆",
+              "吉",
+              "太",
+              "拍",
+              "艾",
+              "泽",
+              "尧"
+          ],
+          grouping: [
+              3
+          ],
+          delimiters: {
+              thousands: ",",
+              decimal: "."
+          },
+          currency: [
+              "¥",
+              ""
+          ]
+      }
+  };
+
+  const round = (x, n)=>parseFloat(Math.round(x * Math.pow(10, n)) / Math.pow(10, n)).toFixed(n);
+  /**
+   * @private
+  */ function formatSuffix(str, precision, suffixes) {
+      let i = 0;
+      let value = parseFloat(str.replace("−", "-"), 10);
+      if (value) {
+          if (value < 0) value *= -1;
+          i = 1 + Math.floor(1e-12 + Math.log(value) / Math.LN10);
+          i = Math.max(-24, Math.min(24, Math.floor((i - 1) / 3) * 3));
+      }
+      const d = suffixes[8 + i / 3];
+      return {
+          number: round(d.scale(value), precision),
+          symbol: d.symbol
+      };
+  }
+  /**
+   * @private
+  */ function parseSuffixes(d, i) {
+      const k = Math.pow(10, Math.abs(8 - i) * 3);
+      return {
+          scale: i > 8 ? (d)=>d / k : (d)=>d * k,
+          symbol: d
+      };
+  }
+  /**
+      @function formatAbbreviate
+      @desc Formats a number to an appropriate number of decimal places and rounding, adding suffixes if applicable (ie. `1200000` to `"1.2M"`).
+      @param {Number|String} n The number to be formatted.
+      @param {Object|String} locale The locale config to be used. If *value* is an object, the function will format the numbers according the object. The object must include `suffixes`, `delimiter` and `currency` properties.
+      @returns {String}
+  */ function abbreviate(n, locale = "en-US", precision = undefined) {
+      if (isFinite(n)) n *= 1;
+      else return "N/A";
+      const negative = n < 0;
+      const length = n.toString().split(".")[0].replace("-", "").length, localeConfig = typeof locale === "object" ? locale : defaultLocale$1[locale] || defaultLocale$1["en-US"], suffixes = localeConfig.suffixes.map(parseSuffixes);
+      const decimal = localeConfig.delimiters.decimal || ".", separator = localeConfig.separator || "", thousands = localeConfig.delimiters.thousands || ",";
+      const d3plusFormatLocale = formatLocale$1({
+          currency: localeConfig.currency || [
+              "$",
+              ""
+          ],
+          decimal,
+          grouping: localeConfig.grouping || [
+              3
+          ],
+          thousands
+      });
+      let val;
+      if (precision) val = d3plusFormatLocale.format(precision)(n);
+      else if (n === 0) val = "0";
+      else if (length >= 3) {
+          const f = formatSuffix(d3plusFormatLocale.format(".3r")(n), 2, suffixes);
+          const num = parseFloat(f.number).toString().replace(".", decimal);
+          const char = f.symbol;
+          val = `${num}${separator}${char}`;
+      } else if (length === 3) val = d3plusFormatLocale.format(",f")(n);
+      else if (n < 1 && n > -1) val = d3plusFormatLocale.format(".2g")(n);
+      else val = d3plusFormatLocale.format(".3g")(n);
+      return `${negative && val.charAt(0) !== "−" ? "−" : ""}${val}`.replace(/−/g, "-") // replace new d3 default minus sign (−) to hyphen-minus (-)
+      .replace(/(\.[0]*[1-9]*)[0]*$/g, "$1") // removes any trailing zeros
+      .replace(/\.[0]*$/g, ""); // removes any trailing decimal point
+  }
+
+  /**
+      @function format
+      @desc An extension to d3's [format](https://github.com/d3/d3-format#api-reference) function that adds more string formatting types and localizations.
+
+  The new specifier strings added by d3plus-format are:
+   - `.3~a` - abbreviated decimal notation with a numeric suffix (ie. "k", "M", "B", etc). This is an alias of the `formatAbbreviate` function.
+      @param {String} specifier The string specifier used by the format function.
+      @returns {Function}
+  */ var format = ((specifier)=>{
+      if (specifier === ".3~a") return abbreviate;
+      return format$1(specifier);
+  });
+
+  /**
+      @function formatDefaultLocale
+      @desc An extension to d3's [formatDefaultLocale](https://github.com/d3/d3-format#api-reference) function that allows setting the locale globally for formatters.
+      @param {Object} definition The localization definition.
+      @returns {Object}
+  */ var formatDefaultLocale = ((definition)=>{
+      const locale = defaultLocale$2(definition);
+      locale.format = format;
+      return locale;
+  });
+
+  const t0 = new Date, t1 = new Date;
+  function timeInterval(floori, offseti, count, field) {
+      function interval(date) {
+          return floori(date = arguments.length === 0 ? new Date : new Date(+date)), date;
+      }
+      interval.floor = (date)=>{
+          return floori(date = new Date(+date)), date;
+      };
+      interval.ceil = (date)=>{
+          return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date;
+      };
+      interval.round = (date)=>{
+          const d0 = interval(date), d1 = interval.ceil(date);
+          return date - d0 < d1 - date ? d0 : d1;
+      };
+      interval.offset = (date, step)=>{
+          return offseti(date = new Date(+date), step == null ? 1 : Math.floor(step)), date;
+      };
+      interval.range = (start, stop, step)=>{
+          const range = [];
+          start = interval.ceil(start);
+          step = step == null ? 1 : Math.floor(step);
+          if (!(start < stop) || !(step > 0)) return range; // also handles Invalid Date
+          let previous;
+          do range.push(previous = new Date(+start)), offseti(start, step), floori(start);
+          while (previous < start && start < stop)
+          return range;
+      };
+      interval.filter = (test)=>{
+          return timeInterval((date)=>{
+              if (date >= date) while(floori(date), !test(date))date.setTime(date - 1);
+          }, (date, step)=>{
+              if (date >= date) {
+                  if (step < 0) while(++step <= 0){
+                      while(offseti(date, -1), !test(date)){} // eslint-disable-line no-empty
+                  }
+                  else while(--step >= 0){
+                      while(offseti(date, 1), !test(date)){} // eslint-disable-line no-empty
+                  }
+              }
+          });
+      };
+      if (count) {
+          interval.count = (start, end)=>{
+              t0.setTime(+start), t1.setTime(+end);
+              floori(t0), floori(t1);
+              return Math.floor(count(t0, t1));
+          };
+          interval.every = (step)=>{
+              step = Math.floor(step);
+              return !isFinite(step) || !(step > 0) ? null : !(step > 1) ? interval : interval.filter(field ? (d)=>field(d) % step === 0 : (d)=>interval.count(0, d) % step === 0);
+          };
+      }
+      return interval;
+  }
+
+  const durationSecond = 1000;
+  const durationMinute = durationSecond * 60;
+  const durationHour = durationMinute * 60;
+  const durationDay = durationHour * 24;
+  const durationWeek = durationDay * 7;
+
+  const second = timeInterval((date)=>{
+      date.setTime(date - date.getMilliseconds());
+  }, (date, step)=>{
+      date.setTime(+date + step * durationSecond);
+  }, (start, end)=>{
+      return (end - start) / durationSecond;
+  }, (date)=>{
+      return date.getUTCSeconds();
+  });
+  second.range;
+
+  const timeMinute = timeInterval((date)=>{
+      date.setTime(date - date.getMilliseconds() - date.getSeconds() * durationSecond);
+  }, (date, step)=>{
+      date.setTime(+date + step * durationMinute);
+  }, (start, end)=>{
+      return (end - start) / durationMinute;
+  }, (date)=>{
+      return date.getMinutes();
+  });
+  timeMinute.range;
+  const utcMinute = timeInterval((date)=>{
+      date.setUTCSeconds(0, 0);
+  }, (date, step)=>{
+      date.setTime(+date + step * durationMinute);
+  }, (start, end)=>{
+      return (end - start) / durationMinute;
+  }, (date)=>{
+      return date.getUTCMinutes();
+  });
+  utcMinute.range;
+
+  const timeHour = timeInterval((date)=>{
+      date.setTime(date - date.getMilliseconds() - date.getSeconds() * durationSecond - date.getMinutes() * durationMinute);
+  }, (date, step)=>{
+      date.setTime(+date + step * durationHour);
+  }, (start, end)=>{
+      return (end - start) / durationHour;
+  }, (date)=>{
+      return date.getHours();
+  });
+  timeHour.range;
+  const utcHour = timeInterval((date)=>{
+      date.setUTCMinutes(0, 0, 0);
+  }, (date, step)=>{
+      date.setTime(+date + step * durationHour);
+  }, (start, end)=>{
+      return (end - start) / durationHour;
+  }, (date)=>{
+      return date.getUTCHours();
+  });
+  utcHour.range;
+
+  const timeDay = timeInterval((date)=>date.setHours(0, 0, 0, 0), (date, step)=>date.setDate(date.getDate() + step), (start, end)=>(end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationDay, (date)=>date.getDate() - 1);
+  timeDay.range;
+  const utcDay = timeInterval((date)=>{
+      date.setUTCHours(0, 0, 0, 0);
+  }, (date, step)=>{
+      date.setUTCDate(date.getUTCDate() + step);
+  }, (start, end)=>{
+      return (end - start) / durationDay;
+  }, (date)=>{
+      return date.getUTCDate() - 1;
+  });
+  utcDay.range;
+  const unixDay = timeInterval((date)=>{
+      date.setUTCHours(0, 0, 0, 0);
+  }, (date, step)=>{
+      date.setUTCDate(date.getUTCDate() + step);
+  }, (start, end)=>{
+      return (end - start) / durationDay;
+  }, (date)=>{
+      return Math.floor(date / durationDay);
+  });
+  unixDay.range;
+
+  function timeWeekday(i) {
+      return timeInterval((date)=>{
+          date.setDate(date.getDate() - (date.getDay() + 7 - i) % 7);
+          date.setHours(0, 0, 0, 0);
+      }, (date, step)=>{
+          date.setDate(date.getDate() + step * 7);
+      }, (start, end)=>{
+          return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationWeek;
+      });
+  }
+  const timeSunday = timeWeekday(0);
+  const timeMonday = timeWeekday(1);
+  const timeTuesday = timeWeekday(2);
+  const timeWednesday = timeWeekday(3);
+  const timeThursday = timeWeekday(4);
+  const timeFriday = timeWeekday(5);
+  const timeSaturday = timeWeekday(6);
+  timeSunday.range;
+  timeMonday.range;
+  timeTuesday.range;
+  timeWednesday.range;
+  timeThursday.range;
+  timeFriday.range;
+  timeSaturday.range;
+  function utcWeekday(i) {
+      return timeInterval((date)=>{
+          date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i) % 7);
+          date.setUTCHours(0, 0, 0, 0);
+      }, (date, step)=>{
+          date.setUTCDate(date.getUTCDate() + step * 7);
+      }, (start, end)=>{
+          return (end - start) / durationWeek;
+      });
+  }
+  const utcSunday = utcWeekday(0);
+  const utcMonday = utcWeekday(1);
+  const utcTuesday = utcWeekday(2);
+  const utcWednesday = utcWeekday(3);
+  const utcThursday = utcWeekday(4);
+  const utcFriday = utcWeekday(5);
+  const utcSaturday = utcWeekday(6);
+  utcSunday.range;
+  utcMonday.range;
+  utcTuesday.range;
+  utcWednesday.range;
+  utcThursday.range;
+  utcFriday.range;
+  utcSaturday.range;
+
+  const timeMonth = timeInterval((date)=>{
+      date.setDate(1);
+      date.setHours(0, 0, 0, 0);
+  }, (date, step)=>{
+      date.setMonth(date.getMonth() + step);
+  }, (start, end)=>{
+      return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12;
+  }, (date)=>{
+      return date.getMonth();
+  });
+  timeMonth.range;
+  const utcMonth = timeInterval((date)=>{
+      date.setUTCDate(1);
+      date.setUTCHours(0, 0, 0, 0);
+  }, (date, step)=>{
+      date.setUTCMonth(date.getUTCMonth() + step);
+  }, (start, end)=>{
+      return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12;
+  }, (date)=>{
+      return date.getUTCMonth();
+  });
+  utcMonth.range;
+
+  const timeYear = timeInterval((date)=>{
+      date.setMonth(0, 1);
+      date.setHours(0, 0, 0, 0);
+  }, (date, step)=>{
+      date.setFullYear(date.getFullYear() + step);
+  }, (start, end)=>{
+      return end.getFullYear() - start.getFullYear();
+  }, (date)=>{
+      return date.getFullYear();
+  });
+  // An optimized implementation for this simple case.
+  timeYear.every = (k)=>{
+      return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : timeInterval((date)=>{
+          date.setFullYear(Math.floor(date.getFullYear() / k) * k);
+          date.setMonth(0, 1);
+          date.setHours(0, 0, 0, 0);
+      }, (date, step)=>{
+          date.setFullYear(date.getFullYear() + step * k);
+      });
+  };
+  timeYear.range;
+  const utcYear = timeInterval((date)=>{
+      date.setUTCMonth(0, 1);
+      date.setUTCHours(0, 0, 0, 0);
+  }, (date, step)=>{
+      date.setUTCFullYear(date.getUTCFullYear() + step);
+  }, (start, end)=>{
+      return end.getUTCFullYear() - start.getUTCFullYear();
+  }, (date)=>{
+      return date.getUTCFullYear();
+  });
+  // An optimized implementation for this simple case.
+  utcYear.every = (k)=>{
+      return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : timeInterval((date)=>{
+          date.setUTCFullYear(Math.floor(date.getUTCFullYear() / k) * k);
+          date.setUTCMonth(0, 1);
+          date.setUTCHours(0, 0, 0, 0);
+      }, (date, step)=>{
+          date.setUTCFullYear(date.getUTCFullYear() + step * k);
+      });
+  };
+  utcYear.range;
+
+  function localDate(d) {
+      if (0 <= d.y && d.y < 100) {
+          var date = new Date(-1, d.m, d.d, d.H, d.M, d.S, d.L);
+          date.setFullYear(d.y);
+          return date;
+      }
+      return new Date(d.y, d.m, d.d, d.H, d.M, d.S, d.L);
+  }
+  function utcDate(d) {
+      if (0 <= d.y && d.y < 100) {
+          var date = new Date(Date.UTC(-1, d.m, d.d, d.H, d.M, d.S, d.L));
+          date.setUTCFullYear(d.y);
+          return date;
+      }
+      return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L));
+  }
+  function newDate(y, m, d) {
+      return {
+          y: y,
+          m: m,
+          d: d,
+          H: 0,
+          M: 0,
+          S: 0,
+          L: 0
+      };
+  }
+  function formatLocale(locale) {
+      var locale_dateTime = locale.dateTime, locale_date = locale.date, locale_time = locale.time, locale_periods = locale.periods, locale_weekdays = locale.days, locale_shortWeekdays = locale.shortDays, locale_months = locale.months, locale_shortMonths = locale.shortMonths;
+      var periodRe = formatRe(locale_periods), periodLookup = formatLookup(locale_periods), weekdayRe = formatRe(locale_weekdays), weekdayLookup = formatLookup(locale_weekdays), shortWeekdayRe = formatRe(locale_shortWeekdays), shortWeekdayLookup = formatLookup(locale_shortWeekdays), monthRe = formatRe(locale_months), monthLookup = formatLookup(locale_months), shortMonthRe = formatRe(locale_shortMonths), shortMonthLookup = formatLookup(locale_shortMonths);
+      var formats = {
+          "a": formatShortWeekday,
+          "A": formatWeekday,
+          "b": formatShortMonth,
+          "B": formatMonth,
+          "c": null,
+          "d": formatDayOfMonth,
+          "e": formatDayOfMonth,
+          "f": formatMicroseconds,
+          "g": formatYearISO,
+          "G": formatFullYearISO,
+          "H": formatHour24,
+          "I": formatHour12,
+          "j": formatDayOfYear,
+          "L": formatMilliseconds,
+          "m": formatMonthNumber,
+          "M": formatMinutes,
+          "p": formatPeriod,
+          "q": formatQuarter,
+          "Q": formatUnixTimestamp,
+          "s": formatUnixTimestampSeconds,
+          "S": formatSeconds,
+          "u": formatWeekdayNumberMonday,
+          "U": formatWeekNumberSunday,
+          "V": formatWeekNumberISO,
+          "w": formatWeekdayNumberSunday,
+          "W": formatWeekNumberMonday,
+          "x": null,
+          "X": null,
+          "y": formatYear,
+          "Y": formatFullYear,
+          "Z": formatZone,
+          "%": formatLiteralPercent
+      };
+      var utcFormats = {
+          "a": formatUTCShortWeekday,
+          "A": formatUTCWeekday,
+          "b": formatUTCShortMonth,
+          "B": formatUTCMonth,
+          "c": null,
+          "d": formatUTCDayOfMonth,
+          "e": formatUTCDayOfMonth,
+          "f": formatUTCMicroseconds,
+          "g": formatUTCYearISO,
+          "G": formatUTCFullYearISO,
+          "H": formatUTCHour24,
+          "I": formatUTCHour12,
+          "j": formatUTCDayOfYear,
+          "L": formatUTCMilliseconds,
+          "m": formatUTCMonthNumber,
+          "M": formatUTCMinutes,
+          "p": formatUTCPeriod,
+          "q": formatUTCQuarter,
+          "Q": formatUnixTimestamp,
+          "s": formatUnixTimestampSeconds,
+          "S": formatUTCSeconds,
+          "u": formatUTCWeekdayNumberMonday,
+          "U": formatUTCWeekNumberSunday,
+          "V": formatUTCWeekNumberISO,
+          "w": formatUTCWeekdayNumberSunday,
+          "W": formatUTCWeekNumberMonday,
+          "x": null,
+          "X": null,
+          "y": formatUTCYear,
+          "Y": formatUTCFullYear,
+          "Z": formatUTCZone,
+          "%": formatLiteralPercent
+      };
+      var parses = {
+          "a": parseShortWeekday,
+          "A": parseWeekday,
+          "b": parseShortMonth,
+          "B": parseMonth,
+          "c": parseLocaleDateTime,
+          "d": parseDayOfMonth,
+          "e": parseDayOfMonth,
+          "f": parseMicroseconds,
+          "g": parseYear,
+          "G": parseFullYear,
+          "H": parseHour24,
+          "I": parseHour24,
+          "j": parseDayOfYear,
+          "L": parseMilliseconds,
+          "m": parseMonthNumber,
+          "M": parseMinutes,
+          "p": parsePeriod,
+          "q": parseQuarter,
+          "Q": parseUnixTimestamp,
+          "s": parseUnixTimestampSeconds,
+          "S": parseSeconds,
+          "u": parseWeekdayNumberMonday,
+          "U": parseWeekNumberSunday,
+          "V": parseWeekNumberISO,
+          "w": parseWeekdayNumberSunday,
+          "W": parseWeekNumberMonday,
+          "x": parseLocaleDate,
+          "X": parseLocaleTime,
+          "y": parseYear,
+          "Y": parseFullYear,
+          "Z": parseZone,
+          "%": parseLiteralPercent
+      };
+      // These recursive directive definitions must be deferred.
+      formats.x = newFormat(locale_date, formats);
+      formats.X = newFormat(locale_time, formats);
+      formats.c = newFormat(locale_dateTime, formats);
+      utcFormats.x = newFormat(locale_date, utcFormats);
+      utcFormats.X = newFormat(locale_time, utcFormats);
+      utcFormats.c = newFormat(locale_dateTime, utcFormats);
+      function newFormat(specifier, formats) {
+          return function(date) {
+              var string = [], i = -1, j = 0, n = specifier.length, c, pad, format;
+              if (!(date instanceof Date)) date = new Date(+date);
+              while(++i < n){
+                  if (specifier.charCodeAt(i) === 37) {
+                      string.push(specifier.slice(j, i));
+                      if ((pad = pads[c = specifier.charAt(++i)]) != null) c = specifier.charAt(++i);
+                      else pad = c === "e" ? " " : "0";
+                      if (format = formats[c]) c = format(date, pad);
+                      string.push(c);
+                      j = i + 1;
+                  }
+              }
+              string.push(specifier.slice(j, i));
+              return string.join("");
+          };
+      }
+      function newParse(specifier, Z) {
+          return function(string) {
+              var d = newDate(1900, undefined, 1), i = parseSpecifier(d, specifier, string += "", 0), week, day;
+              if (i != string.length) return null;
+              // If a UNIX timestamp is specified, return it.
+              if ("Q" in d) return new Date(d.Q);
+              if ("s" in d) return new Date(d.s * 1000 + ("L" in d ? d.L : 0));
+              // If this is utcParse, never use the local timezone.
+              if (Z && !("Z" in d)) d.Z = 0;
+              // The am-pm flag is 0 for AM, and 1 for PM.
+              if ("p" in d) d.H = d.H % 12 + d.p * 12;
+              // If the month was not specified, inherit from the quarter.
+              if (d.m === undefined) d.m = "q" in d ? d.q : 0;
+              // Convert day-of-week and week-of-year to day-of-year.
+              if ("V" in d) {
+                  if (d.V < 1 || d.V > 53) return null;
+                  if (!("w" in d)) d.w = 1;
+                  if ("Z" in d) {
+                      week = utcDate(newDate(d.y, 0, 1)), day = week.getUTCDay();
+                      week = day > 4 || day === 0 ? utcMonday.ceil(week) : utcMonday(week);
+                      week = utcDay.offset(week, (d.V - 1) * 7);
+                      d.y = week.getUTCFullYear();
+                      d.m = week.getUTCMonth();
+                      d.d = week.getUTCDate() + (d.w + 6) % 7;
+                  } else {
+                      week = localDate(newDate(d.y, 0, 1)), day = week.getDay();
+                      week = day > 4 || day === 0 ? timeMonday.ceil(week) : timeMonday(week);
+                      week = timeDay.offset(week, (d.V - 1) * 7);
+                      d.y = week.getFullYear();
+                      d.m = week.getMonth();
+                      d.d = week.getDate() + (d.w + 6) % 7;
+                  }
+              } else if ("W" in d || "U" in d) {
+                  if (!("w" in d)) d.w = "u" in d ? d.u % 7 : "W" in d ? 1 : 0;
+                  day = "Z" in d ? utcDate(newDate(d.y, 0, 1)).getUTCDay() : localDate(newDate(d.y, 0, 1)).getDay();
+                  d.m = 0;
+                  d.d = "W" in d ? (d.w + 6) % 7 + d.W * 7 - (day + 5) % 7 : d.w + d.U * 7 - (day + 6) % 7;
+              }
+              // If a time zone is specified, all fields are interpreted as UTC and then
+              // offset according to the specified time zone.
+              if ("Z" in d) {
+                  d.H += d.Z / 100 | 0;
+                  d.M += d.Z % 100;
+                  return utcDate(d);
+              }
+              // Otherwise, all fields are in local time.
+              return localDate(d);
+          };
+      }
+      function parseSpecifier(d, specifier, string, j) {
+          var i = 0, n = specifier.length, m = string.length, c, parse;
+          while(i < n){
+              if (j >= m) return -1;
+              c = specifier.charCodeAt(i++);
+              if (c === 37) {
+                  c = specifier.charAt(i++);
+                  parse = parses[c in pads ? specifier.charAt(i++) : c];
+                  if (!parse || (j = parse(d, string, j)) < 0) return -1;
+              } else if (c != string.charCodeAt(j++)) {
+                  return -1;
+              }
+          }
+          return j;
+      }
+      function parsePeriod(d, string, i) {
+          var n = periodRe.exec(string.slice(i));
+          return n ? (d.p = periodLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+      }
+      function parseShortWeekday(d, string, i) {
+          var n = shortWeekdayRe.exec(string.slice(i));
+          return n ? (d.w = shortWeekdayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+      }
+      function parseWeekday(d, string, i) {
+          var n = weekdayRe.exec(string.slice(i));
+          return n ? (d.w = weekdayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+      }
+      function parseShortMonth(d, string, i) {
+          var n = shortMonthRe.exec(string.slice(i));
+          return n ? (d.m = shortMonthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+      }
+      function parseMonth(d, string, i) {
+          var n = monthRe.exec(string.slice(i));
+          return n ? (d.m = monthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+      }
+      function parseLocaleDateTime(d, string, i) {
+          return parseSpecifier(d, locale_dateTime, string, i);
+      }
+      function parseLocaleDate(d, string, i) {
+          return parseSpecifier(d, locale_date, string, i);
+      }
+      function parseLocaleTime(d, string, i) {
+          return parseSpecifier(d, locale_time, string, i);
+      }
+      function formatShortWeekday(d) {
+          return locale_shortWeekdays[d.getDay()];
+      }
+      function formatWeekday(d) {
+          return locale_weekdays[d.getDay()];
+      }
+      function formatShortMonth(d) {
+          return locale_shortMonths[d.getMonth()];
+      }
+      function formatMonth(d) {
+          return locale_months[d.getMonth()];
+      }
+      function formatPeriod(d) {
+          return locale_periods[+(d.getHours() >= 12)];
+      }
+      function formatQuarter(d) {
+          return 1 + ~~(d.getMonth() / 3);
+      }
+      function formatUTCShortWeekday(d) {
+          return locale_shortWeekdays[d.getUTCDay()];
+      }
+      function formatUTCWeekday(d) {
+          return locale_weekdays[d.getUTCDay()];
+      }
+      function formatUTCShortMonth(d) {
+          return locale_shortMonths[d.getUTCMonth()];
+      }
+      function formatUTCMonth(d) {
+          return locale_months[d.getUTCMonth()];
+      }
+      function formatUTCPeriod(d) {
+          return locale_periods[+(d.getUTCHours() >= 12)];
+      }
+      function formatUTCQuarter(d) {
+          return 1 + ~~(d.getUTCMonth() / 3);
+      }
+      return {
+          format: function(specifier) {
+              var f = newFormat(specifier += "", formats);
+              f.toString = function() {
+                  return specifier;
+              };
+              return f;
+          },
+          parse: function(specifier) {
+              var p = newParse(specifier += "", false);
+              p.toString = function() {
+                  return specifier;
+              };
+              return p;
+          },
+          utcFormat: function(specifier) {
+              var f = newFormat(specifier += "", utcFormats);
+              f.toString = function() {
+                  return specifier;
+              };
+              return f;
+          },
+          utcParse: function(specifier) {
+              var p = newParse(specifier += "", true);
+              p.toString = function() {
+                  return specifier;
+              };
+              return p;
+          }
+      };
+  }
+  var pads = {
+      "-": "",
+      "_": " ",
+      "0": "0"
+  }, numberRe = /^\s*\d+/, percentRe = /^%/, requoteRe = /[\\^$*+?|[\]().{}]/g;
+  function pad(value, fill, width) {
+      var sign = value < 0 ? "-" : "", string = (sign ? -value : value) + "", length = string.length;
+      return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string);
+  }
+  function requote(s) {
+      return s.replace(requoteRe, "\\$&");
+  }
+  function formatRe(names) {
+      return new RegExp("^(?:" + names.map(requote).join("|") + ")", "i");
+  }
+  function formatLookup(names) {
+      return new Map(names.map((name, i)=>[
+              name.toLowerCase(),
+              i
+          ]));
+  }
+  function parseWeekdayNumberSunday(d, string, i) {
+      var n = numberRe.exec(string.slice(i, i + 1));
+      return n ? (d.w = +n[0], i + n[0].length) : -1;
+  }
+  function parseWeekdayNumberMonday(d, string, i) {
+      var n = numberRe.exec(string.slice(i, i + 1));
+      return n ? (d.u = +n[0], i + n[0].length) : -1;
+  }
+  function parseWeekNumberSunday(d, string, i) {
+      var n = numberRe.exec(string.slice(i, i + 2));
+      return n ? (d.U = +n[0], i + n[0].length) : -1;
+  }
+  function parseWeekNumberISO(d, string, i) {
+      var n = numberRe.exec(string.slice(i, i + 2));
+      return n ? (d.V = +n[0], i + n[0].length) : -1;
+  }
+  function parseWeekNumberMonday(d, string, i) {
+      var n = numberRe.exec(string.slice(i, i + 2));
+      return n ? (d.W = +n[0], i + n[0].length) : -1;
+  }
+  function parseFullYear(d, string, i) {
+      var n = numberRe.exec(string.slice(i, i + 4));
+      return n ? (d.y = +n[0], i + n[0].length) : -1;
+  }
+  function parseYear(d, string, i) {
+      var n = numberRe.exec(string.slice(i, i + 2));
+      return n ? (d.y = +n[0] + (+n[0] > 68 ? 1900 : 2000), i + n[0].length) : -1;
+  }
+  function parseZone(d, string, i) {
+      var n = /^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(string.slice(i, i + 6));
+      return n ? (d.Z = n[1] ? 0 : -(n[2] + (n[3] || "00")), i + n[0].length) : -1;
+  }
+  function parseQuarter(d, string, i) {
+      var n = numberRe.exec(string.slice(i, i + 1));
+      return n ? (d.q = n[0] * 3 - 3, i + n[0].length) : -1;
+  }
+  function parseMonthNumber(d, string, i) {
+      var n = numberRe.exec(string.slice(i, i + 2));
+      return n ? (d.m = n[0] - 1, i + n[0].length) : -1;
+  }
+  function parseDayOfMonth(d, string, i) {
+      var n = numberRe.exec(string.slice(i, i + 2));
+      return n ? (d.d = +n[0], i + n[0].length) : -1;
+  }
+  function parseDayOfYear(d, string, i) {
+      var n = numberRe.exec(string.slice(i, i + 3));
+      return n ? (d.m = 0, d.d = +n[0], i + n[0].length) : -1;
+  }
+  function parseHour24(d, string, i) {
+      var n = numberRe.exec(string.slice(i, i + 2));
+      return n ? (d.H = +n[0], i + n[0].length) : -1;
+  }
+  function parseMinutes(d, string, i) {
+      var n = numberRe.exec(string.slice(i, i + 2));
+      return n ? (d.M = +n[0], i + n[0].length) : -1;
+  }
+  function parseSeconds(d, string, i) {
+      var n = numberRe.exec(string.slice(i, i + 2));
+      return n ? (d.S = +n[0], i + n[0].length) : -1;
+  }
+  function parseMilliseconds(d, string, i) {
+      var n = numberRe.exec(string.slice(i, i + 3));
+      return n ? (d.L = +n[0], i + n[0].length) : -1;
+  }
+  function parseMicroseconds(d, string, i) {
+      var n = numberRe.exec(string.slice(i, i + 6));
+      return n ? (d.L = Math.floor(n[0] / 1000), i + n[0].length) : -1;
+  }
+  function parseLiteralPercent(d, string, i) {
+      var n = percentRe.exec(string.slice(i, i + 1));
+      return n ? i + n[0].length : -1;
+  }
+  function parseUnixTimestamp(d, string, i) {
+      var n = numberRe.exec(string.slice(i));
+      return n ? (d.Q = +n[0], i + n[0].length) : -1;
+  }
+  function parseUnixTimestampSeconds(d, string, i) {
+      var n = numberRe.exec(string.slice(i));
+      return n ? (d.s = +n[0], i + n[0].length) : -1;
+  }
+  function formatDayOfMonth(d, p) {
+      return pad(d.getDate(), p, 2);
+  }
+  function formatHour24(d, p) {
+      return pad(d.getHours(), p, 2);
+  }
+  function formatHour12(d, p) {
+      return pad(d.getHours() % 12 || 12, p, 2);
+  }
+  function formatDayOfYear(d, p) {
+      return pad(1 + timeDay.count(timeYear(d), d), p, 3);
+  }
+  function formatMilliseconds(d, p) {
+      return pad(d.getMilliseconds(), p, 3);
+  }
+  function formatMicroseconds(d, p) {
+      return formatMilliseconds(d, p) + "000";
+  }
+  function formatMonthNumber(d, p) {
+      return pad(d.getMonth() + 1, p, 2);
+  }
+  function formatMinutes(d, p) {
+      return pad(d.getMinutes(), p, 2);
+  }
+  function formatSeconds(d, p) {
+      return pad(d.getSeconds(), p, 2);
+  }
+  function formatWeekdayNumberMonday(d) {
+      var day = d.getDay();
+      return day === 0 ? 7 : day;
+  }
+  function formatWeekNumberSunday(d, p) {
+      return pad(timeSunday.count(timeYear(d) - 1, d), p, 2);
+  }
+  function dISO(d) {
+      var day = d.getDay();
+      return day >= 4 || day === 0 ? timeThursday(d) : timeThursday.ceil(d);
+  }
+  function formatWeekNumberISO(d, p) {
+      d = dISO(d);
+      return pad(timeThursday.count(timeYear(d), d) + (timeYear(d).getDay() === 4), p, 2);
+  }
+  function formatWeekdayNumberSunday(d) {
+      return d.getDay();
+  }
+  function formatWeekNumberMonday(d, p) {
+      return pad(timeMonday.count(timeYear(d) - 1, d), p, 2);
+  }
+  function formatYear(d, p) {
+      return pad(d.getFullYear() % 100, p, 2);
+  }
+  function formatYearISO(d, p) {
+      d = dISO(d);
+      return pad(d.getFullYear() % 100, p, 2);
+  }
+  function formatFullYear(d, p) {
+      return pad(d.getFullYear() % 10000, p, 4);
+  }
+  function formatFullYearISO(d, p) {
+      var day = d.getDay();
+      d = day >= 4 || day === 0 ? timeThursday(d) : timeThursday.ceil(d);
+      return pad(d.getFullYear() % 10000, p, 4);
+  }
+  function formatZone(d) {
+      var z = d.getTimezoneOffset();
+      return (z > 0 ? "-" : (z *= -1, "+")) + pad(z / 60 | 0, "0", 2) + pad(z % 60, "0", 2);
+  }
+  function formatUTCDayOfMonth(d, p) {
+      return pad(d.getUTCDate(), p, 2);
+  }
+  function formatUTCHour24(d, p) {
+      return pad(d.getUTCHours(), p, 2);
+  }
+  function formatUTCHour12(d, p) {
+      return pad(d.getUTCHours() % 12 || 12, p, 2);
+  }
+  function formatUTCDayOfYear(d, p) {
+      return pad(1 + utcDay.count(utcYear(d), d), p, 3);
+  }
+  function formatUTCMilliseconds(d, p) {
+      return pad(d.getUTCMilliseconds(), p, 3);
+  }
+  function formatUTCMicroseconds(d, p) {
+      return formatUTCMilliseconds(d, p) + "000";
+  }
+  function formatUTCMonthNumber(d, p) {
+      return pad(d.getUTCMonth() + 1, p, 2);
+  }
+  function formatUTCMinutes(d, p) {
+      return pad(d.getUTCMinutes(), p, 2);
+  }
+  function formatUTCSeconds(d, p) {
+      return pad(d.getUTCSeconds(), p, 2);
+  }
+  function formatUTCWeekdayNumberMonday(d) {
+      var dow = d.getUTCDay();
+      return dow === 0 ? 7 : dow;
+  }
+  function formatUTCWeekNumberSunday(d, p) {
+      return pad(utcSunday.count(utcYear(d) - 1, d), p, 2);
+  }
+  function UTCdISO(d) {
+      var day = d.getUTCDay();
+      return day >= 4 || day === 0 ? utcThursday(d) : utcThursday.ceil(d);
+  }
+  function formatUTCWeekNumberISO(d, p) {
+      d = UTCdISO(d);
+      return pad(utcThursday.count(utcYear(d), d) + (utcYear(d).getUTCDay() === 4), p, 2);
+  }
+  function formatUTCWeekdayNumberSunday(d) {
+      return d.getUTCDay();
+  }
+  function formatUTCWeekNumberMonday(d, p) {
+      return pad(utcMonday.count(utcYear(d) - 1, d), p, 2);
+  }
+  function formatUTCYear(d, p) {
+      return pad(d.getUTCFullYear() % 100, p, 2);
+  }
+  function formatUTCYearISO(d, p) {
+      d = UTCdISO(d);
+      return pad(d.getUTCFullYear() % 100, p, 2);
+  }
+  function formatUTCFullYear(d, p) {
+      return pad(d.getUTCFullYear() % 10000, p, 4);
+  }
+  function formatUTCFullYearISO(d, p) {
+      var day = d.getUTCDay();
+      d = day >= 4 || day === 0 ? utcThursday(d) : utcThursday.ceil(d);
+      return pad(d.getUTCFullYear() % 10000, p, 4);
+  }
+  function formatUTCZone() {
+      return "+0000";
+  }
+  function formatLiteralPercent() {
+      return "%";
+  }
+  function formatUnixTimestamp(d) {
+      return +d;
+  }
+  function formatUnixTimestampSeconds(d) {
+      return Math.floor(+d / 1000);
+  }
+
+  var locale;
+  var timeFormat;
+  defaultLocale({
+      dateTime: "%x, %X",
+      date: "%-m/%-d/%Y",
+      time: "%-I:%M:%S %p",
+      periods: [
+          "AM",
+          "PM"
+      ],
+      days: [
+          "Sunday",
+          "Monday",
+          "Tuesday",
+          "Wednesday",
+          "Thursday",
+          "Friday",
+          "Saturday"
+      ],
+      shortDays: [
+          "Sun",
+          "Mon",
+          "Tue",
+          "Wed",
+          "Thu",
+          "Fri",
+          "Sat"
+      ],
+      months: [
+          "January",
+          "February",
+          "March",
+          "April",
+          "May",
+          "June",
+          "July",
+          "August",
+          "September",
+          "October",
+          "November",
+          "December"
+      ],
+      shortMonths: [
+          "Jan",
+          "Feb",
+          "Mar",
+          "Apr",
+          "May",
+          "Jun",
+          "Jul",
+          "Aug",
+          "Sep",
+          "Oct",
+          "Nov",
+          "Dec"
+      ]
+  });
+  function defaultLocale(definition) {
+      locale = formatLocale(definition);
+      timeFormat = locale.format;
+      locale.parse;
+      locale.utcFormat;
+      locale.utcParse;
+      return locale;
+  }
+
+  /**
+      @function formatDate
+      @desc A default set of date formatters, which takes into account both the interval in between in each data point but also the start/end data points.
+      @param {Date} d The date string to be formatted.
+      @param {Array} dataArray The full array of ordered Date Objects.
+      @param {Function} [formatter = d3.timeFormat] An optional instance of d3.timeFormat to be used for localization.
+      @returns {String}
+  */ function formatDate(d, dataArray, formatter = timeFormat) {
+      const formatHour = formatter("%I %p"), formatMillisecond = formatter(".%L"), formatMinute = formatter("%I:%M"), formatMonth = formatter("%b"), formatMonthDay = formatter("%b %-d"), formatMonthDayYear = formatter("%b %-d, %Y"), formatMonthYear = formatter("%b %Y"), formatQuarter = formatter("Q%q"), formatQuarterYear = formatter("Q%q %Y"), formatSecond = formatter(":%S"), formatYear = formatter("%Y");
+      const labelIndex = dataArray.findIndex((a)=>+a === +d);
+      const firstOrLast = labelIndex === 0 || labelIndex === dataArray.length - 1;
+      const smallArray = dataArray.length <= 5;
+      const [yearlySteps, monthlySteps, dailySteps, hourlySteps] = dataArray.reduce((arr, d, i)=>{
+          if (i) {
+              arr[0].push(d.getFullYear() - dataArray[i - 1].getFullYear());
+              arr[1].push(monthDiff(dataArray[i - 1], d));
+              arr[2].push(Math.round((d - dataArray[i - 1]) / (1000 * 60 * 60 * 24)));
+              arr[3].push(Math.round((d - dataArray[i - 1]) / (1000 * 60 * 60)));
+          }
+          return arr;
+      }, [
+          [],
+          [],
+          [],
+          []
+      ]);
+      return (yearlySteps.every((s)=>s >= 1 && !(s % 1)) // Yearly Data 
+       ? formatYear : monthlySteps.every((s)=>s >= 3 && !(s % 3)) // Quarterly Data
+       ? +timeYear(d) === d || firstOrLast || smallArray ? formatQuarterYear : formatQuarter : monthlySteps.every((s)=>s >= 1 && !(s % 1)) // Monthly Data
+       ? +timeYear(d) === d || firstOrLast || smallArray ? formatMonthYear : formatMonth : dailySteps.every((s)=>s >= 1 && !(s % 1)) // Daily Data
+       ? +timeYear(d) === d || firstOrLast || smallArray ? formatMonthDayYear : formatMonthDay : hourlySteps.every((s)=>s >= 1 && !(s % 1)) // Hourly Data
+       ? firstOrLast || smallArray ? formatMonthDayYear : +timeMonth(d) === d ? formatMonthDay : formatHour : second(d) < d ? formatMillisecond : timeMinute(d) < d ? formatSecond : timeHour(d) < d ? formatMinute : d)(d);
+  }
+  /**
+      @function monthDiff
+      @desc Returns the number of months between two Date objects
+      @param {*} d1
+      @param {*} d2
+      @returns {Number} the number of months between the two Date objects
+      @private
+  */ function monthDiff(d1, d2) {
+      let months;
+      months = (d2.getFullYear() - d1.getFullYear()) * 12;
+      months -= d1.getMonth();
+      months += d2.getMonth();
+      return months <= 0 ? 0 : months;
+  }
+
+  exports.format = format;
+  exports.formatAbbreviate = abbreviate;
+  exports.formatDate = formatDate;
+  exports.formatDefaultLocale = formatDefaultLocale;
+
+}));
+//# sourceMappingURL=d3plus-format.full.js.map