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

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

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var math = require('../math.js');
+var azimuthal = require('./azimuthal.js');
+var index = require('./index.js');
+
+function orthographicRaw(x, y) {
+  return [math.cos(y) * math.sin(x), math.sin(y)];
+}
+
+orthographicRaw.invert = azimuthal.azimuthalInvert(math.asin);
+
+function geoOrthographic() {
+  return index.default(orthographicRaw)
+      .scale(249.5)
+      .clipAngle(90 + math.epsilon);
+}
+
+exports.default = geoOrthographic;
+exports.orthographicRaw = orthographicRaw;

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

@@ -0,0 +1,108 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var cartesian = require('../cartesian.js');
+var math = require('../math.js');
+var transform = require('../transform.js');
+
+var maxDepth = 16, // maximum depth of subdivision
+    cosMinDistance = math.cos(30 * math.radians); // cos(minimum angular distance)
+
+function resample(project, delta2) {
+  return +delta2 ? resample$1(project, delta2) : resampleNone(project);
+}
+
+function resampleNone(project) {
+  return transform.transformer({
+    point: function(x, y) {
+      x = project(x, y);
+      this.stream.point(x[0], x[1]);
+    }
+  });
+}
+
+function resample$1(project, delta2) {
+
+  function resampleLineTo(x0, y0, lambda0, a0, b0, c0, x1, y1, lambda1, a1, b1, c1, depth, stream) {
+    var dx = x1 - x0,
+        dy = y1 - y0,
+        d2 = dx * dx + dy * dy;
+    if (d2 > 4 * delta2 && depth--) {
+      var a = a0 + a1,
+          b = b0 + b1,
+          c = c0 + c1,
+          m = math.sqrt(a * a + b * b + c * c),
+          phi2 = math.asin(c /= m),
+          lambda2 = math.abs(math.abs(c) - 1) < math.epsilon || math.abs(lambda0 - lambda1) < math.epsilon ? (lambda0 + lambda1) / 2 : math.atan2(b, a),
+          p = project(lambda2, phi2),
+          x2 = p[0],
+          y2 = p[1],
+          dx2 = x2 - x0,
+          dy2 = y2 - y0,
+          dz = dy * dx2 - dx * dy2;
+      if (dz * dz / d2 > delta2 // perpendicular projected distance
+          || math.abs((dx * dx2 + dy * dy2) / d2 - 0.5) > 0.3 // midpoint close to an end
+          || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) { // angular distance
+        resampleLineTo(x0, y0, lambda0, a0, b0, c0, x2, y2, lambda2, a /= m, b /= m, c, depth, stream);
+        stream.point(x2, y2);
+        resampleLineTo(x2, y2, lambda2, a, b, c, x1, y1, lambda1, a1, b1, c1, depth, stream);
+      }
+    }
+  }
+  return function(stream) {
+    var lambda00, x00, y00, a00, b00, c00, // first point
+        lambda0, x0, y0, a0, b0, c0; // previous point
+
+    var resampleStream = {
+      point: point,
+      lineStart: lineStart,
+      lineEnd: lineEnd,
+      polygonStart: function() { stream.polygonStart(); resampleStream.lineStart = ringStart; },
+      polygonEnd: function() { stream.polygonEnd(); resampleStream.lineStart = lineStart; }
+    };
+
+    function point(x, y) {
+      x = project(x, y);
+      stream.point(x[0], x[1]);
+    }
+
+    function lineStart() {
+      x0 = NaN;
+      resampleStream.point = linePoint;
+      stream.lineStart();
+    }
+
+    function linePoint(lambda, phi) {
+      var c = cartesian.cartesian([lambda, phi]), p = project(lambda, phi);
+      resampleLineTo(x0, y0, lambda0, a0, b0, c0, x0 = p[0], y0 = p[1], lambda0 = lambda, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream);
+      stream.point(x0, y0);
+    }
+
+    function lineEnd() {
+      resampleStream.point = point;
+      stream.lineEnd();
+    }
+
+    function ringStart() {
+      lineStart();
+      resampleStream.point = ringPoint;
+      resampleStream.lineEnd = ringEnd;
+    }
+
+    function ringPoint(lambda, phi) {
+      linePoint(lambda00 = lambda, phi), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0;
+      resampleStream.point = linePoint;
+    }
+
+    function ringEnd() {
+      resampleLineTo(x0, y0, lambda0, a0, b0, c0, x00, y00, lambda00, a00, b00, c00, maxDepth, stream);
+      resampleStream.lineEnd = lineEnd;
+      lineEnd();
+    }
+
+    return resampleStream;
+  };
+}
+
+exports.default = resample;

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

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var math = require('../math.js');
+var azimuthal = require('./azimuthal.js');
+var index = require('./index.js');
+
+function stereographicRaw(x, y) {
+  var cy = math.cos(y), k = 1 + math.cos(x) * cy;
+  return [cy * math.sin(x) / k, math.sin(y) / k];
+}
+
+stereographicRaw.invert = azimuthal.azimuthalInvert(function(z) {
+  return 2 * math.atan(z);
+});
+
+function geoStereographic() {
+  return index.default(stereographicRaw)
+      .scale(250)
+      .clipAngle(142);
+}
+
+exports.default = geoStereographic;
+exports.stereographicRaw = stereographicRaw;

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

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var math = require('../math.js');
+var mercator = require('./mercator.js');
+
+function transverseMercatorRaw(lambda, phi) {
+  return [math.log(math.tan((math.halfPi + phi) / 2)), -lambda];
+}
+
+transverseMercatorRaw.invert = function(x, y) {
+  return [-y, 2 * math.atan(math.exp(x)) - math.halfPi];
+};
+
+function geoTransverseMercator() {
+  var m = mercator.mercatorProjection(transverseMercatorRaw),
+      center = m.center,
+      rotate = m.rotate;
+
+  m.center = function(_) {
+    return arguments.length ? center([-_[1], _[0]]) : (_ = center(), [_[1], -_[0]]);
+  };
+
+  m.rotate = function(_) {
+    return arguments.length ? rotate([_[0], _[1], _.length > 2 ? _[2] + 90 : 90]) : (_ = rotate(), [_[0], _[1], _[2] - 90]);
+  };
+
+  return rotate([0, 0, 90])
+      .scale(159.155);
+}
+
+exports.default = geoTransverseMercator;
+exports.transverseMercatorRaw = transverseMercatorRaw;

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

