     i = findCurveIndex(@endLengths, Math.min(z, @endLengths[@endLengths.length-1]), 0, @endLengths.length)
     @curves[i].pointAtLength(z - @startLengths[i])
 
-  ###
-  Computes the first derivative at position t of the curve.
-  @param {number} t The point of the curve to consider. The curve starts at t=0 and ends at t=curves.length.
-  @returns {Point} The derivative as a vector.
-  ###
   firstDerivative: (t) ->
+    ###
+    Computes the first derivative at position t of the curve.
+
+    * t The point of the curve to consider. The curve starts at t=0 and ends at t=curves.length.
+    * Returns: Point. The derivative as a vector.
+    ###
     a = @_curveIndex(t)
     @curves[a.i].firstDerivative(a.t)
 
-  ###
-  Computes the second derivative at position t of the curve.
-  @param {number} t The point of the curve to consider. The curve starts at t=0 and ends at t=curves.length.
-  @returns {Point} The second derivative as a vector.
-  ###
   secondDerivative: (t) ->
+    ###
+    Computes the second derivative at position t of the curve.
+
+    * t The point of the curve to consider. The curve starts at t=0 and ends at t=curves.length.
+    * Returns: Point. The second derivative as a vector.
+    ###
     a = @_curveIndex(t)
     @curves[a.i].secondDerivative(a.t)
 
-  ###
-  Computes the curvature at position t of the curve. Curvature is 1/R where R is the instantaneous
-  radius of the curve.
-  @param {number} t The point of the curve to consider. The curve starts at t=0 and ends at t=curves.length.
-  @returns {number} The curvature value.
-  ###
   curvature: (t) ->
+    ###
+    Computes the curvature at position t of the curve. Curvature is 1/R where R is the instantaneous
+    radius of the curve.
+
+    * t The point of the curve to consider. The curve starts at t=0 and ends at t=curves.length.
+    * Returns: number. The curvature value.
+    ###
     a = @_curveIndex(t)
     @curves[a.i].curvature(a.t)
 
-  ###
-  Computes the tangent at position t of the curve.
-  @param {number} t The point of the curve to consider. The curve starts at t=0 and ends at t=curves.length.
-  @returns {Point} The tangent as a vector.
-  ###
   tangent: (t) ->
+    ###
+    Computes the tangent at position t of the curve.
+
+    * t The point of the curve to consider. The curve starts at t=0 and ends at t=curves.length.
+    * Returns: Point. The tangent as a vector.
+    ###
     a = this._curveIndex(t)
     return this.curves[a.i].tangent(a.t)
 
-  ###
-  Computes the normal at position t of the curve.
-  @param {number} t The point of the curve to consider. The curve starts at t=0 and ends at t=curves.length.
-  @returns {Point} The normal as a vector.
-  ###
   normal: (t) ->
+    ###
+    Computes the normal at position t of the curve.
+
+    * t The point of the curve to consider. The curve starts at t=0 and ends at t=curves.length.
+    * Returns: Point. The normal as a vector.
+    ###
     a = @_curveIndex(t)
     @curves[a.i].normal(a.t)
 
-  ###
-  Produces a new {BezierSpline} with the points normalized.
-  @param {normalizeOptions} [normalize='length'] Option to indicate if the spline should be recomputed to smooth out numerical
-  properties or make drawing easier.
-  length: recompute the spline so that each curve is approximately the same length.
-  x: recompute the curve so that the x values are evenly distributed. Useful for when the knots define a function of y in terms of x coordinates.
-  @param {number} [segmentLength=1] If normalizing, sets the step interval for how close the normalized knot points should be.
-  @param {number} [segmentCount] If normalizing, sets the number of knot points to use, evenly distributed based on the normalization strategy.
-  ###
   normalize: (method, segmentLength, segmentCount) ->
+    ###
+    Produces a new BezierSpline with the points normalized.
+
+    * method: ('length', 'x'). Default 'length'. Option to indicate if the spline should be recomputed to smooth out numerical
+    properties or make drawing easier.
+      * length: recompute the spline so that each curve is approximately the same length.
+      * x: recompute the curve so that the x values are evenly distributed. Useful for when the knots define a function of y in terms of x coordinates.
+    * segmentLength: number. Defatul 1. If normalizing, sets the step interval for how close the normalized knot points should be.
+    * segmentCount: number. If normalizing, sets the number of knot points to use, evenly distributed based on the normalization strategy.
+    ###
     segmentCount = segmentCount || Math.ceil(@length / (segmentLength || 1))
 
     switch method

    .map integrate, this
    .reduce (p, c) -> p + c

  ###
  @property {number} length The full length of the curve
  ###
  @getter 'length', -> @_length ?= @lengthAt(1)

  ###
  Computes the point at position t of the curve.
  @param {number} t The portion of the curve to consider. The curve starts at t=0 and ends at t=1.
  @returns {Point} the location point.
  ###
  point: (t) ->
    new Point((1-t)**3 * @p0.x +
              3 * (1-t)**2 * t * @p1.x +
              3 * (1-t) * t**2 * @p2.x +

      cx.p2 = cx.p2[extend..-extend]
      cy.p2 = cy.p2[extend..-extend]

    for [p0x, p0y, p1x, p1y, p2x, p2y, p3x, p3y], i in _zip(xs[...-1], ys[...-1], cx.p1, cy.p1, cx.p2, cy.p2, xs[1..], ys[1..])
      c = new BezierCurve(new Point(p0x, p0y), new Point(p1x, p1y), new Point(p2x, p2y), new Point(p3x, p3y))
      c.startLength = startLength;
      c.endLength = startLength + c.length;
