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

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;

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

@@ -0,0 +1,19 @@
+'use strict';
+
+var math = require('../math.js');
+var index = require('./index.js');
+
+function conicProjection(projectAt) {
+  var phi0 = 0,
+      phi1 = math.pi / 3,
+      m = index.projectionMutator(projectAt),
+      p = m(phi0, phi1);
+
+  p.parallels = function(_) {
+    return arguments.length ? m(phi0 = _[0] * math.radians, phi1 = _[1] * math.radians) : [phi0 * math.degrees, phi1 * math.degrees];
+  };
+
+  return p;
+}
+
+exports.conicProjection = conicProjection;

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

@@ -0,0 +1,45 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var math = require('../math.js');
+var conic = require('./conic.js');
+var mercator = require('./mercator.js');
+
+function tany(y) {
+  return math.tan((math.halfPi + y) / 2);
+}
+
+function conicConformalRaw(y0, y1) {
+  var cy0 = math.cos(y0),
+      n = y0 === y1 ? math.sin(y0) : math.log(cy0 / math.cos(y1)) / math.log(tany(y1) / tany(y0)),
+      f = cy0 * math.pow(tany(y0), n) / n;
+
+  if (!n) return mercator.mercatorRaw;
+
+  function project(x, y) {
+    if (f > 0) { if (y < -math.halfPi + math.epsilon) y = -math.halfPi + math.epsilon; }
+    else { if (y > math.halfPi - math.epsilon) y = math.halfPi - math.epsilon; }
+    var r = f / math.pow(tany(y), n);
+    return [r * math.sin(n * x), f - r * math.cos(n * x)];
+  }
+
+  project.invert = function(x, y) {
+    var fy = f - y, r = math.sign(n) * math.sqrt(x * x + fy * fy),
+      l = math.atan2(x, math.abs(fy)) * math.sign(fy);
+    if (fy * n < 0)
+      l -= math.pi * math.sign(x) * math.sign(fy);
+    return [l / n, 2 * math.atan(math.pow(f / r, 1 / n)) - math.halfPi];
+  };
+
+  return project;
+}
+
+function geoConicConformal() {
+  return conic.conicProjection(conicConformalRaw)
+      .scale(109.5)
+      .parallels([30, 30]);
+}
+
+exports.conicConformalRaw = conicConformalRaw;
+exports.default = geoConicConformal;

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

@@ -0,0 +1,40 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var math = require('../math.js');
+var conic = require('./conic.js');
+var cylindricalEqualArea = require('./cylindricalEqualArea.js');
+
+function conicEqualAreaRaw(y0, y1) {
+  var sy0 = math.sin(y0), n = (sy0 + math.sin(y1)) / 2;
+
+  // Are the parallels symmetrical around the Equator?
+  if (math.abs(n) < math.epsilon) return cylindricalEqualArea.cylindricalEqualAreaRaw(y0);
+
+  var c = 1 + sy0 * (2 * n - sy0), r0 = math.sqrt(c) / n;
+
+  function project(x, y) {
+    var r = math.sqrt(c - 2 * n * math.sin(y)) / n;
+    return [r * math.sin(x *= n), r0 - r * math.cos(x)];
+  }
+
+  project.invert = function(x, y) {
+    var r0y = r0 - y,
+        l = math.atan2(x, math.abs(r0y)) * math.sign(r0y);
+    if (r0y * n < 0)
+      l -= math.pi * math.sign(x) * math.sign(r0y);
+    return [l / n, math.asin((c - (x * x + r0y * r0y) * n * n) / (2 * n))];
+  };
+
+  return project;
+}
+
+function geoConicEqualArea() {
+  return conic.conicProjection(conicEqualAreaRaw)
+      .scale(155.424)
+      .center([0, 33.6442]);
+}
+
+exports.conicEqualAreaRaw = conicEqualAreaRaw;
+exports.default = geoConicEqualArea;

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

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var math = require('../math.js');
+var conic = require('./conic.js');
+var equirectangular = require('./equirectangular.js');
+
+function conicEquidistantRaw(y0, y1) {
+  var cy0 = math.cos(y0),
+      n = y0 === y1 ? math.sin(y0) : (cy0 - math.cos(y1)) / (y1 - y0),
+      g = cy0 / n + y0;
+
+  if (math.abs(n) < math.epsilon) return equirectangular.equirectangularRaw;
+
+  function project(x, y) {
+    var gy = g - y, nx = n * x;
+    return [gy * math.sin(nx), g - gy * math.cos(nx)];
+  }
+
+  project.invert = function(x, y) {
+    var gy = g - y,
+        l = math.atan2(x, math.abs(gy)) * math.sign(gy);
+    if (gy * n < 0)
+      l -= math.pi * math.sign(x) * math.sign(gy);
+    return [l / n, g - math.sign(n) * math.sqrt(x * x + gy * gy)];
+  };
+
+  return project;
+}
+
+function geoConicEquidistant() {
+  return conic.conicProjection(conicEquidistantRaw)
+      .scale(131.154)
+      .center([0, 13.9389]);
+}
+
+exports.conicEquidistantRaw = conicEquidistantRaw;
+exports.default = geoConicEquidistant;

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

