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

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

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

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

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

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

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

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

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