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

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

@@ -1,43 +0,0 @@
-'use strict';
-
-var math = require('./math.js');
-
-function spherical(cartesian) {
-  return [math.atan2(cartesian[1], cartesian[0]), math.asin(cartesian[2])];
-}
-
-function cartesian(spherical) {
-  var lambda = spherical[0], phi = spherical[1], cosPhi = math.cos(phi);
-  return [cosPhi * math.cos(lambda), cosPhi * math.sin(lambda), math.sin(phi)];
-}
-
-function cartesianDot(a, b) {
-  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-}
-
-function cartesianCross(a, b) {
-  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
-}
-
-// TODO return a
-function cartesianAddInPlace(a, b) {
-  a[0] += b[0], a[1] += b[1], a[2] += b[2];
-}
-
-function cartesianScale(vector, k) {
-  return [vector[0] * k, vector[1] * k, vector[2] * k];
-}
-
-// TODO return d
-function cartesianNormalizeInPlace(d) {
-  var l = math.sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
-  d[0] /= l, d[1] /= l, d[2] /= l;
-}
-
-exports.cartesian = cartesian;
-exports.cartesianAddInPlace = cartesianAddInPlace;
-exports.cartesianCross = cartesianCross;
-exports.cartesianDot = cartesianDot;
-exports.cartesianNormalizeInPlace = cartesianNormalizeInPlace;
-exports.cartesianScale = cartesianScale;
-exports.spherical = spherical;

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

