@mui/x-charts-vendor 7.12.0

package/lib-vendor/d3-format/dist/d3-format.js

@@ -0,0 +1,313 @@
+"use strict";
+
+// https://d3js.org/d3-format/ v3.1.0 Copyright 2010-2021 Mike Bostock
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'], factory) : (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.d3 = global.d3 || {}));
+})(this, function (exports) {
+  'use strict';
+
+  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(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";
+
+      // The "" type, and any invalid type, is an alias for ".12~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;
+  exports.format = void 0;
+  exports.formatPrefix = void 0;
+  defaultLocale({
+    thousands: ",",
+    grouping: [3],
+    currency: ["$", ""]
+  });
+  function defaultLocale(definition) {
+    locale = formatLocale(definition);
+    exports.format = locale.format;
+    exports.formatPrefix = locale.formatPrefix;
+    return locale;
+  }
+  function precisionFixed(step) {
+    return Math.max(0, -exponent(Math.abs(step)));
+  }
+  function precisionPrefix(step, value) {
+    return Math.max(0, Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3 - exponent(Math.abs(step)));
+  }
+  function precisionRound(step, max) {
+    step = Math.abs(step), max = Math.abs(max) - step;
+    return Math.max(0, exponent(max) - exponent(step)) + 1;
+  }
+  exports.FormatSpecifier = FormatSpecifier;
+  exports.formatDefaultLocale = defaultLocale;
+  exports.formatLocale = formatLocale;
+  exports.formatSpecifier = formatSpecifier;
+  exports.precisionFixed = precisionFixed;
+  exports.precisionPrefix = precisionPrefix;
+  exports.precisionRound = precisionRound;
+  Object.defineProperty(exports, '__esModule', {
+    value: true
+  });
+});

package/lib-vendor/d3-format/dist/d3-format.min.js

@@ -0,0 +1,193 @@
+"use strict";
+
+// https://d3js.org/d3-format/ v3.1.0 Copyright 2010-2021 Mike Bostock
+!function (t, i) {
+  "object" == typeof exports && "undefined" != typeof module ? i(exports) : "function" == typeof define && define.amd ? define(["exports"], i) : i((t = "undefined" != typeof globalThis ? globalThis : t || self).d3 = t.d3 || {});
+}(this, function (t) {
+  "use strict";
+
+  function i(t, i) {
+    if ((r = (t = i ? t.toExponential(i - 1) : t.toExponential()).indexOf("e")) < 0) return null;
+    var r,
+      n = t.slice(0, r);
+    return [n.length > 1 ? n[0] + n.slice(2) : n, +t.slice(r + 1)];
+  }
+  function r(t) {
+    return (t = i(Math.abs(t))) ? t[1] : NaN;
+  }
+  var n,
+    e = /^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;
+  function o(t) {
+    if (!(i = e.exec(t))) throw new Error("invalid format: " + t);
+    var i;
+    return new a({
+      fill: i[1],
+      align: i[2],
+      sign: i[3],
+      symbol: i[4],
+      zero: i[5],
+      width: i[6],
+      comma: i[7],
+      precision: i[8] && i[8].slice(1),
+      trim: i[9],
+      type: i[10]
+    });
+  }
+  function a(t) {
+    this.fill = void 0 === t.fill ? " " : t.fill + "", this.align = void 0 === t.align ? ">" : t.align + "", this.sign = void 0 === t.sign ? "-" : t.sign + "", this.symbol = void 0 === t.symbol ? "" : t.symbol + "", this.zero = !!t.zero, this.width = void 0 === t.width ? void 0 : +t.width, this.comma = !!t.comma, this.precision = void 0 === t.precision ? void 0 : +t.precision, this.trim = !!t.trim, this.type = void 0 === t.type ? "" : t.type + "";
+  }
+  function s(t, r) {
+    var n = i(t, r);
+    if (!n) return t + "";
+    var e = n[0],
+      o = n[1];
+    return o < 0 ? "0." + new Array(-o).join("0") + e : e.length > o + 1 ? e.slice(0, o + 1) + "." + e.slice(o + 1) : e + new Array(o - e.length + 2).join("0");
+  }
+  o.prototype = a.prototype, a.prototype.toString = function () {
+    return this.fill + this.align + this.sign + this.symbol + (this.zero ? "0" : "") + (void 0 === this.width ? "" : Math.max(1, 0 | this.width)) + (this.comma ? "," : "") + (void 0 === this.precision ? "" : "." + Math.max(0, 0 | this.precision)) + (this.trim ? "~" : "") + this.type;
+  };
+  var c = {
+    "%": (t, i) => (100 * t).toFixed(i),
+    b: t => Math.round(t).toString(2),
+    c: t => t + "",
+    d: function (t) {
+      return Math.abs(t = Math.round(t)) >= 1e21 ? t.toLocaleString("en").replace(/,/g, "") : t.toString(10);
+    },
+    e: (t, i) => t.toExponential(i),
+    f: (t, i) => t.toFixed(i),
+    g: (t, i) => t.toPrecision(i),
+    o: t => Math.round(t).toString(8),
+    p: (t, i) => s(100 * t, i),
+    r: s,
+    s: function (t, r) {
+      var e = i(t, r);
+      if (!e) return t + "";
+      var o = e[0],
+        a = e[1],
+        s = a - (n = 3 * Math.max(-8, Math.min(8, Math.floor(a / 3)))) + 1,
+        c = o.length;
+      return s === c ? o : s > c ? o + new Array(s - c + 1).join("0") : s > 0 ? o.slice(0, s) + "." + o.slice(s) : "0." + new Array(1 - s).join("0") + i(t, Math.max(0, r + s - 1))[0];
+    },
+    X: t => Math.round(t).toString(16).toUpperCase(),
+    x: t => Math.round(t).toString(16)
+  };
+  function h(t) {
+    return t;
+  }
+  var l,
+    u = Array.prototype.map,
+    f = ["y", "z", "a", "f", "p", "n", "µ", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y"];
+  function d(t) {
+    var i,
+      e,
+      a = void 0 === t.grouping || void 0 === t.thousands ? h : (i = u.call(t.grouping, Number), e = t.thousands + "", function (t, r) {
+        for (var n = t.length, o = [], a = 0, s = i[0], c = 0; n > 0 && s > 0 && (c + s + 1 > r && (s = Math.max(1, r - c)), o.push(t.substring(n -= s, n + s)), !((c += s + 1) > r));) s = i[a = (a + 1) % i.length];
+        return o.reverse().join(e);
+      }),
+      s = void 0 === t.currency ? "" : t.currency[0] + "",
+      l = void 0 === t.currency ? "" : t.currency[1] + "",
+      d = void 0 === t.decimal ? "." : t.decimal + "",
+      m = void 0 === t.numerals ? h : function (t) {
+        return function (i) {
+          return i.replace(/[0-9]/g, function (i) {
+            return t[+i];
+          });
+        };
+      }(u.call(t.numerals, String)),
+      p = void 0 === t.percent ? "%" : t.percent + "",
+      g = void 0 === t.minus ? "−" : t.minus + "",
+      v = void 0 === t.nan ? "NaN" : t.nan + "";
+    function M(t) {
+      var i = (t = o(t)).fill,
+        r = t.align,
+        e = t.sign,
+        h = t.symbol,
+        u = t.zero,
+        M = t.width,
+        y = t.comma,
+        x = t.precision,
+        b = t.trim,
+        w = t.type;
+      "n" === w ? (y = !0, w = "g") : c[w] || (void 0 === x && (x = 12), b = !0, w = "g"), (u || "0" === i && "=" === r) && (u = !0, i = "0", r = "=");
+      var S = "$" === h ? s : "#" === h && /[boxX]/.test(w) ? "0" + w.toLowerCase() : "",
+        j = "$" === h ? l : /[%p]/.test(w) ? p : "",
+        k = c[w],
+        P = /[defgprs%]/.test(w);
+      function z(t) {
+        var o,
+          s,
+          c,
+          h = S,
+          l = j;
+        if ("c" === w) l = k(t) + l, t = "";else {
+          var p = (t = +t) < 0 || 1 / t < 0;
+          if (t = isNaN(t) ? v : k(Math.abs(t), x), b && (t = function (t) {
+            t: for (var i, r = t.length, n = 1, e = -1; n < r; ++n) switch (t[n]) {
+              case ".":
+                e = i = n;
+                break;
+              case "0":
+                0 === e && (e = n), i = n;
+                break;
+              default:
+                if (!+t[n]) break t;
+                e > 0 && (e = 0);
+            }
+            return e > 0 ? t.slice(0, e) + t.slice(i + 1) : t;
+          }(t)), p && 0 == +t && "+" !== e && (p = !1), h = (p ? "(" === e ? e : g : "-" === e || "(" === e ? "" : e) + h, l = ("s" === w ? f[8 + n / 3] : "") + l + (p && "(" === e ? ")" : ""), P) for (o = -1, s = t.length; ++o < s;) if (48 > (c = t.charCodeAt(o)) || c > 57) {
+            l = (46 === c ? d + t.slice(o + 1) : t.slice(o)) + l, t = t.slice(0, o);
+            break;
+          }
+        }
+        y && !u && (t = a(t, 1 / 0));
+        var z = h.length + t.length + l.length,
+          A = z < M ? new Array(M - z + 1).join(i) : "";
+        switch (y && u && (t = a(A + t, A.length ? M - l.length : 1 / 0), A = ""), r) {
+          case "<":
+            t = h + t + l + A;
+            break;
+          case "=":
+            t = h + A + t + l;
+            break;
+          case "^":
+            t = A.slice(0, z = A.length >> 1) + h + t + l + A.slice(z);
+            break;
+          default:
+            t = A + h + t + l;
+        }
+        return m(t);
+      }
+      return x = void 0 === x ? 6 : /[gprs]/.test(w) ? Math.max(1, Math.min(21, x)) : Math.max(0, Math.min(20, x)), z.toString = function () {
+        return t + "";
+      }, z;
+    }
+    return {
+      format: M,
+      formatPrefix: function (t, i) {
+        var n = M(((t = o(t)).type = "f", t)),
+          e = 3 * Math.max(-8, Math.min(8, Math.floor(r(i) / 3))),
+          a = Math.pow(10, -e),
+          s = f[8 + e / 3];
+        return function (t) {
+          return n(a * t) + s;
+        };
+      }
+    };
+  }
+  function m(i) {
+    return l = d(i), t.format = l.format, t.formatPrefix = l.formatPrefix, l;
+  }
+  t.format = void 0, t.formatPrefix = void 0, m({
+    thousands: ",",
+    grouping: [3],
+    currency: ["$", ""]
+  }), t.FormatSpecifier = a, t.formatDefaultLocale = m, t.formatLocale = d, t.formatSpecifier = o, t.precisionFixed = function (t) {
+    return Math.max(0, -r(Math.abs(t)));
+  }, t.precisionPrefix = function (t, i) {
+    return Math.max(0, 3 * Math.max(-8, Math.min(8, Math.floor(r(i) / 3))) - r(Math.abs(t)));
+  }, t.precisionRound = function (t, i) {
+    return t = Math.abs(t), i = Math.abs(i) - t, Math.max(0, r(i) - r(t)) + 1;
+  }, Object.defineProperty(t, "__esModule", {
+    value: !0
+  });
+});

package/lib-vendor/d3-format/src/defaultLocale.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = defaultLocale;
+exports.formatPrefix = exports.format = void 0;
+var _locale = _interopRequireDefault(require("./locale.js"));
+var locale;
+var format;
+var formatPrefix;
+defaultLocale({
+  thousands: ",",
+  grouping: [3],
+  currency: ["$", ""]
+});
+function defaultLocale(definition) {
+  locale = (0, _locale.default)(definition);
+  exports.format = format = locale.format;
+  exports.formatPrefix = formatPrefix = locale.formatPrefix;
+  return locale;
+}

package/lib-vendor/d3-format/src/exponent.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _formatDecimal = require("./formatDecimal.js");
+function _default(x) {
+  return x = (0, _formatDecimal.formatDecimalParts)(Math.abs(x)), x ? x[1] : NaN;
+}

package/lib-vendor/d3-format/src/formatDecimal.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+exports.formatDecimalParts = formatDecimalParts;
+function _default(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)];
+}

package/lib-vendor/d3-format/src/formatGroup.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+function _default(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);
+  };
+}

package/lib-vendor/d3-format/src/formatNumerals.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+function _default(numerals) {
+  return function (value) {
+    return value.replace(/[0-9]/g, function (i) {
+      return numerals[+i];
+    });
+  };
+}

package/lib-vendor/d3-format/src/formatPrefixAuto.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+exports.prefixExponent = void 0;
+var _formatDecimal = require("./formatDecimal.js");
+var prefixExponent;
+function _default(x, p) {
+  var d = (0, _formatDecimal.formatDecimalParts)(x, p);
+  if (!d) return x + "";
+  var coefficient = d[0],
+    exponent = d[1],
+    i = exponent - (exports.prefixExponent = 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") + (0, _formatDecimal.formatDecimalParts)(x, Math.max(0, p + i - 1))[0]; // less than 1y!
+}

package/lib-vendor/d3-format/src/formatRounded.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _formatDecimal = require("./formatDecimal.js");
+function _default(x, p) {
+  var d = (0, _formatDecimal.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");
+}

package/lib-vendor/d3-format/src/formatSpecifier.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FormatSpecifier = FormatSpecifier;
+exports.default = formatSpecifier;
+// [[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;
+};