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

package/dist/cjs/bundled_modules/d3-geo/src/path/centroid.js

@@ -1,104 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var math = require('../math.js');
-
-// TODO Enforce positive area for exterior, negative area for interior?
-
-var X0 = 0,
-    Y0 = 0,
-    Z0 = 0,
-    X1 = 0,
-    Y1 = 0,
-    Z1 = 0,
-    X2 = 0,
-    Y2 = 0,
-    Z2 = 0,
-    x00,
-    y00,
-    x0,
-    y0;
-
-var centroidStream = {
-  point: centroidPoint,
-  lineStart: centroidLineStart,
-  lineEnd: centroidLineEnd,
-  polygonStart: function() {
-    centroidStream.lineStart = centroidRingStart;
-    centroidStream.lineEnd = centroidRingEnd;
-  },
-  polygonEnd: function() {
-    centroidStream.point = centroidPoint;
-    centroidStream.lineStart = centroidLineStart;
-    centroidStream.lineEnd = centroidLineEnd;
-  },
-  result: function() {
-    var centroid = Z2 ? [X2 / Z2, Y2 / Z2]
-        : Z1 ? [X1 / Z1, Y1 / Z1]
-        : Z0 ? [X0 / Z0, Y0 / Z0]
-        : [NaN, NaN];
-    X0 = Y0 = Z0 =
-    X1 = Y1 = Z1 =
-    X2 = Y2 = Z2 = 0;
-    return centroid;
-  }
-};
-
-function centroidPoint(x, y) {
-  X0 += x;
-  Y0 += y;
-  ++Z0;
-}
-
-function centroidLineStart() {
-  centroidStream.point = centroidPointFirstLine;
-}
-
-function centroidPointFirstLine(x, y) {
-  centroidStream.point = centroidPointLine;
-  centroidPoint(x0 = x, y0 = y);
-}
-
-function centroidPointLine(x, y) {
-  var dx = x - x0, dy = y - y0, z = math.sqrt(dx * dx + dy * dy);
-  X1 += z * (x0 + x) / 2;
-  Y1 += z * (y0 + y) / 2;
-  Z1 += z;
-  centroidPoint(x0 = x, y0 = y);
-}
-
-function centroidLineEnd() {
-  centroidStream.point = centroidPoint;
-}
-
-function centroidRingStart() {
-  centroidStream.point = centroidPointFirstRing;
-}
-
-function centroidRingEnd() {
-  centroidPointRing(x00, y00);
-}
-
-function centroidPointFirstRing(x, y) {
-  centroidStream.point = centroidPointRing;
-  centroidPoint(x00 = x0 = x, y00 = y0 = y);
-}
-
-function centroidPointRing(x, y) {
-  var dx = x - x0,
-      dy = y - y0,
-      z = math.sqrt(dx * dx + dy * dy);
-
-  X1 += z * (x0 + x) / 2;
-  Y1 += z * (y0 + y) / 2;
-  Z1 += z;
-
-  z = y0 * x - x0 * y;
-  X2 += z * (x0 + x);
-  Y2 += z * (y0 + y);
-  Z2 += z * 3;
-  centroidPoint(x0 = x, y0 = y);
-}
-
-exports.default = centroidStream;

package/dist/cjs/bundled_modules/d3-geo/src/path/context.js

@@ -1,51 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var math = require('../math.js');
-var noop = require('../noop.js');
-
-function PathContext(context) {
-  this._context = context;
-}
-
-PathContext.prototype = {
-  _radius: 4.5,
-  pointRadius: function(_) {
-    return this._radius = _, this;
-  },
-  polygonStart: function() {
-    this._line = 0;
-  },
-  polygonEnd: function() {
-    this._line = NaN;
-  },
-  lineStart: function() {
-    this._point = 0;
-  },
-  lineEnd: function() {
-    if (this._line === 0) this._context.closePath();
-    this._point = NaN;
-  },
-  point: function(x, y) {
-    switch (this._point) {
-      case 0: {
-        this._context.moveTo(x, y);
-        this._point = 1;
-        break;
-      }
-      case 1: {
-        this._context.lineTo(x, y);
-        break;
-      }
-      default: {
-        this._context.moveTo(x + this._radius, y);
-        this._context.arc(x, y, this._radius, 0, math.tau);
-        break;
-      }
-    }
-  },
-  result: noop.default
-};
-
-exports.default = PathContext;

package/dist/cjs/bundled_modules/d3-geo/src/path/index.js