@@ -0,0 +1,86 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var compose = require('./compose.js');
+var math = require('./math.js');
+
+function rotationIdentity(lambda, phi) {
+  if (math.abs(lambda) > math.pi) lambda -= Math.round(lambda / math.tau) * math.tau;
+  return [lambda, phi];
+}
+
+rotationIdentity.invert = rotationIdentity;
+
+function rotateRadians(deltaLambda, deltaPhi, deltaGamma) {
+  return (deltaLambda %= math.tau) ? (deltaPhi || deltaGamma ? compose.default(rotationLambda(deltaLambda), rotationPhiGamma(deltaPhi, deltaGamma))
+    : rotationLambda(deltaLambda))
+    : (deltaPhi || deltaGamma ? rotationPhiGamma(deltaPhi, deltaGamma)
+    : rotationIdentity);
+}
+
+function forwardRotationLambda(deltaLambda) {
+  return function(lambda, phi) {
+    lambda += deltaLambda;
+    if (math.abs(lambda) > math.pi) lambda -= Math.round(lambda / math.tau) * math.tau;
+    return [lambda, phi];
+  };
+}
+
+function rotationLambda(deltaLambda) {
+  var rotation = forwardRotationLambda(deltaLambda);
+  rotation.invert = forwardRotationLambda(-deltaLambda);
+  return rotation;
+}
+
+function rotationPhiGamma(deltaPhi, deltaGamma) {
+  var cosDeltaPhi = math.cos(deltaPhi),
+      sinDeltaPhi = math.sin(deltaPhi),
+      cosDeltaGamma = math.cos(deltaGamma),
+      sinDeltaGamma = math.sin(deltaGamma);
+
+  function rotation(lambda, phi) {
+    var cosPhi = math.cos(phi),
+        x = math.cos(lambda) * cosPhi,
+        y = math.sin(lambda) * cosPhi,
+        z = math.sin(phi),
+        k = z * cosDeltaPhi + x * sinDeltaPhi;
+    return [
+      math.atan2(y * cosDeltaGamma - k * sinDeltaGamma, x * cosDeltaPhi - z * sinDeltaPhi),
+      math.asin(k * cosDeltaGamma + y * sinDeltaGamma)
+    ];
+  }
+
+  rotation.invert = function(lambda, phi) {
+    var cosPhi = math.cos(phi),
+        x = math.cos(lambda) * cosPhi,
+        y = math.sin(lambda) * cosPhi,
+        z = math.sin(phi),
+        k = z * cosDeltaGamma - y * sinDeltaGamma;
+    return [
+      math.atan2(y * cosDeltaGamma + z * sinDeltaGamma, x * cosDeltaPhi + k * sinDeltaPhi),
+      math.asin(k * cosDeltaPhi - x * sinDeltaPhi)
+    ];
+  };
+
+  return rotation;
+}
+
+function rotation(rotate) {
+  rotate = rotateRadians(rotate[0] * math.radians, rotate[1] * math.radians, rotate.length > 2 ? rotate[2] * math.radians : 0);
+
+  function forward(coordinates) {
+    coordinates = rotate(coordinates[0] * math.radians, coordinates[1] * math.radians);
+    return coordinates[0] *= math.degrees, coordinates[1] *= math.degrees, coordinates;
+  }
+
+  forward.invert = function(coordinates) {
+    coordinates = rotate.invert(coordinates[0] * math.radians, coordinates[1] * math.radians);
+    return coordinates[0] *= math.degrees, coordinates[1] *= math.degrees, coordinates;
+  };
+
+  return forward;
+}
+
+exports.default = rotation;
+exports.rotateRadians = rotateRadians;

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

