@veritone-ce/design-system 2.8.12 → 2.8.13-next.1

package/dist/cjs/bundled_modules/d3-hierarchy/src/treemap/squarify.js

@@ -0,0 +1,74 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dice = require('./dice.js');
+var slice = require('./slice.js');
+
+var phi = (1 + Math.sqrt(5)) / 2;
+
+function squarifyRatio(ratio, parent, x0, y0, x1, y1) {
+  var rows = [],
+      nodes = parent.children,
+      row,
+      nodeValue,
+      i0 = 0,
+      i1 = 0,
+      n = nodes.length,
+      dx, dy,
+      value = parent.value,
+      sumValue,
+      minValue,
+      maxValue,
+      newRatio,
+      minRatio,
+      alpha,
+      beta;
+
+  while (i0 < n) {
+    dx = x1 - x0, dy = y1 - y0;
+
+    // Find the next non-empty node.
+    do sumValue = nodes[i1++].value; while (!sumValue && i1 < n);
+    minValue = maxValue = sumValue;
+    alpha = Math.max(dy / dx, dx / dy) / (value * ratio);
+    beta = sumValue * sumValue * alpha;
+    minRatio = Math.max(maxValue / beta, beta / minValue);
+
+    // Keep adding nodes while the aspect ratio maintains or improves.
+    for (; i1 < n; ++i1) {
+      sumValue += nodeValue = nodes[i1].value;
+      if (nodeValue < minValue) minValue = nodeValue;
+      if (nodeValue > maxValue) maxValue = nodeValue;
+      beta = sumValue * sumValue * alpha;
+      newRatio = Math.max(maxValue / beta, beta / minValue);
+      if (newRatio > minRatio) { sumValue -= nodeValue; break; }
+      minRatio = newRatio;
+    }
+
+    // Position and record the row orientation.
+    rows.push(row = {value: sumValue, dice: dx < dy, children: nodes.slice(i0, i1)});
+    if (row.dice) dice.default(row, x0, y0, x1, value ? y0 += dy * sumValue / value : y1);
+    else slice.default(row, x0, y0, value ? x0 += dx * sumValue / value : x1, y1);
+    value -= sumValue, i0 = i1;
+  }
+
+  return rows;
+}
+
+var treemapSquarify = (function custom(ratio) {
+
+  function squarify(parent, x0, y0, x1, y1) {
+    squarifyRatio(ratio, parent, x0, y0, x1, y1);
+  }
+
+  squarify.ratio = function(x) {
+    return custom((x = +x) > 1 ? x : 1);
+  };
+
+  return squarify;
+})(phi);
+
+exports.default = treemapSquarify;
+exports.phi = phi;
+exports.squarifyRatio = squarifyRatio;

package/dist/cjs/bundled_modules/d3-interpolate/src/array.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var value = require('./value.js');
+var numberArray = require('./numberArray.js');
+
+function array(a, b) {
+  return (numberArray.isNumberArray(b) ? numberArray.default : genericArray)(a, b);
+}
+
+function genericArray(a, b) {
+  var nb = b ? b.length : 0,
+      na = a ? Math.min(nb, a.length) : 0,
+      x = new Array(na),
+      c = new Array(nb),
+      i;
+
+  for (i = 0; i < na; ++i) x[i] = value.default(a[i], b[i]);
+  for (; i < nb; ++i) c[i] = b[i];
+
+  return function(t) {
+    for (i = 0; i < na; ++i) c[i] = x[i](t);
+    return c;
+  };
+}
+
+exports.default = array;
+exports.genericArray = genericArray;

package/dist/cjs/bundled_modules/d3-interpolate/src/basis.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function basis(t1, v0, v1, v2, v3) {
+  var t2 = t1 * t1, t3 = t2 * t1;
+  return ((1 - 3 * t1 + 3 * t2 - t3) * v0
+      + (4 - 6 * t2 + 3 * t3) * v1
+      + (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2
+      + t3 * v3) / 6;
+}
+
+function basis$1(values) {
+  var n = values.length - 1;
+  return function(t) {
+    var i = t <= 0 ? (t = 0) : t >= 1 ? (t = 1, n - 1) : Math.floor(t * n),
+        v1 = values[i],
+        v2 = values[i + 1],
+        v0 = i > 0 ? values[i - 1] : 2 * v1 - v2,
+        v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1;
+    return basis((t - i / n) * n, v0, v1, v2, v3);
+  };
+}
+
+exports.basis = basis;
+exports.default = basis$1;

package/dist/cjs/bundled_modules/d3-interpolate/src/basisClosed.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var basis = require('./basis.js');
+
+function basisClosed(values) {
+  var n = values.length;
+  return function(t) {
+    var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n),
+        v0 = values[(i + n - 1) % n],
+        v1 = values[i % n],
+        v2 = values[(i + 1) % n],
+        v3 = values[(i + 2) % n];
+    return basis.basis((t - i / n) * n, v0, v1, v2, v3);
+  };
+}
+
+exports.default = basisClosed;