@@ -1,82 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var identity = require('../identity.js');
-var stream = require('../stream.js');
-var area = require('./area.js');
-var bounds = require('./bounds.js');
-var centroid = require('./centroid.js');
-var context = require('./context.js');
-var measure = require('./measure.js');
-var string = require('./string.js');
-
-function geoPath(projection, context$1) {
-  let digits = 3,
-      pointRadius = 4.5,
-      projectionStream,
-      contextStream;
-
-  function path(object) {
-    if (object) {
-      if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
-      stream.default(object, projectionStream(contextStream));
-    }
-    return contextStream.result();
-  }
-
-  path.area = function(object) {
-    stream.default(object, projectionStream(area.default));
-    return area.default.result();
-  };
-
-  path.measure = function(object) {
-    stream.default(object, projectionStream(measure.default));
-    return measure.default.result();
-  };
-
-  path.bounds = function(object) {
-    stream.default(object, projectionStream(bounds.default));
-    return bounds.default.result();
-  };
-
-  path.centroid = function(object) {
-    stream.default(object, projectionStream(centroid.default));
-    return centroid.default.result();
-  };
-
-  path.projection = function(_) {
-    if (!arguments.length) return projection;
-    projectionStream = _ == null ? (projection = null, identity.default) : (projection = _).stream;
-    return path;
-  };
-
-  path.context = function(_) {
-    if (!arguments.length) return context$1;
-    contextStream = _ == null ? (context$1 = null, new string.default(digits)) : new context.default(context$1 = _);
-    if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
-    return path;
-  };
-
-  path.pointRadius = function(_) {
-    if (!arguments.length) return pointRadius;
-    pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
-    return path;
-  };
-
-  path.digits = function(_) {
-    if (!arguments.length) return digits;
-    if (_ == null) digits = null;
-    else {
-      const d = Math.floor(_);
-      if (!(d >= 0)) throw new RangeError(`invalid digits: ${_}`);
-      digits = d;
-    }
-    if (context$1 === null) contextStream = new string.default(digits);
-    return path;
-  };
-
-  return path.projection(projection).digits(digits).context(context$1);
-}
-
-exports.default = geoPath;

package/dist/cjs/bundled_modules/d3-geo/src/path/measure.js

@@ -1,49 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var math = require('../math.js');
-var noop = require('../noop.js');
-var fsum = require('../../../d3-array/src/fsum.js');
-
-var lengthSum = new fsum.Adder(),
-    lengthRing,
-    x00,
-    y00,
-    x0,
-    y0;
-
-var lengthStream = {
-  point: noop.default,
-  lineStart: function() {
-    lengthStream.point = lengthPointFirst;
-  },
-  lineEnd: function() {
-    if (lengthRing) lengthPoint(x00, y00);
-    lengthStream.point = noop.default;
-  },
-  polygonStart: function() {
-    lengthRing = true;
-  },
-  polygonEnd: function() {
-    lengthRing = null;
-  },
-  result: function() {
-    var length = +lengthSum;
-    lengthSum = new fsum.Adder();
-    return length;
-  }
-};
-
-function lengthPointFirst(x, y) {
-  lengthStream.point = lengthPoint;
-  x00 = x0 = x, y00 = y0 = y;
-}
-
-function lengthPoint(x, y) {
-  x0 -= x, y0 -= y;
-  lengthSum.add(math.sqrt(x0 * x0 + y0 * y0));
-  x0 = x, y0 = y;
-}
-
-exports.default = lengthStream;

package/dist/cjs/bundled_modules/d3-geo/src/path/string.js