@@ -0,0 +1,75 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function streamGeometry(geometry, stream) {
+  if (geometry && streamGeometryType.hasOwnProperty(geometry.type)) {
+    streamGeometryType[geometry.type](geometry, stream);
+  }
+}
+
+var streamObjectType = {
+  Feature: function(object, stream) {
+    streamGeometry(object.geometry, stream);
+  },
+  FeatureCollection: function(object, stream) {
+    var features = object.features, i = -1, n = features.length;
+    while (++i < n) streamGeometry(features[i].geometry, stream);
+  }
+};
+
+var streamGeometryType = {
+  Sphere: function(object, stream) {
+    stream.sphere();
+  },
+  Point: function(object, stream) {
+    object = object.coordinates;
+    stream.point(object[0], object[1], object[2]);
+  },
+  MultiPoint: function(object, stream) {
+    var coordinates = object.coordinates, i = -1, n = coordinates.length;
+    while (++i < n) object = coordinates[i], stream.point(object[0], object[1], object[2]);
+  },
+  LineString: function(object, stream) {
+    streamLine(object.coordinates, stream, 0);
+  },
+  MultiLineString: function(object, stream) {
+    var coordinates = object.coordinates, i = -1, n = coordinates.length;
+    while (++i < n) streamLine(coordinates[i], stream, 0);
+  },
+  Polygon: function(object, stream) {
+    streamPolygon(object.coordinates, stream);
+  },
+  MultiPolygon: function(object, stream) {
+    var coordinates = object.coordinates, i = -1, n = coordinates.length;
+    while (++i < n) streamPolygon(coordinates[i], stream);
+  },
+  GeometryCollection: function(object, stream) {
+    var geometries = object.geometries, i = -1, n = geometries.length;
+    while (++i < n) streamGeometry(geometries[i], stream);
+  }
+};
+
+function streamLine(coordinates, stream, closed) {
+  var i = -1, n = coordinates.length - closed, coordinate;
+  stream.lineStart();
+  while (++i < n) coordinate = coordinates[i], stream.point(coordinate[0], coordinate[1], coordinate[2]);
+  stream.lineEnd();
+}
+
+function streamPolygon(coordinates, stream) {
+  var i = -1, n = coordinates.length;
+  stream.polygonStart();
+  while (++i < n) streamLine(coordinates[i], stream, 1);
+  stream.polygonEnd();
+}
+
+function geoStream(object, stream) {
+  if (object && streamObjectType.hasOwnProperty(object.type)) {
+    streamObjectType[object.type](object, stream);
+  } else {
+    streamGeometry(object, stream);
+  }
+}
+
+exports.default = geoStream;

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