@@ -0,0 +1,19 @@
+'use strict';
+
+var math = require('../math.js');
+
+function cylindricalEqualAreaRaw(phi0) {
+  var cosPhi0 = math.cos(phi0);
+
+  function forward(lambda, phi) {
+    return [lambda * cosPhi0, math.sin(phi) / cosPhi0];
+  }
+
+  forward.invert = function(x, y) {
+    return [x / cosPhi0, math.asin(y * cosPhi0)];
+  };
+
+  return forward;
+}
+
+exports.cylindricalEqualAreaRaw = cylindricalEqualAreaRaw;

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

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('./index.js');
+var math = require('../math.js');
+
+var A1 = 1.340264,
+    A2 = -0.081106,
+    A3 = 0.000893,
+    A4 = 0.003796,
+    M = math.sqrt(3) / 2,
+    iterations = 12;
+
+function equalEarthRaw(lambda, phi) {
+  var l = math.asin(M * math.sin(phi)), l2 = l * l, l6 = l2 * l2 * l2;
+  return [
+    lambda * math.cos(l) / (M * (A1 + 3 * A2 * l2 + l6 * (7 * A3 + 9 * A4 * l2))),
+    l * (A1 + A2 * l2 + l6 * (A3 + A4 * l2))
+  ];
+}
+
+equalEarthRaw.invert = function(x, y) {
+  var l = y, l2 = l * l, l6 = l2 * l2 * l2;
+  for (var i = 0, delta, fy, fpy; i < iterations; ++i) {
+    fy = l * (A1 + A2 * l2 + l6 * (A3 + A4 * l2)) - y;
+    fpy = A1 + 3 * A2 * l2 + l6 * (7 * A3 + 9 * A4 * l2);
+    l -= delta = fy / fpy, l2 = l * l, l6 = l2 * l2 * l2;
+    if (math.abs(delta) < math.epsilon2) break;
+  }
+  return [
+    M * x * (A1 + 3 * A2 * l2 + l6 * (7 * A3 + 9 * A4 * l2)) / math.cos(l),
+    math.asin(math.sin(l) / M)
+  ];
+};
+
+function geoEqualEarth() {
+  return index.default(equalEarthRaw)
+      .scale(177.158);
+}
+
+exports.default = geoEqualEarth;
+exports.equalEarthRaw = equalEarthRaw;

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

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('./index.js');
+
+function equirectangularRaw(lambda, phi) {
+  return [lambda, phi];
+}
+
+equirectangularRaw.invert = equirectangularRaw;
+
+function geoEquirectangular() {
+  return index.default(equirectangularRaw)
+      .scale(152.63);
+}
+
+exports.default = geoEquirectangular;
+exports.equirectangularRaw = equirectangularRaw;

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

@@ -0,0 +1,54 @@
+'use strict';
+
+var stream = require('../stream.js');
+var bounds = require('../path/bounds.js');
+
+function fit(projection, fitBounds, object) {
+  var clip = projection.clipExtent && projection.clipExtent();
+  projection.scale(150).translate([0, 0]);
+  if (clip != null) projection.clipExtent(null);
+  stream.default(object, projection.stream(bounds.default));
+  fitBounds(bounds.default.result());
+  if (clip != null) projection.clipExtent(clip);
+  return projection;
+}
+
+function fitExtent(projection, extent, object) {
+  return fit(projection, function(b) {
+    var w = extent[1][0] - extent[0][0],
+        h = extent[1][1] - extent[0][1],
+        k = Math.min(w / (b[1][0] - b[0][0]), h / (b[1][1] - b[0][1])),
+        x = +extent[0][0] + (w - k * (b[1][0] + b[0][0])) / 2,
+        y = +extent[0][1] + (h - k * (b[1][1] + b[0][1])) / 2;
+    projection.scale(150 * k).translate([x, y]);
+  }, object);
+}
+
+function fitSize(projection, size, object) {
+  return fitExtent(projection, [[0, 0], size], object);
+}
+
+function fitWidth(projection, width, object) {
+  return fit(projection, function(b) {
+    var w = +width,
+        k = w / (b[1][0] - b[0][0]),
+        x = (w - k * (b[1][0] + b[0][0])) / 2,
+        y = -k * b[0][1];
+    projection.scale(150 * k).translate([x, y]);
+  }, object);
+}
+
+function fitHeight(projection, height, object) {
+  return fit(projection, function(b) {
+    var h = +height,
+        k = h / (b[1][1] - b[0][1]),
+        x = -k * b[0][0],
+        y = (h - k * (b[1][1] + b[0][1])) / 2;
+    projection.scale(150 * k).translate([x, y]);
+  }, object);
+}
+
+exports.fitExtent = fitExtent;
+exports.fitHeight = fitHeight;
+exports.fitSize = fitSize;
+exports.fitWidth = fitWidth;

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

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var math = require('../math.js');
+var azimuthal = require('./azimuthal.js');
+var index = require('./index.js');
+
+function gnomonicRaw(x, y) {
+  var cy = math.cos(y), k = math.cos(x) * cy;
+  return [cy * math.sin(x) / k, math.sin(y) / k];
+}
+
+gnomonicRaw.invert = azimuthal.azimuthalInvert(math.atan);
+
+function geoGnomonic() {
+  return index.default(gnomonicRaw)
+      .scale(144.049)
+      .clipAngle(60);
+}
+
+exports.default = geoGnomonic;
+exports.gnomonicRaw = gnomonicRaw;