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

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

@@ -0,0 +1,104 @@
+'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

@@ -0,0 +1,51 @@
+'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

@@ -0,0 +1,82 @@
+'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

@@ -0,0 +1,49 @@
+'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

@@ -0,0 +1,92 @@
+'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

@@ -0,0 +1,11 @@
+'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

@@ -0,0 +1,80 @@
+'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

@@ -0,0 +1,16 @@
+'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

@@ -0,0 +1,117 @@
+'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

@@ -0,0 +1,32 @@
+'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

@@ -0,0 +1,24 @@
+'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

@@ -0,0 +1,24 @@
+'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;