@@ -1,149 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var math = require('./math.js');
-var noop = require('./noop.js');
-var stream = require('./stream.js');
-var fsum = require('../../d3-array/src/fsum.js');
-
-var W0, W1,
-    X0, Y0, Z0,
-    X1, Y1, Z1,
-    X2, Y2, Z2,
-    lambda00, phi00, // first point
-    x0, y0, z0; // previous point
-
-var centroidStream = {
-  sphere: noop.default,
-  point: centroidPoint,
-  lineStart: centroidLineStart,
-  lineEnd: centroidLineEnd,
-  polygonStart: function() {
-    centroidStream.lineStart = centroidRingStart;
-    centroidStream.lineEnd = centroidRingEnd;
-  },
-  polygonEnd: function() {
-    centroidStream.lineStart = centroidLineStart;
-    centroidStream.lineEnd = centroidLineEnd;
-  }
-};
-
-// Arithmetic mean of Cartesian vectors.
-function centroidPoint(lambda, phi) {
-  lambda *= math.radians, phi *= math.radians;
-  var cosPhi = math.cos(phi);
-  centroidPointCartesian(cosPhi * math.cos(lambda), cosPhi * math.sin(lambda), math.sin(phi));
-}
-
-function centroidPointCartesian(x, y, z) {
-  ++W0;
-  X0 += (x - X0) / W0;
-  Y0 += (y - Y0) / W0;
-  Z0 += (z - Z0) / W0;
-}
-
-function centroidLineStart() {
-  centroidStream.point = centroidLinePointFirst;
-}
-
-function centroidLinePointFirst(lambda, phi) {
-  lambda *= math.radians, phi *= math.radians;
-  var cosPhi = math.cos(phi);
-  x0 = cosPhi * math.cos(lambda);
-  y0 = cosPhi * math.sin(lambda);
-  z0 = math.sin(phi);
-  centroidStream.point = centroidLinePoint;
-  centroidPointCartesian(x0, y0, z0);
-}
-
-function centroidLinePoint(lambda, phi) {
-  lambda *= math.radians, phi *= math.radians;
-  var cosPhi = math.cos(phi),
-      x = cosPhi * math.cos(lambda),
-      y = cosPhi * math.sin(lambda),
-      z = math.sin(phi),
-      w = math.atan2(math.sqrt((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w), x0 * x + y0 * y + z0 * z);
-  W1 += w;
-  X1 += w * (x0 + (x0 = x));
-  Y1 += w * (y0 + (y0 = y));
-  Z1 += w * (z0 + (z0 = z));
-  centroidPointCartesian(x0, y0, z0);
-}
-
-function centroidLineEnd() {
-  centroidStream.point = centroidPoint;
-}
-
-// See J. E. Brock, The Inertia Tensor for a Spherical Triangle,
-// J. Applied Mechanics 42, 239 (1975).
-function centroidRingStart() {
-  centroidStream.point = centroidRingPointFirst;
-}
-
-function centroidRingEnd() {
-  centroidRingPoint(lambda00, phi00);
-  centroidStream.point = centroidPoint;
-}
-
-function centroidRingPointFirst(lambda, phi) {
-  lambda00 = lambda, phi00 = phi;
-  lambda *= math.radians, phi *= math.radians;
-  centroidStream.point = centroidRingPoint;
-  var cosPhi = math.cos(phi);
-  x0 = cosPhi * math.cos(lambda);
-  y0 = cosPhi * math.sin(lambda);
-  z0 = math.sin(phi);
-  centroidPointCartesian(x0, y0, z0);
-}
-
-function centroidRingPoint(lambda, phi) {
-  lambda *= math.radians, phi *= math.radians;
-  var cosPhi = math.cos(phi),
-      x = cosPhi * math.cos(lambda),
-      y = cosPhi * math.sin(lambda),
-      z = math.sin(phi),
-      cx = y0 * z - z0 * y,
-      cy = z0 * x - x0 * z,
-      cz = x0 * y - y0 * x,
-      m = math.hypot(cx, cy, cz),
-      w = math.asin(m), // line weight = angle
-      v = m && -w / m; // area weight multiplier
-  X2.add(v * cx);
-  Y2.add(v * cy);
-  Z2.add(v * cz);
-  W1 += w;
-  X1 += w * (x0 + (x0 = x));
-  Y1 += w * (y0 + (y0 = y));
-  Z1 += w * (z0 + (z0 = z));
-  centroidPointCartesian(x0, y0, z0);
-}
-
-function geoCentroid$1(object) {
-  W0 = W1 =
-  X0 = Y0 = Z0 =
-  X1 = Y1 = Z1 = 0;
-  X2 = new fsum.Adder();
-  Y2 = new fsum.Adder();
-  Z2 = new fsum.Adder();
-  stream.default(object, centroidStream);
-
-  var x = +X2,
-      y = +Y2,
-      z = +Z2,
-      m = math.hypot(x, y, z);
-
-  // If the area-weighted ccentroid is undefined, fall back to length-weighted ccentroid.
-  if (m < math.epsilon2) {
-    x = X1, y = Y1, z = Z1;
-    // If the feature has zero length, fall back to arithmetic mean of point vectors.
-    if (W1 < math.epsilon) x = X0, y = Y0, z = Z0;
-    m = math.hypot(x, y, z);
-    // If the feature still has an undefined ccentroid, then return.
-    if (m < math.epsilon2) return [NaN, NaN];
-  }
-
-  return [math.atan2(y, x) * math.degrees, math.asin(z / m) * math.degrees];
-}
-
-exports.default = geoCentroid$1;

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

@@ -1,35 +0,0 @@
-'use strict';
-
-var cartesian = require('./cartesian.js');
-var math = require('./math.js');
-require('./rotation.js');
-
-// Generates a circle centered at [0°, 0°], with a given radius and precision.
-function circleStream(stream, radius, delta, direction, t0, t1) {
-  if (!delta) return;
-  var cosRadius = math.cos(radius),
-      sinRadius = math.sin(radius),
-      step = direction * delta;
-  if (t0 == null) {
-    t0 = radius + direction * math.tau;
-    t1 = radius - step / 2;
-  } else {
-    t0 = circleRadius(cosRadius, t0);
-    t1 = circleRadius(cosRadius, t1);
-    if (direction > 0 ? t0 < t1 : t0 > t1) t0 += direction * math.tau;
-  }
-  for (var point, t = t0; direction > 0 ? t > t1 : t < t1; t -= step) {
-    point = cartesian.spherical([cosRadius, -sinRadius * math.cos(t), -sinRadius * math.sin(t)]);
-    stream.point(point[0], point[1]);
-  }
-}
-
-// Returns the signed angle of a cartesian point relative to [cosRadius, 0, 0].
-function circleRadius(cosRadius, point) {
-  point = cartesian.cartesian(point), point[0] -= cosRadius;
-  cartesian.cartesianNormalizeInPlace(point);
-  var radius = math.acos(-point[1]);
-  return ((-point[2] < 0 ? -radius : radius) + math.tau - math.epsilon) % math.tau;
-}
-
-exports.circleStream = circleStream;

package/dist/cjs/bundled_modules/d3-geo/src/clip/antimeridian.js

@@ -1,98 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var index = require('./index.js');
-var math = require('../math.js');
-
-var clipAntimeridian = index.default(
-  function() { return true; },
-  clipAntimeridianLine,
-  clipAntimeridianInterpolate,
-  [-math.pi, -math.halfPi]
-);
-
-// Takes a line and cuts into visible segments. Return values: 0 - there were
-// intersections or the line was empty; 1 - no intersections; 2 - there were
-// intersections, and the first and last segments should be rejoined.
-function clipAntimeridianLine(stream) {
-  var lambda0 = NaN,
-      phi0 = NaN,
-      sign0 = NaN,
-      clean; // no intersections
-
-  return {
-    lineStart: function() {
-      stream.lineStart();
-      clean = 1;
-    },
-    point: function(lambda1, phi1) {
-      var sign1 = lambda1 > 0 ? math.pi : -math.pi,
-          delta = math.abs(lambda1 - lambda0);
-      if (math.abs(delta - math.pi) < math.epsilon) { // line crosses a pole
-        stream.point(lambda0, phi0 = (phi0 + phi1) / 2 > 0 ? math.halfPi : -math.halfPi);
-        stream.point(sign0, phi0);
-        stream.lineEnd();
-        stream.lineStart();
-        stream.point(sign1, phi0);
-        stream.point(lambda1, phi0);
-        clean = 0;
-      } else if (sign0 !== sign1 && delta >= math.pi) { // line crosses antimeridian
-        if (math.abs(lambda0 - sign0) < math.epsilon) lambda0 -= sign0 * math.epsilon; // handle degeneracies
-        if (math.abs(lambda1 - sign1) < math.epsilon) lambda1 -= sign1 * math.epsilon;
-        phi0 = clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1);
-        stream.point(sign0, phi0);
-        stream.lineEnd();
-        stream.lineStart();
-        stream.point(sign1, phi0);
-        clean = 0;
-      }
-      stream.point(lambda0 = lambda1, phi0 = phi1);
-      sign0 = sign1;
-    },
-    lineEnd: function() {
-      stream.lineEnd();
-      lambda0 = phi0 = NaN;
-    },
-    clean: function() {
-      return 2 - clean; // if intersections, rejoin first and last segments
-    }
-  };
-}
-
-function clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1) {
-  var cosPhi0,
-      cosPhi1,
-      sinLambda0Lambda1 = math.sin(lambda0 - lambda1);
-  return math.abs(sinLambda0Lambda1) > math.epsilon
-      ? math.atan((math.sin(phi0) * (cosPhi1 = math.cos(phi1)) * math.sin(lambda1)
-          - math.sin(phi1) * (cosPhi0 = math.cos(phi0)) * math.sin(lambda0))
-          / (cosPhi0 * cosPhi1 * sinLambda0Lambda1))
-      : (phi0 + phi1) / 2;
-}
-
-function clipAntimeridianInterpolate(from, to, direction, stream) {
-  var phi;
-  if (from == null) {
-    phi = direction * math.halfPi;
-    stream.point(-math.pi, phi);
-    stream.point(0, phi);
-    stream.point(math.pi, phi);
-    stream.point(math.pi, 0);
-    stream.point(math.pi, -phi);
-    stream.point(0, -phi);
-    stream.point(-math.pi, -phi);
-    stream.point(-math.pi, 0);
-    stream.point(-math.pi, phi);
-  } else if (math.abs(from[0] - to[0]) > math.epsilon) {
-    var lambda = from[0] < to[0] ? math.pi : -math.pi;
-    phi = direction * lambda / 2;
-    stream.point(-lambda, phi);
-    stream.point(0, phi);
-    stream.point(lambda, phi);
-  } else {
-    stream.point(to[0], to[1]);
-  }
-}
-
-exports.default = clipAntimeridian;