@@ -0,0 +1,24 @@
+'use strict';
+
+function transformer(methods) {
+  return function(stream) {
+    var s = new TransformStream;
+    for (var key in methods) s[key] = methods[key];
+    s.stream = stream;
+    return s;
+  };
+}
+
+function TransformStream() {}
+
+TransformStream.prototype = {
+  constructor: TransformStream,
+  point: function(x, y) { this.stream.point(x, y); },
+  sphere: function() { this.stream.sphere(); },
+  lineStart: function() { this.stream.lineStart(); },
+  lineEnd: function() { this.stream.lineEnd(); },
+  polygonStart: function() { this.stream.polygonStart(); },
+  polygonEnd: function() { this.stream.polygonEnd(); }
+};
+
+exports.transformer = transformer;

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

@@ -0,0 +1,28 @@
+'use strict';
+
+var abs = Math.abs;
+var cos = Math.cos;
+var sin = Math.sin;
+
+var epsilon = 1e-6;
+var pi = Math.PI;
+var halfPi = pi / 2;
+var sqrt2 = sqrt(2);
+
+function asin(x) {
+  return x > 1 ? halfPi : x < -1 ? -halfPi : Math.asin(x);
+}
+
+function sqrt(x) {
+  return x > 0 ? Math.sqrt(x) : 0;
+}
+
+exports.abs = abs;
+exports.asin = asin;
+exports.cos = cos;
+exports.epsilon = epsilon;
+exports.halfPi = halfPi;
+exports.pi = pi;
+exports.sin = sin;
+exports.sqrt = sqrt;
+exports.sqrt2 = sqrt2;

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

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var math = require('./math.js');
+var index = require('../../d3-geo/src/projection/index.js');
+
+function mollweideBromleyTheta(cp, phi) {
+  var cpsinPhi = cp * math.sin(phi), i = 30, delta;
+  do phi -= delta = (phi + math.sin(phi) - cpsinPhi) / (1 + math.cos(phi));
+  while (math.abs(delta) > math.epsilon && --i > 0);
+  return phi / 2;
+}
+
+function mollweideBromleyRaw(cx, cy, cp) {
+
+  function forward(lambda, phi) {
+    return [cx * lambda * math.cos(phi = mollweideBromleyTheta(cp, phi)), cy * math.sin(phi)];
+  }
+
+  forward.invert = function(x, y) {
+    return y = math.asin(y / cy), [x / (cx * math.cos(y)), math.asin((2 * y + math.sin(2 * y)) / cp)];
+  };
+
+  return forward;
+}
+
+var mollweideRaw = mollweideBromleyRaw(math.sqrt2 / math.halfPi, math.sqrt2, math.pi);
+
+function geoMollweide() {
+  return index.default(mollweideRaw)
+      .scale(169.529);
+}
+
+exports.default = geoMollweide;
+exports.mollweideBromleyRaw = mollweideBromleyRaw;
+exports.mollweideBromleyTheta = mollweideBromleyTheta;
+exports.mollweideRaw = mollweideRaw;

package/dist/cjs/bundled_modules/d3-hierarchy/src/accessors.js

@@ -0,0 +1,13 @@
+'use strict';
+
+function optional(f) {
+  return f == null ? null : required(f);
+}
+
+function required(f) {
+  if (typeof f !== "function") throw new Error;
+  return f;
+}
+
+exports.optional = optional;
+exports.required = required;

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

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function array(x) {
+  return typeof x === "object" && "length" in x
+    ? x // Array, TypedArray, NodeList, array-like
+    : Array.from(x); // Map, Set, iterable, string, or anything else
+}
+
+function shuffle(array, random) {
+  let m = array.length,
+      t,
+      i;
+
+  while (m) {
+    i = random() * m-- | 0;
+    t = array[m];
+    array[m] = array[i];
+    array[i] = t;
+  }
+
+  return array;
+}
+
+exports.default = array;
+exports.shuffle = shuffle;

package/dist/cjs/bundled_modules/d3-hierarchy/src/cluster.js

