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

package/dist/cjs/bundled_modules/d3-format/src/precisionPrefix.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var exponent = require('./exponent.js');
+
+function precisionPrefix(step, value) {
+  return Math.max(0, Math.max(-8, Math.min(8, Math.floor(exponent.default(value) / 3))) * 3 - exponent.default(Math.abs(step)));
+}
+
+exports.default = precisionPrefix;

package/dist/cjs/bundled_modules/d3-format/src/precisionRound.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var exponent = require('./exponent.js');
+
+function precisionRound(step, max) {
+  step = Math.abs(step), max = Math.abs(max) - step;
+  return Math.max(0, exponent.default(max) - exponent.default(step)) + 1;
+}
+
+exports.default = precisionRound;

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

@@ -0,0 +1,83 @@
+'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');
+
+exports.areaRingSum = new fsum.Adder();
+
+// hello?
+
+var areaSum = new fsum.Adder(),
+    lambda00,
+    phi00,
+    lambda0,
+    cosPhi0,
+    sinPhi0;
+
+var areaStream = {
+  point: noop.default,
+  lineStart: noop.default,
+  lineEnd: noop.default,
+  polygonStart: function() {
+    exports.areaRingSum = new fsum.Adder();
+    areaStream.lineStart = areaRingStart;
+    areaStream.lineEnd = areaRingEnd;
+  },
+  polygonEnd: function() {
+    var areaRing = +exports.areaRingSum;
+    areaSum.add(areaRing < 0 ? math.tau + areaRing : areaRing);
+    this.lineStart = this.lineEnd = this.point = noop.default;
+  },
+  sphere: function() {
+    areaSum.add(math.tau);
+  }
+};
+
+function areaRingStart() {
+  areaStream.point = areaPointFirst;
+}
+
+function areaRingEnd() {
+  areaPoint(lambda00, phi00);
+}
+
+function areaPointFirst(lambda, phi) {
+  areaStream.point = areaPoint;
+  lambda00 = lambda, phi00 = phi;
+  lambda *= math.radians, phi *= math.radians;
+  lambda0 = lambda, cosPhi0 = math.cos(phi = phi / 2 + math.quarterPi), sinPhi0 = math.sin(phi);
+}
+
+function areaPoint(lambda, phi) {
+  lambda *= math.radians, phi *= math.radians;
+  phi = phi / 2 + math.quarterPi; // half the angular distance from south pole
+
+  // Spherical excess E for a spherical triangle with vertices: south pole,
+  // previous point, current point.  Uses a formula derived from Cagnoli’s
+  // theorem.  See Todhunter, Spherical Trig. (1871), Sec. 103, Eq. (2).
+  var dLambda = lambda - lambda0,
+      sdLambda = dLambda >= 0 ? 1 : -1,
+      adLambda = sdLambda * dLambda,
+      cosPhi = math.cos(phi),
+      sinPhi = math.sin(phi),
+      k = sinPhi0 * sinPhi,
+      u = cosPhi0 * cosPhi + k * math.cos(adLambda),
+      v = k * sdLambda * math.sin(adLambda);
+  exports.areaRingSum.add(math.atan2(v, u));
+
+  // Advance the previous points.
+  lambda0 = lambda, cosPhi0 = cosPhi, sinPhi0 = sinPhi;
+}
+
+function geoArea$1(object) {
+  areaSum = new fsum.Adder();
+  stream.default(object, areaStream);
+  return areaSum * 2;
+}
+
+exports.areaStream = areaStream;
+exports.default = geoArea$1;

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