package/dist/cjs/bundled_modules/d3-geo/src/clip/buffer.js

@@ -1,30 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var noop = require('../noop.js');
-
-function clipBuffer() {
-  var lines = [],
-      line;
-  return {
-    point: function(x, y, m) {
-      line.push([x, y, m]);
-    },
-    lineStart: function() {
-      lines.push(line = []);
-    },
-    lineEnd: noop.default,
-    rejoin: function() {
-      if (lines.length > 1) lines.push(lines.pop().concat(lines.shift()));
-    },
-    result: function() {
-      var result = lines;
-      lines = [];
-      line = null;
-      return result;
-    }
-  };
-}
-
-exports.default = clipBuffer;

package/dist/cjs/bundled_modules/d3-geo/src/clip/circle.js

@@ -1,183 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var cartesian = require('../cartesian.js');
-var circle = require('../circle.js');
-var math = require('../math.js');
-var pointEqual = require('../pointEqual.js');
-var index = require('./index.js');
-
-function clipCircle(radius) {
-  var cr = math.cos(radius),
-      delta = 2 * math.radians,
-      smallRadius = cr > 0,
-      notHemisphere = math.abs(cr) > math.epsilon; // TODO optimise for this common case
-
-  function interpolate(from, to, direction, stream) {
-    circle.circleStream(stream, radius, delta, direction, from, to);
-  }
-
-  function visible(lambda, phi) {
-    return math.cos(lambda) * math.cos(phi) > cr;
-  }
-
-  // Takes a line and cuts into visible segments. Return values used for polygon
-  // clipping: 0 - there were intersections or the line was empty; 1 - no
-  // intersections 2 - there were intersections, and the first and last segments
-  // should be rejoined.
-  function clipLine(stream) {
-    var point0, // previous point
-        c0, // code for previous point
-        v0, // visibility of previous point
-        v00, // visibility of first point
-        clean; // no intersections
-    return {
-      lineStart: function() {
-        v00 = v0 = false;
-        clean = 1;
-      },
-      point: function(lambda, phi) {
-        var point1 = [lambda, phi],
-            point2,
-            v = visible(lambda, phi),
-            c = smallRadius
-              ? v ? 0 : code(lambda, phi)
-              : v ? code(lambda + (lambda < 0 ? math.pi : -math.pi), phi) : 0;
-        if (!point0 && (v00 = v0 = v)) stream.lineStart();
-        if (v !== v0) {
-          point2 = intersect(point0, point1);
-          if (!point2 || pointEqual.default(point0, point2) || pointEqual.default(point1, point2))
-            point1[2] = 1;
-        }
-        if (v !== v0) {
-          clean = 0;
-          if (v) {
-            // outside going in
-            stream.lineStart();
-            point2 = intersect(point1, point0);
-            stream.point(point2[0], point2[1]);
-          } else {
-            // inside going out
-            point2 = intersect(point0, point1);
-            stream.point(point2[0], point2[1], 2);
-            stream.lineEnd();
-          }
-          point0 = point2;
-        } else if (notHemisphere && point0 && smallRadius ^ v) {
-          var t;
-          // If the codes for two points are different, or are both zero,
-          // and there this segment intersects with the small circle.
-          if (!(c & c0) && (t = intersect(point1, point0, true))) {
-            clean = 0;
-            if (smallRadius) {
-              stream.lineStart();
-              stream.point(t[0][0], t[0][1]);
-              stream.point(t[1][0], t[1][1]);
-              stream.lineEnd();
-            } else {
-              stream.point(t[1][0], t[1][1]);
-              stream.lineEnd();
-              stream.lineStart();
-              stream.point(t[0][0], t[0][1], 3);
-            }
-          }
-        }
-        if (v && (!point0 || !pointEqual.default(point0, point1))) {
-          stream.point(point1[0], point1[1]);
-        }
-        point0 = point1, v0 = v, c0 = c;
-      },
-      lineEnd: function() {
-        if (v0) stream.lineEnd();
-        point0 = null;
-      },
-      // Rejoin first and last segments if there were intersections and the first
-      // and last points were visible.
-      clean: function() {
-        return clean | ((v00 && v0) << 1);
-      }
-    };
-  }
-
-  // Intersects the great circle between a and b with the clip circle.
-  function intersect(a, b, two) {
-    var pa = cartesian.cartesian(a),
-        pb = cartesian.cartesian(b);
-
-    // We have two planes, n1.p = d1 and n2.p = d2.
-    // Find intersection line p(t) = c1 n1 + c2 n2 + t (n1 ⨯ n2).
-    var n1 = [1, 0, 0], // normal
-        n2 = cartesian.cartesianCross(pa, pb),
-        n2n2 = cartesian.cartesianDot(n2, n2),
-        n1n2 = n2[0], // cartesianDot(n1, n2),
-        determinant = n2n2 - n1n2 * n1n2;
-
-    // Two polar points.
-    if (!determinant) return !two && a;
-
-    var c1 =  cr * n2n2 / determinant,
-        c2 = -cr * n1n2 / determinant,
-        n1xn2 = cartesian.cartesianCross(n1, n2),
-        A = cartesian.cartesianScale(n1, c1),
-        B = cartesian.cartesianScale(n2, c2);
-    cartesian.cartesianAddInPlace(A, B);
-
-    // Solve |p(t)|^2 = 1.
-    var u = n1xn2,
-        w = cartesian.cartesianDot(A, u),
-        uu = cartesian.cartesianDot(u, u),
-        t2 = w * w - uu * (cartesian.cartesianDot(A, A) - 1);
-
-    if (t2 < 0) return;
-
-    var t = math.sqrt(t2),
-        q = cartesian.cartesianScale(u, (-w - t) / uu);
-    cartesian.cartesianAddInPlace(q, A);
-    q = cartesian.spherical(q);
-
-    if (!two) return q;
-
-    // Two intersection points.
-    var lambda0 = a[0],
-        lambda1 = b[0],
-        phi0 = a[1],
-        phi1 = b[1],
-        z;
-
-    if (lambda1 < lambda0) z = lambda0, lambda0 = lambda1, lambda1 = z;
-
-    var delta = lambda1 - lambda0,
-        polar = math.abs(delta - math.pi) < math.epsilon,
-        meridian = polar || delta < math.epsilon;
-
-    if (!polar && phi1 < phi0) z = phi0, phi0 = phi1, phi1 = z;
-
-    // Check that the first point is between a and b.
-    if (meridian
-        ? polar
-          ? phi0 + phi1 > 0 ^ q[1] < (math.abs(q[0] - lambda0) < math.epsilon ? phi0 : phi1)
-          : phi0 <= q[1] && q[1] <= phi1
-        : delta > math.pi ^ (lambda0 <= q[0] && q[0] <= lambda1)) {
-      var q1 = cartesian.cartesianScale(u, (-w + t) / uu);
-      cartesian.cartesianAddInPlace(q1, A);
-      return [q, cartesian.spherical(q1)];
-    }
-  }
-
-  // Generates a 4-bit vector representing the location of a point relative to
-  // the small circle's bounding box.
-  function code(lambda, phi) {
-    var r = smallRadius ? radius : math.pi - radius,
-        code = 0;
-    if (lambda < -r) code |= 1; // left
-    else if (lambda > r) code |= 2; // right
-    if (phi < -r) code |= 4; // below
-    else if (phi > r) code |= 8; // above
-    return code;
-  }
-
-  return index.default(visible, clipLine, interpolate, smallRadius ? [0, -radius] : [-math.pi, radius - math.pi]);
-}
-
-exports.default = clipCircle;

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