@@ -1,92 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-// Simple caching for constant-radius points.
-let cacheDigits, cacheAppend, cacheRadius, cacheCircle;
-
-class PathString {
-  constructor(digits) {
-    this._append = digits == null ? append : appendRound(digits);
-    this._radius = 4.5;
-    this._ = "";
-  }
-  pointRadius(_) {
-    this._radius = +_;
-    return this;
-  }
-  polygonStart() {
-    this._line = 0;
-  }
-  polygonEnd() {
-    this._line = NaN;
-  }
-  lineStart() {
-    this._point = 0;
-  }
-  lineEnd() {
-    if (this._line === 0) this._ += "Z";
-    this._point = NaN;
-  }
-  point(x, y) {
-    switch (this._point) {
-      case 0: {
-        this._append`M${x},${y}`;
-        this._point = 1;
-        break;
-      }
-      case 1: {
-        this._append`L${x},${y}`;
-        break;
-      }
-      default: {
-        this._append`M${x},${y}`;
-        if (this._radius !== cacheRadius || this._append !== cacheAppend) {
-          const r = this._radius;
-          const s = this._;
-          this._ = ""; // stash the old string so we can cache the circle path fragment
-          this._append`m0,${r}a${r},${r} 0 1,1 0,${ -2 * r}a${r},${r} 0 1,1 0,${2 * r}z`;
-          cacheRadius = r;
-          cacheAppend = this._append;
-          cacheCircle = this._;
-          this._ = s;
-        }
-        this._ += cacheCircle;
-        break;
-      }
-    }
-  }
-  result() {
-    const result = this._;
-    this._ = "";
-    return result.length ? result : null;
-  }
-}
-
-function append(strings) {
-  let i = 1;
-  this._ += strings[0];
-  for (const j = strings.length; i < j; ++i) {
-    this._ += arguments[i] + strings[i];
-  }
-}
-
-function appendRound(digits) {
-  const d = Math.floor(digits);
-  if (!(d >= 0)) throw new RangeError(`invalid digits: ${digits}`);
-  if (d > 15) return append;
-  if (d !== cacheDigits) {
-    const k = 10 ** d;
-    cacheDigits = d;
-    cacheAppend = function append(strings) {
-      let i = 1;
-      this._ += strings[0];
-      for (const j = strings.length; i < j; ++i) {
-        this._ += Math.round(arguments[i] * k) / k + strings[i];
-      }
-    };
-  }
-  return cacheAppend;
-}
-
-exports.default = PathString;

package/dist/cjs/bundled_modules/d3-geo/src/pointEqual.js

@@ -1,11 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var math = require('./math.js');
-
-function pointEqual(a, b) {
-  return math.abs(a[0] - b[0]) < math.epsilon && math.abs(a[1] - b[1]) < math.epsilon;
-}
-
-exports.default = pointEqual;

package/dist/cjs/bundled_modules/d3-geo/src/polygonContains.js

@@ -1,80 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var cartesian = require('./cartesian.js');
-var math = require('./math.js');
-var fsum = require('../../d3-array/src/fsum.js');
-
-function longitude(point) {
-  return math.abs(point[0]) <= math.pi ? point[0] : math.sign(point[0]) * ((math.abs(point[0]) + math.pi) % math.tau - math.pi);
-}
-
-function polygonContains(polygon, point) {
-  var lambda = longitude(point),
-      phi = point[1],
-      sinPhi = math.sin(phi),
-      normal = [math.sin(lambda), -math.cos(lambda), 0],
-      angle = 0,
-      winding = 0;
-
-  var sum = new fsum.Adder();
-
-  if (sinPhi === 1) phi = math.halfPi + math.epsilon;
-  else if (sinPhi === -1) phi = -math.halfPi - math.epsilon;
-
-  for (var i = 0, n = polygon.length; i < n; ++i) {
-    if (!(m = (ring = polygon[i]).length)) continue;
-    var ring,
-        m,
-        point0 = ring[m - 1],
-        lambda0 = longitude(point0),
-        phi0 = point0[1] / 2 + math.quarterPi,
-        sinPhi0 = math.sin(phi0),
-        cosPhi0 = math.cos(phi0);
-
-    for (var j = 0; j < m; ++j, lambda0 = lambda1, sinPhi0 = sinPhi1, cosPhi0 = cosPhi1, point0 = point1) {
-      var point1 = ring[j],
-          lambda1 = longitude(point1),
-          phi1 = point1[1] / 2 + math.quarterPi,
-          sinPhi1 = math.sin(phi1),
-          cosPhi1 = math.cos(phi1),
-          delta = lambda1 - lambda0,
-          sign = delta >= 0 ? 1 : -1,
-          absDelta = sign * delta,
-          antimeridian = absDelta > math.pi,
-          k = sinPhi0 * sinPhi1;
-
-      sum.add(math.atan2(k * sign * math.sin(absDelta), cosPhi0 * cosPhi1 + k * math.cos(absDelta)));
-      angle += antimeridian ? delta + sign * math.tau : delta;
-
-      // Are the longitudes either side of the point’s meridian (lambda),
-      // and are the latitudes smaller than the parallel (phi)?
-      if (antimeridian ^ lambda0 >= lambda ^ lambda1 >= lambda) {
-        var arc = cartesian.cartesianCross(cartesian.cartesian(point0), cartesian.cartesian(point1));
-        cartesian.cartesianNormalizeInPlace(arc);
-        var intersection = cartesian.cartesianCross(normal, arc);
-        cartesian.cartesianNormalizeInPlace(intersection);
-        var phiArc = (antimeridian ^ delta >= 0 ? -1 : 1) * math.asin(intersection[2]);
-        if (phi > phiArc || phi === phiArc && (arc[0] || arc[1])) {
-          winding += antimeridian ^ delta >= 0 ? 1 : -1;
-        }
-      }
-    }
-  }
-
-  // First, determine whether the South pole is inside or outside:
-  //
-  // It is inside if:
-  // * the polygon winds around it in a clockwise direction.
-  // * the polygon does not (cumulatively) wind around it, but has a negative
-  //   (counter-clockwise) area.
-  //
-  // Second, count the (signed) number of times a segment crosses a lambda
-  // from the point to the South pole.  If it is zero, then the point is the
-  // same side as the South pole.
-
-  return (angle < -1e-6 || angle < math.epsilon && sum < -1e-12) ^ (winding & 1);
-}
-
-exports.default = polygonContains;

