@veritone-ce/design-system 2.9.0-next.2 → 2.9.0-next.3

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;

package/dist/cjs/bundled_modules/d3-interpolate/src/transform/decompose.js

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var degrees = 180 / Math.PI;
+
+var identity = {
+  translateX: 0,
+  translateY: 0,
+  rotate: 0,
+  skewX: 0,
+  scaleX: 1,
+  scaleY: 1
+};
+
+function decompose(a, b, c, d, e, f) {
+  var scaleX, scaleY, skewX;
+  if (scaleX = Math.sqrt(a * a + b * b)) a /= scaleX, b /= scaleX;
+  if (skewX = a * c + b * d) c -= a * skewX, d -= b * skewX;
+  if (scaleY = Math.sqrt(c * c + d * d)) c /= scaleY, d /= scaleY, skewX /= scaleY;
+  if (a * d < b * c) a = -a, b = -b, skewX = -skewX, scaleX = -scaleX;
+  return {
+    translateX: e,
+    translateY: f,
+    rotate: Math.atan2(b, a) * degrees,
+    skewX: Math.atan(skewX) * degrees,
+    scaleX: scaleX,
+    scaleY: scaleY
+  };
+}
+
+exports.default = decompose;
+exports.identity = identity;

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

@@ -0,0 +1,68 @@
+'use strict';
+
+var number = require('../number.js');
+var parse = require('./parse.js');
+
+function interpolateTransform(parse, pxComma, pxParen, degParen) {
+
+  function pop(s) {
+    return s.length ? s.pop() + " " : "";
+  }
+
+  function translate(xa, ya, xb, yb, s, q) {
+    if (xa !== xb || ya !== yb) {
+      var i = s.push("translate(", null, pxComma, null, pxParen);
+      q.push({i: i - 4, x: number.default(xa, xb)}, {i: i - 2, x: number.default(ya, yb)});
+    } else if (xb || yb) {
+      s.push("translate(" + xb + pxComma + yb + pxParen);
+    }
+  }
+
+  function rotate(a, b, s, q) {
+    if (a !== b) {
+      if (a - b > 180) b += 360; else if (b - a > 180) a += 360; // shortest path
+      q.push({i: s.push(pop(s) + "rotate(", null, degParen) - 2, x: number.default(a, b)});
+    } else if (b) {
+      s.push(pop(s) + "rotate(" + b + degParen);
+    }
+  }
+
+  function skewX(a, b, s, q) {
+    if (a !== b) {
+      q.push({i: s.push(pop(s) + "skewX(", null, degParen) - 2, x: number.default(a, b)});
+    } else if (b) {
+      s.push(pop(s) + "skewX(" + b + degParen);
+    }
+  }
+
+  function scale(xa, ya, xb, yb, s, q) {
+    if (xa !== xb || ya !== yb) {
+      var i = s.push(pop(s) + "scale(", null, ",", null, ")");
+      q.push({i: i - 4, x: number.default(xa, xb)}, {i: i - 2, x: number.default(ya, yb)});
+    } else if (xb !== 1 || yb !== 1) {
+      s.push(pop(s) + "scale(" + xb + "," + yb + ")");
+    }
+  }
+
+  return function(a, b) {
+    var s = [], // string constants and placeholders
+        q = []; // number interpolators
+    a = parse(a), b = parse(b);
+    translate(a.translateX, a.translateY, b.translateX, b.translateY, s, q);
+    rotate(a.rotate, b.rotate, s, q);
+    skewX(a.skewX, b.skewX, s, q);
+    scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q);
+    a = b = null; // gc
+    return function(t) {
+      var i = -1, n = q.length, o;
+      while (++i < n) s[(o = q[i]).i] = o.x(t);
+      return s.join("");
+    };
+  };
+}
+
+var interpolateTransformCss = interpolateTransform(parse.parseCss, "px, ", "px)", "deg)");
+var interpolateTransformSvg = interpolateTransform(parse.parseSvg, ", ", ")", ")");
+
+exports.interpolateTransformCss = interpolateTransformCss;
+exports.interpolateTransformSvg = interpolateTransformSvg;

package/dist/cjs/bundled_modules/d3-interpolate/src/transform/parse.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var decompose = require('./decompose.js');
+
+var svgNode;
+
+/* eslint-disable no-undef */
+function parseCss(value) {
+  const m = new (typeof DOMMatrix === "function" ? DOMMatrix : WebKitCSSMatrix)(value + "");
+  return m.isIdentity ? decompose.identity : decompose.default(m.a, m.b, m.c, m.d, m.e, m.f);
+}
+
+function parseSvg(value) {
+  if (value == null) return decompose.identity;
+  if (!svgNode) svgNode = document.createElementNS("http://www.w3.org/2000/svg", "g");
+  svgNode.setAttribute("transform", value);
+  if (!(value = svgNode.transform.baseVal.consolidate())) return decompose.identity;
+  value = value.matrix;
+  return decompose.default(value.a, value.b, value.c, value.d, value.e, value.f);
+}
+
+exports.parseCss = parseCss;
+exports.parseSvg = parseSvg;

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

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var rgb = require('./rgb.js');
+var array = require('./array.js');
+var date = require('./date.js');
+var number = require('./number.js');
+var object = require('./object.js');
+var string = require('./string.js');
+var constant = require('./constant.js');
+var numberArray = require('./numberArray.js');
+var color = require('../../d3-color/src/color.js');
+
+function interpolate$1(a, b) {
+  var t = typeof b, c;
+  return b == null || t === "boolean" ? constant.default(b)
+      : (t === "number" ? number.default
+      : t === "string" ? ((c = color.default(b)) ? (b = c, rgb.default) : string.default)
+      : b instanceof color.default ? rgb.default
+      : b instanceof Date ? date.default
+      : numberArray.isNumberArray(b) ? numberArray.default
+      : Array.isArray(b) ? array.genericArray
+      : typeof b.valueOf !== "function" && typeof b.toString !== "function" || isNaN(b) ? object.default
+      : number.default)(a, b);
+}
+
+exports.default = interpolate$1;