package/dist/cjs/bundled_modules/d3-interpolate/src/color.js

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constant = require('./constant.js');
+
+function linear(a, d) {
+  return function(t) {
+    return a + t * d;
+  };
+}
+
+function exponential(a, b, y) {
+  return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) {
+    return Math.pow(a + t * b, y);
+  };
+}
+
+function hue(a, b) {
+  var d = b - a;
+  return d ? linear(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : constant.default(isNaN(a) ? b : a);
+}
+
+function gamma(y) {
+  return (y = +y) === 1 ? nogamma : function(a, b) {
+    return b - a ? exponential(a, b, y) : constant.default(isNaN(a) ? b : a);
+  };
+}
+
+function nogamma(a, b) {
+  var d = b - a;
+  return d ? linear(a, d) : constant.default(isNaN(a) ? b : a);
+}
+
+exports.default = nogamma;
+exports.gamma = gamma;
+exports.hue = hue;

package/dist/cjs/bundled_modules/d3-interpolate/src/constant.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constant = x => () => x;
+
+exports.default = constant;

package/dist/cjs/bundled_modules/d3-interpolate/src/cubehelix.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var color = require('./color.js');
+var cubehelix$2 = require('../../d3-color/src/cubehelix.js');
+
+function cubehelix(hue) {
+  return (function cubehelixGamma(y) {
+    y = +y;
+
+    function cubehelix(start, end) {
+      var h = hue((start = cubehelix$2.default(start)).h, (end = cubehelix$2.default(end)).h),
+          s = color.default(start.s, end.s),
+          l = color.default(start.l, end.l),
+          opacity = color.default(start.opacity, end.opacity);
+      return function(t) {
+        start.h = h(t);
+        start.s = s(t);
+        start.l = l(Math.pow(t, y));
+        start.opacity = opacity(t);
+        return start + "";
+      };
+    }
+
+    cubehelix.gamma = cubehelixGamma;
+
+    return cubehelix;
+  })(1);
+}
+
+var cubehelix$1 = cubehelix(color.hue);
+var cubehelixLong = cubehelix(color.default);
+
+exports.cubehelixLong = cubehelixLong;
+exports.default = cubehelix$1;

package/dist/cjs/bundled_modules/d3-interpolate/src/date.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function date(a, b) {
+  var d = new Date;
+  return a = +a, b = +b, function(t) {
+    return d.setTime(a * (1 - t) + b * t), d;
+  };
+}
+
+exports.default = date;

package/dist/cjs/bundled_modules/d3-interpolate/src/discrete.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function discrete(range) {
+  var n = range.length;
+  return function(t) {
+    return range[Math.max(0, Math.min(n - 1, Math.floor(t * n)))];
+  };
+}
+
+exports.default = discrete;

package/dist/cjs/bundled_modules/d3-interpolate/src/hcl.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var color = require('./color.js');
+var lab = require('../../d3-color/src/lab.js');
+
+function hcl(hue) {
+  return function(start, end) {
+    var h = hue((start = lab.hcl(start)).h, (end = lab.hcl(end)).h),
+        c = color.default(start.c, end.c),
+        l = color.default(start.l, end.l),
+        opacity = color.default(start.opacity, end.opacity);
+    return function(t) {
+      start.h = h(t);
+      start.c = c(t);
+      start.l = l(t);
+      start.opacity = opacity(t);
+      return start + "";
+    };
+  }
+}
+
+var hcl$1 = hcl(color.hue);
+var hclLong = hcl(color.default);
+
+exports.default = hcl$1;
+exports.hclLong = hclLong;

package/dist/cjs/bundled_modules/d3-interpolate/src/hsl.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var color$1 = require('./color.js');
+var color = require('../../d3-color/src/color.js');
+
+function hsl(hue) {
+  return function(start, end) {
+    var h = hue((start = color.hsl(start)).h, (end = color.hsl(end)).h),
+        s = color$1.default(start.s, end.s),
+        l = color$1.default(start.l, end.l),
+        opacity = color$1.default(start.opacity, end.opacity);
+    return function(t) {
+      start.h = h(t);
+      start.s = s(t);
+      start.l = l(t);
+      start.opacity = opacity(t);
+      return start + "";
+    };
+  }
+}
+
+var hsl$1 = hsl(color$1.hue);
+var hslLong = hsl(color$1.default);
+
+exports.default = hsl$1;
+exports.hslLong = hslLong;

package/dist/cjs/bundled_modules/d3-interpolate/src/hue.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var color = require('./color.js');
+
+function hue(a, b) {
+  var i = color.hue(+a, +b);
+  return function(t) {
+    var x = i(t);
+    return x - 360 * Math.floor(x / 360);
+  };
+}
+
+exports.default = hue;

package/dist/cjs/bundled_modules/d3-interpolate/src/index.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var value = require('./value.js');
+var array = require('./array.js');
+var basis = require('./basis.js');
+var basisClosed = require('./basisClosed.js');
+var date = require('./date.js');
+var discrete = require('./discrete.js');
+var hue = require('./hue.js');
+var number = require('./number.js');
+var numberArray = require('./numberArray.js');
+var object = require('./object.js');
+var round = require('./round.js');
+var string = require('./string.js');
+var index = require('./transform/index.js');
+var zoom = require('./zoom.js');
+var rgb = require('./rgb.js');
+var hsl = require('./hsl.js');
+var lab = require('./lab.js');
+var hcl = require('./hcl.js');
+var cubehelix = require('./cubehelix.js');
+var piecewise = require('./piecewise.js');
+var quantize = require('./quantize.js');
+
+
+
+exports.interpolate = value.default;
+exports.interpolateArray = array.default;
+exports.interpolateBasis = basis.default;
+exports.interpolateBasisClosed = basisClosed.default;
+exports.interpolateDate = date.default;
+exports.interpolateDiscrete = discrete.default;
+exports.interpolateHue = hue.default;
+exports.interpolateNumber = number.default;
+exports.interpolateNumberArray = numberArray.default;
+exports.interpolateObject = object.default;
+exports.interpolateRound = round.default;
+exports.interpolateString = string.default;
+exports.interpolateTransformCss = index.interpolateTransformCss;
+exports.interpolateTransformSvg = index.interpolateTransformSvg;
+exports.interpolateZoom = zoom.default;
+exports.interpolateRgb = rgb.default;
+exports.interpolateRgbBasis = rgb.rgbBasis;
+exports.interpolateRgbBasisClosed = rgb.rgbBasisClosed;
+exports.interpolateHsl = hsl.default;
+exports.interpolateHslLong = hsl.hslLong;
+exports.interpolateLab = lab.default;
+exports.interpolateHcl = hcl.default;
+exports.interpolateHclLong = hcl.hclLong;
+exports.interpolateCubehelix = cubehelix.default;
+exports.interpolateCubehelixLong = cubehelix.cubehelixLong;
+exports.piecewise = piecewise.default;
+exports.quantize = quantize.default;

package/dist/cjs/bundled_modules/d3-interpolate/src/lab.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var color = require('./color.js');
+var lab$1 = require('../../d3-color/src/lab.js');
+
+function lab(start, end) {
+  var l = color.default((start = lab$1.default(start)).l, (end = lab$1.default(end)).l),
+      a = color.default(start.a, end.a),
+      b = color.default(start.b, end.b),
+      opacity = color.default(start.opacity, end.opacity);
+  return function(t) {
+    start.l = l(t);
+    start.a = a(t);
+    start.b = b(t);
+    start.opacity = opacity(t);
+    return start + "";
+  };
+}
+
+exports.default = lab;

package/dist/cjs/bundled_modules/d3-interpolate/src/number.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function interpolateNumber(a, b) {
+  return a = +a, b = +b, function(t) {
+    return a * (1 - t) + b * t;
+  };
+}
+
+exports.default = interpolateNumber;

package/dist/cjs/bundled_modules/d3-interpolate/src/numberArray.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function numberArray(a, b) {
+  if (!b) b = [];
+  var n = a ? Math.min(b.length, a.length) : 0,
+      c = b.slice(),
+      i;
+  return function(t) {
+    for (i = 0; i < n; ++i) c[i] = a[i] * (1 - t) + b[i] * t;
+    return c;
+  };
+}
+
+function isNumberArray(x) {
+  return ArrayBuffer.isView(x) && !(x instanceof DataView);
+}
+
+exports.default = numberArray;
+exports.isNumberArray = isNumberArray;

package/dist/cjs/bundled_modules/d3-interpolate/src/object.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var value = require('./value.js');
+
+function object(a, b) {
+  var i = {},
+      c = {},
+      k;
+
+  if (a === null || typeof a !== "object") a = {};
+  if (b === null || typeof b !== "object") b = {};
+
+  for (k in b) {
+    if (k in a) {
+      i[k] = value.default(a[k], b[k]);
+    } else {
+      c[k] = b[k];
+    }
+  }
+
+  return function(t) {
+    for (k in i) c[k] = i[k](t);
+    return c;
+  };
+}
+
+exports.default = object;

package/dist/cjs/bundled_modules/d3-interpolate/src/piecewise.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var value = require('./value.js');
+
+function piecewise(interpolate, values) {
+  if (values === undefined) values = interpolate, interpolate = value.default;
+  var i = 0, n = values.length - 1, v = values[0], I = new Array(n < 0 ? 0 : n);
+  while (i < n) I[i] = interpolate(v, v = values[++i]);
+  return function(t) {
+    var i = Math.max(0, Math.min(n - 1, Math.floor(t *= n)));
+    return I[i](t - i);
+  };
+}
+
+exports.default = piecewise;

package/dist/cjs/bundled_modules/d3-interpolate/src/quantize.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function quantize(interpolator, n) {
+  var samples = new Array(n);
+  for (var i = 0; i < n; ++i) samples[i] = interpolator(i / (n - 1));
+  return samples;
+}
+
+exports.default = quantize;

package/dist/cjs/bundled_modules/d3-interpolate/src/rgb.js

@@ -0,0 +1,63 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var basis = require('./basis.js');
+var basisClosed = require('./basisClosed.js');
+var color = require('./color.js');
+var color$1 = require('../../d3-color/src/color.js');
+
+var rgb = (function rgbGamma(y) {
+  var color$2 = color.gamma(y);
+
+  function rgb(start, end) {
+    var r = color$2((start = color$1.rgb(start)).r, (end = color$1.rgb(end)).r),
+        g = color$2(start.g, end.g),
+        b = color$2(start.b, end.b),
+        opacity = color.default(start.opacity, end.opacity);
+    return function(t) {
+      start.r = r(t);
+      start.g = g(t);
+      start.b = b(t);
+      start.opacity = opacity(t);
+      return start + "";
+    };
+  }
+
+  rgb.gamma = rgbGamma;
+
+  return rgb;
+})(1);
+
+function rgbSpline(spline) {
+  return function(colors) {
+    var n = colors.length,
+        r = new Array(n),
+        g = new Array(n),
+        b = new Array(n),
+        i, color;
+    for (i = 0; i < n; ++i) {
+      color = color$1.rgb(colors[i]);
+      r[i] = color.r || 0;
+      g[i] = color.g || 0;
+      b[i] = color.b || 0;
+    }
+    r = spline(r);
+    g = spline(g);
+    b = spline(b);
+    color.opacity = 1;
+    return function(t) {
+      color.r = r(t);
+      color.g = g(t);
+      color.b = b(t);
+      return color + "";
+    };
+  };
+}
+
+var rgbBasis = rgbSpline(basis.default);
+var rgbBasisClosed = rgbSpline(basisClosed.default);
+
+exports.default = rgb;
+exports.rgbBasis = rgbBasis;
+exports.rgbBasisClosed = rgbBasisClosed;

package/dist/cjs/bundled_modules/d3-interpolate/src/round.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function interpolateRound(a, b) {
+  return a = +a, b = +b, function(t) {
+    return Math.round(a * (1 - t) + b * t);
+  };
+}
+
+exports.default = interpolateRound;

package/dist/cjs/bundled_modules/d3-interpolate/src/string.js

@@ -0,0 +1,70 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var number = require('./number.js');
+
+var reA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,
+    reB = new RegExp(reA.source, "g");
+
+function zero(b) {
+  return function() {
+    return b;
+  };
+}
+
+function one(b) {
+  return function(t) {
+    return b(t) + "";
+  };
+}
+
+function string(a, b) {
+  var bi = reA.lastIndex = reB.lastIndex = 0, // scan index for next number in b
+      am, // current match in a
+      bm, // current match in b
+      bs, // string preceding current number in b, if any
+      i = -1, // index in s
+      s = [], // string constants and placeholders
+      q = []; // number interpolators
+
+  // Coerce inputs to strings.
+  a = a + "", b = b + "";
+
+  // Interpolate pairs of numbers in a & b.
+  while ((am = reA.exec(a))
+      && (bm = reB.exec(b))) {
+    if ((bs = bm.index) > bi) { // a string precedes the next number in b
+      bs = b.slice(bi, bs);
+      if (s[i]) s[i] += bs; // coalesce with previous string
+      else s[++i] = bs;
+    }
+    if ((am = am[0]) === (bm = bm[0])) { // numbers in a & b match
+      if (s[i]) s[i] += bm; // coalesce with previous string
+      else s[++i] = bm;
+    } else { // interpolate non-matching numbers
+      s[++i] = null;
+      q.push({i: i, x: number.default(am, bm)});
+    }
+    bi = reB.lastIndex;
+  }
+
+  // Add remains of b.
+  if (bi < b.length) {
+    bs = b.slice(bi);
+    if (s[i]) s[i] += bs; // coalesce with previous string
+    else s[++i] = bs;
+  }
+
+  // Special optimization for only a single match.
+  // Otherwise, interpolate each of the numbers and rejoin the string.
+  return s.length < 2 ? (q[0]
+      ? one(q[0].x)
+      : zero(b))
+      : (b = q.length, function(t) {
+          for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t);
+          return s.join("");
+        });
+}
+
+exports.default = string;