package/dist/cjs/bundled_modules/d3-geo/src/projection/albers.js

@@ -1,16 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var conicEqualArea = require('./conicEqualArea.js');
-
-function geoAlbers() {
-  return conicEqualArea.default()
-      .parallels([29.5, 45.5])
-      .scale(1070)
-      .translate([480, 250])
-      .rotate([96, 0])
-      .center([-0.6, 38.7]);
-}
-
-exports.default = geoAlbers;

package/dist/cjs/bundled_modules/d3-geo/src/projection/albersUsa.js

@@ -1,117 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var math = require('../math.js');
-var albers = require('./albers.js');
-var conicEqualArea = require('./conicEqualArea.js');
-var fit = require('./fit.js');
-
-// The projections must have mutually exclusive clip regions on the sphere,
-// as this will avoid emitting interleaving lines and polygons.
-function multiplex(streams) {
-  var n = streams.length;
-  return {
-    point: function(x, y) { var i = -1; while (++i < n) streams[i].point(x, y); },
-    sphere: function() { var i = -1; while (++i < n) streams[i].sphere(); },
-    lineStart: function() { var i = -1; while (++i < n) streams[i].lineStart(); },
-    lineEnd: function() { var i = -1; while (++i < n) streams[i].lineEnd(); },
-    polygonStart: function() { var i = -1; while (++i < n) streams[i].polygonStart(); },
-    polygonEnd: function() { var i = -1; while (++i < n) streams[i].polygonEnd(); }
-  };
-}
-
-// A composite projection for the United States, configured by default for
-// 960×500. The projection also works quite well at 960×600 if you change the
-// scale to 1285 and adjust the translate accordingly. The set of standard
-// parallels for each region comes from USGS, which is published here:
-// http://egsc.usgs.gov/isb/pubs/MapProjections/projections.html#albers
-function geoAlbersUsa() {
-  var cache,
-      cacheStream,
-      lower48 = albers.default(), lower48Point,
-      alaska = conicEqualArea.default().rotate([154, 0]).center([-2, 58.5]).parallels([55, 65]), alaskaPoint, // EPSG:3338
-      hawaii = conicEqualArea.default().rotate([157, 0]).center([-3, 19.9]).parallels([8, 18]), hawaiiPoint, // ESRI:102007
-      point, pointStream = {point: function(x, y) { point = [x, y]; }};
-
-  function albersUsa(coordinates) {
-    var x = coordinates[0], y = coordinates[1];
-    return point = null,
-        (lower48Point.point(x, y), point)
-        || (alaskaPoint.point(x, y), point)
-        || (hawaiiPoint.point(x, y), point);
-  }
-
-  albersUsa.invert = function(coordinates) {
-    var k = lower48.scale(),
-        t = lower48.translate(),
-        x = (coordinates[0] - t[0]) / k,
-        y = (coordinates[1] - t[1]) / k;
-    return (y >= 0.120 && y < 0.234 && x >= -0.425 && x < -0.214 ? alaska
-        : y >= 0.166 && y < 0.234 && x >= -0.214 && x < -0.115 ? hawaii
-        : lower48).invert(coordinates);
-  };
-
-  albersUsa.stream = function(stream) {
-    return cache && cacheStream === stream ? cache : cache = multiplex([lower48.stream(cacheStream = stream), alaska.stream(stream), hawaii.stream(stream)]);
-  };
-
-  albersUsa.precision = function(_) {
-    if (!arguments.length) return lower48.precision();
-    lower48.precision(_), alaska.precision(_), hawaii.precision(_);
-    return reset();
-  };
-
-  albersUsa.scale = function(_) {
-    if (!arguments.length) return lower48.scale();
-    lower48.scale(_), alaska.scale(_ * 0.35), hawaii.scale(_);
-    return albersUsa.translate(lower48.translate());
-  };
-
-  albersUsa.translate = function(_) {
-    if (!arguments.length) return lower48.translate();
-    var k = lower48.scale(), x = +_[0], y = +_[1];
-
-    lower48Point = lower48
-        .translate(_)
-        .clipExtent([[x - 0.455 * k, y - 0.238 * k], [x + 0.455 * k, y + 0.238 * k]])
-        .stream(pointStream);
-
-    alaskaPoint = alaska
-        .translate([x - 0.307 * k, y + 0.201 * k])
-        .clipExtent([[x - 0.425 * k + math.epsilon, y + 0.120 * k + math.epsilon], [x - 0.214 * k - math.epsilon, y + 0.234 * k - math.epsilon]])
-        .stream(pointStream);
-
-    hawaiiPoint = hawaii
-        .translate([x - 0.205 * k, y + 0.212 * k])
-        .clipExtent([[x - 0.214 * k + math.epsilon, y + 0.166 * k + math.epsilon], [x - 0.115 * k - math.epsilon, y + 0.234 * k - math.epsilon]])
-        .stream(pointStream);
-
-    return reset();
-  };
-
-  albersUsa.fitExtent = function(extent, object) {
-    return fit.fitExtent(albersUsa, extent, object);
-  };
-
-  albersUsa.fitSize = function(size, object) {
-    return fit.fitSize(albersUsa, size, object);
-  };
-
-  albersUsa.fitWidth = function(width, object) {
-    return fit.fitWidth(albersUsa, width, object);
-  };
-
-  albersUsa.fitHeight = function(height, object) {
-    return fit.fitHeight(albersUsa, height, object);
-  };
-
-  function reset() {
-    cache = cacheStream = null;
-    return albersUsa;
-  }
-
-  return albersUsa.scale(1070);
-}
-
-exports.default = geoAlbersUsa;