@@ -0,0 +1,185 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var area = require('./area.js');
+var cartesian = require('./cartesian.js');
+var math = require('./math.js');
+var stream = require('./stream.js');
+var fsum = require('../../d3-array/src/fsum.js');
+
+var lambda0, phi0, lambda1, phi1, // bounds
+    lambda2, // previous lambda-coordinate
+    lambda00, phi00, // first point
+    p0, // previous 3D point
+    deltaSum,
+    ranges,
+    range;
+
+var boundsStream = {
+  point: boundsPoint,
+  lineStart: boundsLineStart,
+  lineEnd: boundsLineEnd,
+  polygonStart: function() {
+    boundsStream.point = boundsRingPoint;
+    boundsStream.lineStart = boundsRingStart;
+    boundsStream.lineEnd = boundsRingEnd;
+    deltaSum = new fsum.Adder();
+    area.areaStream.polygonStart();
+  },
+  polygonEnd: function() {
+    area.areaStream.polygonEnd();
+    boundsStream.point = boundsPoint;
+    boundsStream.lineStart = boundsLineStart;
+    boundsStream.lineEnd = boundsLineEnd;
+    if (area.areaRingSum < 0) lambda0 = -(lambda1 = 180), phi0 = -(phi1 = 90);
+    else if (deltaSum > math.epsilon) phi1 = 90;
+    else if (deltaSum < -1e-6) phi0 = -90;
+    range[0] = lambda0, range[1] = lambda1;
+  },
+  sphere: function() {
+    lambda0 = -(lambda1 = 180), phi0 = -(phi1 = 90);
+  }
+};
+
+function boundsPoint(lambda, phi) {
+  ranges.push(range = [lambda0 = lambda, lambda1 = lambda]);
+  if (phi < phi0) phi0 = phi;
+  if (phi > phi1) phi1 = phi;
+}
+
+function linePoint(lambda, phi) {
+  var p = cartesian.cartesian([lambda * math.radians, phi * math.radians]);
+  if (p0) {
+    var normal = cartesian.cartesianCross(p0, p),
+        equatorial = [normal[1], -normal[0], 0],
+        inflection = cartesian.cartesianCross(equatorial, normal);
+    cartesian.cartesianNormalizeInPlace(inflection);
+    inflection = cartesian.spherical(inflection);
+    var delta = lambda - lambda2,
+        sign = delta > 0 ? 1 : -1,
+        lambdai = inflection[0] * math.degrees * sign,
+        phii,
+        antimeridian = math.abs(delta) > 180;
+    if (antimeridian ^ (sign * lambda2 < lambdai && lambdai < sign * lambda)) {
+      phii = inflection[1] * math.degrees;
+      if (phii > phi1) phi1 = phii;
+    } else if (lambdai = (lambdai + 360) % 360 - 180, antimeridian ^ (sign * lambda2 < lambdai && lambdai < sign * lambda)) {
+      phii = -inflection[1] * math.degrees;
+      if (phii < phi0) phi0 = phii;
+    } else {
+      if (phi < phi0) phi0 = phi;
+      if (phi > phi1) phi1 = phi;
+    }
+    if (antimeridian) {
+      if (lambda < lambda2) {
+        if (angle(lambda0, lambda) > angle(lambda0, lambda1)) lambda1 = lambda;
+      } else {
+        if (angle(lambda, lambda1) > angle(lambda0, lambda1)) lambda0 = lambda;
+      }
+    } else {
+      if (lambda1 >= lambda0) {
+        if (lambda < lambda0) lambda0 = lambda;
+        if (lambda > lambda1) lambda1 = lambda;
+      } else {
+        if (lambda > lambda2) {
+          if (angle(lambda0, lambda) > angle(lambda0, lambda1)) lambda1 = lambda;
+        } else {
+          if (angle(lambda, lambda1) > angle(lambda0, lambda1)) lambda0 = lambda;
+        }
+      }
+    }
+  } else {
+    ranges.push(range = [lambda0 = lambda, lambda1 = lambda]);
+  }
+  if (phi < phi0) phi0 = phi;
+  if (phi > phi1) phi1 = phi;
+  p0 = p, lambda2 = lambda;
+}
+
+function boundsLineStart() {
+  boundsStream.point = linePoint;
+}
+
+function boundsLineEnd() {
+  range[0] = lambda0, range[1] = lambda1;
+  boundsStream.point = boundsPoint;
+  p0 = null;
+}
+
+function boundsRingPoint(lambda, phi) {
+  if (p0) {
+    var delta = lambda - lambda2;
+    deltaSum.add(math.abs(delta) > 180 ? delta + (delta > 0 ? 360 : -360) : delta);
+  } else {
+    lambda00 = lambda, phi00 = phi;
+  }
+  area.areaStream.point(lambda, phi);
+  linePoint(lambda, phi);
+}
+
+function boundsRingStart() {
+  area.areaStream.lineStart();
+}
+
+function boundsRingEnd() {
+  boundsRingPoint(lambda00, phi00);
+  area.areaStream.lineEnd();
+  if (math.abs(deltaSum) > math.epsilon) lambda0 = -(lambda1 = 180);
+  range[0] = lambda0, range[1] = lambda1;
+  p0 = null;
+}
+
+// Finds the left-right distance between two longitudes.
+// This is almost the same as (lambda1 - lambda0 + 360°) % 360°, except that we want
+// the distance between ±180° to be 360°.
+function angle(lambda0, lambda1) {
+  return (lambda1 -= lambda0) < 0 ? lambda1 + 360 : lambda1;
+}
+
+function rangeCompare(a, b) {
+  return a[0] - b[0];
+}
+
+function rangeContains(range, x) {
+  return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x;
+}
+
+function geoBounds$1(feature) {
+  var i, n, a, b, merged, deltaMax, delta;
+
+  phi1 = lambda1 = -(lambda0 = phi0 = Infinity);
+  ranges = [];
+  stream.default(feature, boundsStream);
+
+  // First, sort ranges by their minimum longitudes.
+  if (n = ranges.length) {
+    ranges.sort(rangeCompare);
+
+    // Then, merge any ranges that overlap.
+    for (i = 1, a = ranges[0], merged = [a]; i < n; ++i) {
+      b = ranges[i];
+      if (rangeContains(a, b[0]) || rangeContains(a, b[1])) {
+        if (angle(a[0], b[1]) > angle(a[0], a[1])) a[1] = b[1];
+        if (angle(b[0], a[1]) > angle(a[0], a[1])) a[0] = b[0];
+      } else {
+        merged.push(a = b);
+      }
+    }
+
+    // Finally, find the largest gap between the merged ranges.
+    // The final bounding box will be the inverse of this gap.
+    for (deltaMax = -Infinity, n = merged.length - 1, i = 0, a = merged[n]; i <= n; a = b, ++i) {
+      b = merged[i];
+      if ((delta = angle(a[1], b[0])) > deltaMax) deltaMax = delta, lambda0 = b[0], lambda1 = a[1];
+    }
+  }
+
+  ranges = range = null;
+
+  return lambda0 === Infinity || phi0 === Infinity
+      ? [[NaN, NaN], [NaN, NaN]]
+      : [[lambda0, phi0], [lambda1, phi1]];
+}
+
+exports.default = geoBounds$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;