@@ -0,0 +1,90 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function defaultSeparation(a, b) {
+  return a.parent === b.parent ? 1 : 2;
+}
+
+function meanX(children) {
+  return children.reduce(meanXReduce, 0) / children.length;
+}
+
+function meanXReduce(x, c) {
+  return x + c.x;
+}
+
+function maxY(children) {
+  return 1 + children.reduce(maxYReduce, 0);
+}
+
+function maxYReduce(y, c) {
+  return Math.max(y, c.y);
+}
+
+function leafLeft(node) {
+  var children;
+  while (children = node.children) node = children[0];
+  return node;
+}
+
+function leafRight(node) {
+  var children;
+  while (children = node.children) node = children[children.length - 1];
+  return node;
+}
+
+function cluster() {
+  var separation = defaultSeparation,
+      dx = 1,
+      dy = 1,
+      nodeSize = false;
+
+  function cluster(root) {
+    var previousNode,
+        x = 0;
+
+    // First walk, computing the initial x & y values.
+    root.eachAfter(function(node) {
+      var children = node.children;
+      if (children) {
+        node.x = meanX(children);
+        node.y = maxY(children);
+      } else {
+        node.x = previousNode ? x += separation(node, previousNode) : 0;
+        node.y = 0;
+        previousNode = node;
+      }
+    });
+
+    var left = leafLeft(root),
+        right = leafRight(root),
+        x0 = left.x - separation(left, right) / 2,
+        x1 = right.x + separation(right, left) / 2;
+
+    // Second walk, normalizing x & y to the desired size.
+    return root.eachAfter(nodeSize ? function(node) {
+      node.x = (node.x - root.x) * dx;
+      node.y = (root.y - node.y) * dy;
+    } : function(node) {
+      node.x = (node.x - x0) / (x1 - x0) * dx;
+      node.y = (1 - (root.y ? node.y / root.y : 1)) * dy;
+    });
+  }
+
+  cluster.separation = function(x) {
+    return arguments.length ? (separation = x, cluster) : separation;
+  };
+
+  cluster.size = function(x) {
+    return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? null : [dx, dy]);
+  };
+
+  cluster.nodeSize = function(x) {
+    return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? [dx, dy] : null);
+  };
+
+  return cluster;
+}
+
+exports.default = cluster;

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

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function constantZero() {
+  return 0;
+}
+
+function constant(x) {
+  return function() {
+    return x;
+  };
+}
+
+exports.constantZero = constantZero;
+exports.default = constant;

package/dist/cjs/bundled_modules/d3-hierarchy/src/hierarchy/ancestors.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function node_ancestors() {
+  var node = this, nodes = [node];
+  while (node = node.parent) {
+    nodes.push(node);
+  }
+  return nodes;
+}
+
+exports.default = node_ancestors;

package/dist/cjs/bundled_modules/d3-hierarchy/src/hierarchy/count.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function count(node) {
+  var sum = 0,
+      children = node.children,
+      i = children && children.length;
+  if (!i) sum = 1;
+  else while (--i >= 0) sum += children[i].value;
+  node.value = sum;
+}
+
+function node_count() {
+  return this.eachAfter(count);
+}
+
+exports.default = node_count;

package/dist/cjs/bundled_modules/d3-hierarchy/src/hierarchy/descendants.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function node_descendants() {
+  return Array.from(this);
+}
+
+exports.default = node_descendants;

package/dist/cjs/bundled_modules/d3-hierarchy/src/hierarchy/each.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function node_each(callback, that) {
+  let index = -1;
+  for (const node of this) {
+    callback.call(that, node, ++index, this);
+  }
+  return this;
+}
+
+exports.default = node_each;

package/dist/cjs/bundled_modules/d3-hierarchy/src/hierarchy/eachAfter.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function node_eachAfter(callback, that) {
+  var node = this, nodes = [node], next = [], children, i, n, index = -1;
+  while (node = nodes.pop()) {
+    next.push(node);
+    if (children = node.children) {
+      for (i = 0, n = children.length; i < n; ++i) {
+        nodes.push(children[i]);
+      }
+    }
+  }
+  while (node = next.pop()) {
+    callback.call(that, node, ++index, this);
+  }
+  return this;
+}
+
+exports.default = node_eachAfter;