package/dist/cjs/bundled_modules/d3-geo/src/projection/azimuthal.js

@@ -1,32 +0,0 @@
-'use strict';
-
-var math = require('../math.js');
-
-function azimuthalRaw(scale) {
-  return function(x, y) {
-    var cx = math.cos(x),
-        cy = math.cos(y),
-        k = scale(cx * cy);
-        if (k === Infinity) return [2, 0];
-    return [
-      k * cy * math.sin(x),
-      k * math.sin(y)
-    ];
-  }
-}
-
-function azimuthalInvert(angle) {
-  return function(x, y) {
-    var z = math.sqrt(x * x + y * y),
-        c = angle(z),
-        sc = math.sin(c),
-        cc = math.cos(c);
-    return [
-      math.atan2(x * sc, z * cc),
-      math.asin(z && y * sc / z)
-    ];
-  }
-}
-
-exports.azimuthalInvert = azimuthalInvert;
-exports.azimuthalRaw = azimuthalRaw;

package/dist/cjs/bundled_modules/d3-geo/src/projection/azimuthalEqualArea.js

@@ -1,24 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var math = require('../math.js');
-var azimuthal = require('./azimuthal.js');
-var index = require('./index.js');
-
-var azimuthalEqualAreaRaw = azimuthal.azimuthalRaw(function(cxcy) {
-  return math.sqrt(2 / (1 + cxcy));
-});
-
-azimuthalEqualAreaRaw.invert = azimuthal.azimuthalInvert(function(z) {
-  return 2 * math.asin(z / 2);
-});
-
-function geoAzimuthalEqualArea() {
-  return index.default(azimuthalEqualAreaRaw)
-      .scale(124.75)
-      .clipAngle(180 - 1e-3);
-}
-
-exports.azimuthalEqualAreaRaw = azimuthalEqualAreaRaw;
-exports.default = geoAzimuthalEqualArea;

package/dist/cjs/bundled_modules/d3-geo/src/projection/azimuthalEquidistant.js

@@ -1,24 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var math = require('../math.js');
-var azimuthal = require('./azimuthal.js');
-var index = require('./index.js');
-
-var azimuthalEquidistantRaw = azimuthal.azimuthalRaw(function(c) {
-  return (c = math.acos(c)) && c / math.sin(c);
-});
-
-azimuthalEquidistantRaw.invert = azimuthal.azimuthalInvert(function(z) {
-  return z;
-});
-
-function geoAzimuthalEquidistant() {
-  return index.default(azimuthalEquidistantRaw)
-      .scale(79.4188)
-      .clipAngle(180 - 1e-3);
-}
-
-exports.azimuthalEquidistantRaw = azimuthalEquidistantRaw;
-exports.default = geoAzimuthalEquidistant;