code: function(length, opt) {
  
              var segments = this.segments;
              var numSegments = segments.length;
              if (numSegments === 0) return null; // if segments is an empty array
  
              var fromStart = true;
              if (length < 0) {
                  fromStart = false; // negative lengths mean start calculation from end point
                  length = -length; // absolute value
              }
  
              opt = opt || {};
              var precision = (opt.precision === undefined) ? this.PRECISION : opt.precision;
              var segmentSubdivisions = (opt.segmentSubdivisions === undefined) ? this.getSegmentSubdivisions({ precision: precision }) : opt.segmentSubdivisions;
              // not using localOpt
  
              var lastValidSegment; // visible AND differentiable (with a tangent)
              var l = 0; // length so far
              for (var i = (fromStart ? 0 : (numSegments - 1)); (fromStart ? (i < numSegments) : (i >= 0)); (fromStart ? (i++) : (i--))) {
  
                  var segment = segments[i];
                  var subdivisions = segmentSubdivisions[i];
                  var d = segment.length({ precision: precision, subdivisions: subdivisions });
  
                  if (segment.isDifferentiable()) {
                      if (length <= (l + d)) {
                          return segment.tangentAtLength(((fromStart ? 1 : -1) * (length - l)), { precision: precision, subdivisions: subdivisions });
                      }
  
                      lastValidSegment = segment;
                  }
  
                  l += d;
              }
  
              // if length requested is higher than the length of the path, return tangent of endpoint of last valid segment
              if (lastValidSegment) {
                  var t = (fromStart ? 1 : 0);
                  return lastValidSegment.tangentAtT(t);
              }
  
              // if no valid segment, return null
              return null;
          }
docs: Returns tangent line at requested `length`, with precision better than requested `opt.precision`; optionally using `opt.segmentSubdivisions` provided. Accepts negative length.