@@ -1,137 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var buffer = require('./buffer.js');
-var rejoin = require('./rejoin.js');
-var math = require('../math.js');
-var polygonContains = require('../polygonContains.js');
-var merge = require('../../../d3-array/src/merge.js');
-
-function clip(pointVisible, clipLine, interpolate, start) {
-  return function(sink) {
-    var line = clipLine(sink),
-        ringBuffer = buffer.default(),
-        ringSink = clipLine(ringBuffer),
-        polygonStarted = false,
-        polygon,
-        segments,
-        ring;
-
-    var clip = {
-      point: point,
-      lineStart: lineStart,
-      lineEnd: lineEnd,
-      polygonStart: function() {
-        clip.point = pointRing;
-        clip.lineStart = ringStart;
-        clip.lineEnd = ringEnd;
-        segments = [];
-        polygon = [];
-      },
-      polygonEnd: function() {
-        clip.point = point;
-        clip.lineStart = lineStart;
-        clip.lineEnd = lineEnd;
-        segments = merge.default(segments);
-        var startInside = polygonContains.default(polygon, start);
-        if (segments.length) {
-          if (!polygonStarted) sink.polygonStart(), polygonStarted = true;
-          rejoin.default(segments, compareIntersection, startInside, interpolate, sink);
-        } else if (startInside) {
-          if (!polygonStarted) sink.polygonStart(), polygonStarted = true;
-          sink.lineStart();
-          interpolate(null, null, 1, sink);
-          sink.lineEnd();
-        }
-        if (polygonStarted) sink.polygonEnd(), polygonStarted = false;
-        segments = polygon = null;
-      },
-      sphere: function() {
-        sink.polygonStart();
-        sink.lineStart();
-        interpolate(null, null, 1, sink);
-        sink.lineEnd();
-        sink.polygonEnd();
-      }
-    };
-
-    function point(lambda, phi) {
-      if (pointVisible(lambda, phi)) sink.point(lambda, phi);
-    }
-
-    function pointLine(lambda, phi) {
-      line.point(lambda, phi);
-    }
-
-    function lineStart() {
-      clip.point = pointLine;
-      line.lineStart();
-    }
-
-    function lineEnd() {
-      clip.point = point;
-      line.lineEnd();
-    }
-
-    function pointRing(lambda, phi) {
-      ring.push([lambda, phi]);
-      ringSink.point(lambda, phi);
-    }
-
-    function ringStart() {
-      ringSink.lineStart();
-      ring = [];
-    }
-
-    function ringEnd() {
-      pointRing(ring[0][0], ring[0][1]);
-      ringSink.lineEnd();
-
-      var clean = ringSink.clean(),
-          ringSegments = ringBuffer.result(),
-          i, n = ringSegments.length, m,
-          segment,
-          point;
-
-      ring.pop();
-      polygon.push(ring);
-      ring = null;
-
-      if (!n) return;
-
-      // No intersections.
-      if (clean & 1) {
-        segment = ringSegments[0];
-        if ((m = segment.length - 1) > 0) {
-          if (!polygonStarted) sink.polygonStart(), polygonStarted = true;
-          sink.lineStart();
-          for (i = 0; i < m; ++i) sink.point((point = segment[i])[0], point[1]);
-          sink.lineEnd();
-        }
-        return;
-      }
-
-      // Rejoin connected segments.
-      // TODO reuse ringBuffer.rejoin()?
-      if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift()));
-
-      segments.push(ringSegments.filter(validSegment));
-    }
-
-    return clip;
-  };
-}
-
-function validSegment(segment) {
-  return segment.length > 1;
-}
-
-// Intersections are sorted along the clip edge. For both antimeridian cutting
-// and circle clipping, the same comparison is used.
-function compareIntersection(a, b) {
-  return ((a = a.x)[0] < 0 ? a[1] - math.halfPi - math.epsilon : math.halfPi - a[1])
-       - ((b = b.x)[0] < 0 ? b[1] - math.halfPi - math.epsilon : math.halfPi - b[1]);
-}
-
-exports.default = clip;