p5 2.0.4 → 2.0.5

package/package.json

@@ -18,7 +18,7 @@
     "test/**/*.js": "eslint",
     "utils/**/*.{js,mjs}": "eslint"
   },
-  "version": "2.0.4",
+  "version": "2.0.5",
   "dependencies": {
     "@davepagurek/bezier-path": "^0.0.2",
     "@japont/unicode-range": "^1.0.0",

package/types/core/main.d.ts

@@ -3380,7 +3380,7 @@ declare module 'p5' {
    * Draws a Bézier curve.Bézier curves can form shapes and curves that slope gently. They're defined
    * by two anchor points and two control points. Bézier curves provide more
    * control than the spline curves created with the
-   * curve() function.The first two parameters, `x1` and `y1`, set the first anchor point. The
+   * spline() function.The first two parameters, `x1` and `y1`, set the first anchor point. The
    * first anchor point is where the curve starts.The next four parameters, `x2`, `y2`, `x3`, and `y3`, set the two control
    * points. The control points "pull" the curve towards them.The seventh and eighth parameters, `x4` and `y4`, set the last anchor
    * point. The last anchor point is where the curve ends.Bézier curves can also be drawn in 3D using WebGL mode. The 3D version of
@@ -3443,13 +3443,11 @@ declare module 'p5' {
 
   /**
    * Draws a curve using a Catmull-Rom spline.Spline curves can form shapes and curves that slope gently. They’re like
-   * cables that are attached to a set of points. Splines are defined by two
-   * anchor points and two control points.The first two parameters, `x1` and `y1`, set the first control point. This
-   * point isn’t drawn and can be thought of as the curve’s starting point.The next four parameters, `x2`, `y2`, `x3`, and `y3`, set the two anchor
-   * points. The anchor points are the start and end points of the curve’s
-   * visible segment.The seventh and eighth parameters, `x4` and `y4`, set the last control
-   * point. This point isn’t drawn and can be thought of as the curve’s ending
-   * point.Spline curves can also be drawn in 3D using WebGL mode. The 3D version of
+   * cables that are attached to a set of points. By default (`ends: INCLUDE`),
+   * the curve passes through all four points you provide, in order
+   * `p0(x1,y1)` -> `p1(x2,y2)` -> `p2(x3,y3)` -> `p3(x4,y4)`. Think of them as
+   * points on a curve. If you switch to `ends: EXCLUDE`, p0 and p3 act
+   * like control points and only the middle span `p1->p2` is drawn.Spline curves can also be drawn in 3D using WebGL mode. The 3D version of
    * `spline()` has twelve arguments because each point has x-, y-, and
    * z-coordinates.
  *
@@ -3467,15 +3465,15 @@ declare module 'p5' {
   spline(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, x3: number, y3: number, z3: number, x4: number, y4: number, z4: number): void;
 
   /**
-   * Calculates coordinates along a spline curve using interpolation.`splinePoint()` calculates coordinates along a spline curve using the
-   * anchor and control points. It expects points in the same order as the
+   * Calculates coordinates along a spline curve using interpolation.`splinePoint()` calculates coordinates along a spline curve using four
+   * points p0, p1, p2, p3. It expects points in the same order as the
    * spline() function. `splinePoint()` works one axis
-   * at a time. Passing the anchor and control points' x-coordinates will
-   * calculate the x-coordinate of a point on the curve. Passing the anchor and
-   * control points' y-coordinates will calculate the y-coordinate of a point on
-   * the curve.The first parameter, `a`, is the coordinate of the first control point.The second and third parameters, `b` and `c`, are the coordinates of the
-   * anchor points.The fourth parameter, `d`, is the coordinate of the last control point.The fifth parameter, `t`, is the amount to interpolate along the curve. 0
-   * is the first anchor point, 1 is the second anchor point, and 0.5 is halfway
+   * at a time. Passing the points' x-coordinates will
+   * calculate the x-coordinate of a point on the curve. Passing the
+   * points' y-coordinates will calculate the y-coordinate of a point on
+   * the curve.The first parameter, `a`, is the coordinate of point p0.The second and third parameters, `b` and `c`, are the coordinates of
+   * points p1 and p2.The fourth parameter, `d`, is the coordinate of point p3.The fifth parameter, `t`, is the amount to interpolate along the span
+   * from p1 to p2. `t = 0` is p1, `t = 1` is p2, and `t = 0.5` is halfway
    * between them.
  *
    * @param
@@ -3488,15 +3486,14 @@ declare module 'p5' {
 
   /**
    * Calculates coordinates along a line that's tangent to a spline curve.Tangent lines skim the surface of a curve. A tangent line's slope equals
-   * the curve's slope at the point where it intersects.`splineTangent()` calculates coordinates along a tangent line using the
-   * spline curve's anchor and control points. It expects points in the same
-   * order as the spline() function. `splineTangent()`
-   * works one axis at a time. Passing the anchor and control points'
-   * x-coordinates will calculate the x-coordinate of a point on the tangent
-   * line. Passing the anchor and control points' y-coordinates will calculate
-   * the y-coordinate of a point on the tangent line.The first parameter, `a`, is the coordinate of the first control point.The second and third parameters, `b` and `c`, are the coordinates of the
-   * anchor points.The fourth parameter, `d`, is the coordinate of the last control point.The fifth parameter, `t`, is the amount to interpolate along the curve. 0
-   * is the first anchor point, 1 is the second anchor point, and 0.5 is halfway
+   * the curve's slope at the point where it intersects.`splineTangent()` calculates coordinates along a tangent line using four
+   * points p0, p1, p2, p3. It expects points in the same order as the
+   * spline() function. `splineTangent()` works one
+   * axis at a time. Passing the points' x-coordinates returns the x-component of
+   * the tangent vector; passing the points' y-coordinates returns the y-component.
+   * The first parameter, `a`, is the coordinate of point p0.The second and third parameters, `b` and `c`, are the coordinates of
+   * points p1 and p2.The fourth parameter, `d`, is the coordinate of point p3.The fifth parameter, `t`, is the amount to interpolate along the span
+   * from p1 to p2. `t = 0` is p1, `t = 1` is p2, and `t = 0.5` is halfway
    * between them.
  *
    * @param
@@ -3531,49 +3528,44 @@ declare module 'p5' {
   bezierOrder(): number;
 
   /**
-   * Adds a spline curve segment to a custom shape.`splineVertex()` adds a curved segment to custom shapes. The spline curves
-   * it creates are defined like those made by the
-   * curve() function. `splineVertex()` must be called
-   * between the beginShape() and
+   * Connects points with a smooth curve (a spline).`splineVertex()` adds a curved segment to custom shapes.
+   * The curve it creates follows the same rules as the ones
+   * made with the spline() function.
+   * `splineVertex()` must be called between the
+   * beginShape() and
    * endShape() functions.Spline curves can form shapes and curves that slope gently. They’re like
-   * cables that are attached to a set of points. Splines are defined by two
-   * anchor points and two control points. `splineVertex()` must be called at
-   * least four times between
+   * cables that are attached to a set of points. `splineVertex()` draws a smooth
+   * curve through the points you give it.
    * beginShape() and
-   * endShape() in order to draw a curve:`beginShape();
+   * endShape() in order to draw a curve:If you provide three points, the spline will pass through them.
+   * It works the same way with any number of points.`beginShape();
    * 
-   * // Add the first control point.
-   * splineVertex(84, 91);
+   * // Add the first point.
+   * splineVertex(25, 80);
    * 
-   * // Add the anchor points to draw between.
-   * splineVertex(68, 19);
-   * splineVertex(21, 17);
+   * // Add the second point.
+   * splineVertex(20, 30);
    * 
-   * // Add the second control point.
-   * splineVertex(32, 91);
+   * // Add the last point.
+   * splineVertex(85, 60);
    * 
-   * endShape();`The code snippet above would only draw the curve between the anchor points,
-   * similar to the curve() function. The segments
-   * between the control and anchor points can be drawn by calling
-   * `splineVertex()` with the coordinates of the control points:`beginShape();
+   * endShape();`Passing in `CLOSE` to `endShape()` closes the spline smoothly.`beginShape();
    * 
-   * // Add the first control point and draw a segment to it.
-   * splineVertex(84, 91);
-   * splineVertex(84, 91);
+   * // Add the first point.
+   * splineVertex(25, 80);
    * 
-   * // Add the anchor points to draw between.
-   * splineVertex(68, 19);
-   * splineVertex(21, 17);
+   * // Add the second point.
+   * splineVertex(20, 30);
    * 
-   * // Add the second control point.
-   * splineVertex(32, 91);
+   * // Add the second point.
+   * splineVertex(85, 60);
    * 
-   * // Uncomment the next line to draw the segment to the second control point.
-   * // splineVertex(32, 91);
-   * 
-   * endShape();`The first two parameters, `x` and `y`, set the vertex’s location. For
-   * example, calling `splineVertex(10, 10)` adds a point to the curve at
-   * `(10, 10)`.Spline curves can also be drawn in 3D using WebGL mode. The 3D version of
+   * endShape(CLOSE);`By default (`ends: INCLUDE`), the curve passes through
+   * all the points you add with `splineVertex()`, similar to
+   * the spline() function. To draw only
+   * the middle span p1->p2 (skipping p0->p1 and p2->p3), set
+   * `splineProperty('ends', EXCLUDE)`. You don’t need to duplicate
+   * vertices to draw those spans.Spline curves can also be drawn in 3D using WebGL mode. The 3D version of
    * `splineVertex()` has three arguments because each point has x-, y-, and
    * z-coordinates. By default, the vertex’s z-coordinate is set to 0.Note: `splineVertex()` won’t work when an argument is passed to
    * beginShape().
@@ -3590,19 +3582,43 @@ declare module 'p5' {
   splineVertex(x: number, y: number, z: number, u: number, v: number): void;
 
   /**
-   * Sets the property of a curve.For example, set tightness,
-   * use `splineProperty('tightness', t)`, with `t` between 0 and 1,
-   * at 0 as default.Spline curves are like cables that are attached to a set of points.
-   * Adjusting tightness adjusts how tightly the cable is
-   * attached to the points. The parameter, tightness, determines
-   * how the curve fits to the vertex points. By default,
-   * tightness is set to 0. Setting tightness to 1, as in
-   * `splineProperty('tightness', 1)`, connects the curve's points
-   * using straight lines. Values in the range from –5 to 5
-   * deform curves while leaving them recognizable.This function can also be used to set 'ends' property
-   * (see also: the curveDetail() example),
-   * such as: `splineProperty('ends', EXCLUDE)` to exclude
-   * vertices, or `splineProperty('ends', INCLUDE)` to include them.
+   * Gets or sets a given spline property.Use `splineProperty()` to adjust the behavior of splines
+   * created with `splineVertex()` or `spline()`. You can control
+   * two key aspects of a spline: its end behavior (`ends`) and
+   * its curvature (`tightness`).By default, the ends property is set to `INCLUDE`, which means
+   * the spline passes through every point, including the endpoints.
+   * You can also set it to `EXCLUDE` i.e. `splineProperty('ends', EXCLUDE)`,
+   * which makes the spline pass through all points except the endpoints.`INCLUDE` case will have the spline passing through
+   * all points, like this:`splineProperty('ends', INCLUDE); // no need to set this, as it is the default
+   * spline(25, 46, 93, 44, 93, 81, 35, 85);
+   * 
+   * point(25, 46);
+   * point(93, 44);
+   * point(93, 81);
+   * point(35, 85);`EXCLUDE case will have the spline passing through
+   * the middle points, like this:`splineProperty('ends', INCLUDE);
+   * spline(25, 46, 93, 44, 93, 81, 35, 85);
+   * 
+   * point(25, 46);
+   * point(93, 44);
+   * point(93, 81);
+   * point(35, 85);`By default, the tightness property is set to `0`,
+   * producing a smooth curve that passes evenly through
+   * the vertices. Negative values make the curve looser,
+   * while positive values make it tighter. Common values
+   * range between -1 and 1, though values outside this
+   * range can also be used for different effects.For example, To set tightness, use `splineProperty('tightness', t)`,
+   * (default: t = 0).Here's the example showing negetive value of tightness,
+   * which creates a rounder bulge:`splineProperty('tightness', -5)
+   * stroke(0);
+   * strokeWeight(2);
+   * spline(25, 46, 93, 44, 93, 81, 35, 85);`Here's the example showing positive value of tightness,
+   * which makes the curve tighter and more angular:`splineProperty('tightness', 5)
+   * stroke(0);
+   * strokeWeight(2);
+   * spline(25, 46, 93, 44, 93, 81, 35, 85);`In all cases, the splines in p5.js are cardinal splines.
+   * When tightness is 0, these splines are often known as
+   * Catmull-Rom splines
  *
    * @param
    * @param

package/types/global.d.ts

@@ -2830,7 +2830,7 @@ declare global {
    * Draws a Bézier curve.Bézier curves can form shapes and curves that slope gently. They're defined
    * by two anchor points and two control points. Bézier curves provide more
    * control than the spline curves created with the
-   * curve() function.The first two parameters, `x1` and `y1`, set the first anchor point. The
+   * spline() function.The first two parameters, `x1` and `y1`, set the first anchor point. The
    * first anchor point is where the curve starts.The next four parameters, `x2`, `y2`, `x3`, and `y3`, set the two control
    * points. The control points "pull" the curve towards them.The seventh and eighth parameters, `x4` and `y4`, set the last anchor
    * point. The last anchor point is where the curve ends.Bézier curves can also be drawn in 3D using WebGL mode. The 3D version of
@@ -2872,13 +2872,11 @@ declare global {
 
   /**
    * Draws a curve using a Catmull-Rom spline.Spline curves can form shapes and curves that slope gently. They’re like
-   * cables that are attached to a set of points. Splines are defined by two
-   * anchor points and two control points.The first two parameters, `x1` and `y1`, set the first control point. This
-   * point isn’t drawn and can be thought of as the curve’s starting point.The next four parameters, `x2`, `y2`, `x3`, and `y3`, set the two anchor
-   * points. The anchor points are the start and end points of the curve’s
-   * visible segment.The seventh and eighth parameters, `x4` and `y4`, set the last control
-   * point. This point isn’t drawn and can be thought of as the curve’s ending
-   * point.Spline curves can also be drawn in 3D using WebGL mode. The 3D version of
+   * cables that are attached to a set of points. By default (`ends: INCLUDE`),
+   * the curve passes through all four points you provide, in order
+   * `p0(x1,y1)` -> `p1(x2,y2)` -> `p2(x3,y3)` -> `p3(x4,y4)`. Think of them as
+   * points on a curve. If you switch to `ends: EXCLUDE`, p0 and p3 act
+   * like control points and only the middle span `p1->p2` is drawn.Spline curves can also be drawn in 3D using WebGL mode. The 3D version of
    * `spline()` has twelve arguments because each point has x-, y-, and
    * z-coordinates.
    */
@@ -2887,30 +2885,29 @@ declare global {
   function spline(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, x3: number, y3: number, z3: number, x4: number, y4: number, z4: number): void;
 
   /**
-   * Calculates coordinates along a spline curve using interpolation.`splinePoint()` calculates coordinates along a spline curve using the
-   * anchor and control points. It expects points in the same order as the
+   * Calculates coordinates along a spline curve using interpolation.`splinePoint()` calculates coordinates along a spline curve using four
+   * points p0, p1, p2, p3. It expects points in the same order as the
    * spline() function. `splinePoint()` works one axis
-   * at a time. Passing the anchor and control points' x-coordinates will
-   * calculate the x-coordinate of a point on the curve. Passing the anchor and
-   * control points' y-coordinates will calculate the y-coordinate of a point on
-   * the curve.The first parameter, `a`, is the coordinate of the first control point.The second and third parameters, `b` and `c`, are the coordinates of the
-   * anchor points.The fourth parameter, `d`, is the coordinate of the last control point.The fifth parameter, `t`, is the amount to interpolate along the curve. 0
-   * is the first anchor point, 1 is the second anchor point, and 0.5 is halfway
+   * at a time. Passing the points' x-coordinates will
+   * calculate the x-coordinate of a point on the curve. Passing the
+   * points' y-coordinates will calculate the y-coordinate of a point on
+   * the curve.The first parameter, `a`, is the coordinate of point p0.The second and third parameters, `b` and `c`, are the coordinates of
+   * points p1 and p2.The fourth parameter, `d`, is the coordinate of point p3.The fifth parameter, `t`, is the amount to interpolate along the span
+   * from p1 to p2. `t = 0` is p1, `t = 1` is p2, and `t = 0.5` is halfway
    * between them.
    */
   function splinePoint(a: number, b: number, c: number, d: number, t: number): number;
 
   /**
    * Calculates coordinates along a line that's tangent to a spline curve.Tangent lines skim the surface of a curve. A tangent line's slope equals
-   * the curve's slope at the point where it intersects.`splineTangent()` calculates coordinates along a tangent line using the
-   * spline curve's anchor and control points. It expects points in the same
-   * order as the spline() function. `splineTangent()`
-   * works one axis at a time. Passing the anchor and control points'
-   * x-coordinates will calculate the x-coordinate of a point on the tangent
-   * line. Passing the anchor and control points' y-coordinates will calculate
-   * the y-coordinate of a point on the tangent line.The first parameter, `a`, is the coordinate of the first control point.The second and third parameters, `b` and `c`, are the coordinates of the
-   * anchor points.The fourth parameter, `d`, is the coordinate of the last control point.The fifth parameter, `t`, is the amount to interpolate along the curve. 0
-   * is the first anchor point, 1 is the second anchor point, and 0.5 is halfway
+   * the curve's slope at the point where it intersects.`splineTangent()` calculates coordinates along a tangent line using four
+   * points p0, p1, p2, p3. It expects points in the same order as the
+   * spline() function. `splineTangent()` works one
+   * axis at a time. Passing the points' x-coordinates returns the x-component of
+   * the tangent vector; passing the points' y-coordinates returns the y-component.
+   * The first parameter, `a`, is the coordinate of point p0.The second and third parameters, `b` and `c`, are the coordinates of
+   * points p1 and p2.The fourth parameter, `d`, is the coordinate of point p3.The fifth parameter, `t`, is the amount to interpolate along the span
+   * from p1 to p2. `t = 0` is p1, `t = 1` is p2, and `t = 0.5` is halfway
    * between them.
    */
   function splineTangent(a: number, b: number, c: number, d: number, t: number): number;
@@ -2937,49 +2934,44 @@ declare global {
   function bezierOrder(): number;
 
   /**
-   * Adds a spline curve segment to a custom shape.`splineVertex()` adds a curved segment to custom shapes. The spline curves
-   * it creates are defined like those made by the
-   * curve() function. `splineVertex()` must be called
-   * between the beginShape() and
+   * Connects points with a smooth curve (a spline).`splineVertex()` adds a curved segment to custom shapes.
+   * The curve it creates follows the same rules as the ones
+   * made with the spline() function.
+   * `splineVertex()` must be called between the
+   * beginShape() and
    * endShape() functions.Spline curves can form shapes and curves that slope gently. They’re like
-   * cables that are attached to a set of points. Splines are defined by two
-   * anchor points and two control points. `splineVertex()` must be called at
-   * least four times between
+   * cables that are attached to a set of points. `splineVertex()` draws a smooth
+   * curve through the points you give it.
    * beginShape() and
-   * endShape() in order to draw a curve:`beginShape();
+   * endShape() in order to draw a curve:If you provide three points, the spline will pass through them.
+   * It works the same way with any number of points.`beginShape();
    * 
-   * // Add the first control point.
-   * splineVertex(84, 91);
+   * // Add the first point.
+   * splineVertex(25, 80);
    * 
-   * // Add the anchor points to draw between.
-   * splineVertex(68, 19);
-   * splineVertex(21, 17);
+   * // Add the second point.
+   * splineVertex(20, 30);
    * 
-   * // Add the second control point.
-   * splineVertex(32, 91);
+   * // Add the last point.
+   * splineVertex(85, 60);
    * 
-   * endShape();`The code snippet above would only draw the curve between the anchor points,
-   * similar to the curve() function. The segments
-   * between the control and anchor points can be drawn by calling
-   * `splineVertex()` with the coordinates of the control points:`beginShape();
+   * endShape();`Passing in `CLOSE` to `endShape()` closes the spline smoothly.`beginShape();
    * 
-   * // Add the first control point and draw a segment to it.
-   * splineVertex(84, 91);
-   * splineVertex(84, 91);
+   * // Add the first point.
+   * splineVertex(25, 80);
    * 
-   * // Add the anchor points to draw between.
-   * splineVertex(68, 19);
-   * splineVertex(21, 17);
+   * // Add the second point.
+   * splineVertex(20, 30);
    * 
-   * // Add the second control point.
-   * splineVertex(32, 91);
+   * // Add the second point.
+   * splineVertex(85, 60);
    * 
-   * // Uncomment the next line to draw the segment to the second control point.
-   * // splineVertex(32, 91);
-   * 
-   * endShape();`The first two parameters, `x` and `y`, set the vertex’s location. For
-   * example, calling `splineVertex(10, 10)` adds a point to the curve at
-   * `(10, 10)`.Spline curves can also be drawn in 3D using WebGL mode. The 3D version of
+   * endShape(CLOSE);`By default (`ends: INCLUDE`), the curve passes through
+   * all the points you add with `splineVertex()`, similar to
+   * the spline() function. To draw only
+   * the middle span p1->p2 (skipping p0->p1 and p2->p3), set
+   * `splineProperty('ends', EXCLUDE)`. You don’t need to duplicate
+   * vertices to draw those spans.Spline curves can also be drawn in 3D using WebGL mode. The 3D version of
    * `splineVertex()` has three arguments because each point has x-, y-, and
    * z-coordinates. By default, the vertex’s z-coordinate is set to 0.Note: `splineVertex()` won’t work when an argument is passed to
    * beginShape().
@@ -2993,19 +2985,43 @@ declare global {
   function splineVertex(x: number, y: number, z: number, u: number, v: number): void;
 
   /**
-   * Sets the property of a curve.For example, set tightness,
-   * use `splineProperty('tightness', t)`, with `t` between 0 and 1,
-   * at 0 as default.Spline curves are like cables that are attached to a set of points.
-   * Adjusting tightness adjusts how tightly the cable is
-   * attached to the points. The parameter, tightness, determines
-   * how the curve fits to the vertex points. By default,
-   * tightness is set to 0. Setting tightness to 1, as in
-   * `splineProperty('tightness', 1)`, connects the curve's points
-   * using straight lines. Values in the range from –5 to 5
-   * deform curves while leaving them recognizable.This function can also be used to set 'ends' property
-   * (see also: the curveDetail() example),
-   * such as: `splineProperty('ends', EXCLUDE)` to exclude
-   * vertices, or `splineProperty('ends', INCLUDE)` to include them.
+   * Gets or sets a given spline property.Use `splineProperty()` to adjust the behavior of splines
+   * created with `splineVertex()` or `spline()`. You can control
+   * two key aspects of a spline: its end behavior (`ends`) and
+   * its curvature (`tightness`).By default, the ends property is set to `INCLUDE`, which means
+   * the spline passes through every point, including the endpoints.
+   * You can also set it to `EXCLUDE` i.e. `splineProperty('ends', EXCLUDE)`,
+   * which makes the spline pass through all points except the endpoints.`INCLUDE` case will have the spline passing through
+   * all points, like this:`splineProperty('ends', INCLUDE); // no need to set this, as it is the default
+   * spline(25, 46, 93, 44, 93, 81, 35, 85);
+   * 
+   * point(25, 46);
+   * point(93, 44);
+   * point(93, 81);
+   * point(35, 85);`EXCLUDE case will have the spline passing through
+   * the middle points, like this:`splineProperty('ends', INCLUDE);
+   * spline(25, 46, 93, 44, 93, 81, 35, 85);
+   * 
+   * point(25, 46);
+   * point(93, 44);
+   * point(93, 81);
+   * point(35, 85);`By default, the tightness property is set to `0`,
+   * producing a smooth curve that passes evenly through
+   * the vertices. Negative values make the curve looser,
+   * while positive values make it tighter. Common values
+   * range between -1 and 1, though values outside this
+   * range can also be used for different effects.For example, To set tightness, use `splineProperty('tightness', t)`,
+   * (default: t = 0).Here's the example showing negetive value of tightness,
+   * which creates a rounder bulge:`splineProperty('tightness', -5)
+   * stroke(0);
+   * strokeWeight(2);
+   * spline(25, 46, 93, 44, 93, 81, 35, 85);`Here's the example showing positive value of tightness,
+   * which makes the curve tighter and more angular:`splineProperty('tightness', 5)
+   * stroke(0);
+   * strokeWeight(2);
+   * spline(25, 46, 93, 44, 93, 81, 35, 85);`In all cases, the splines in p5.js are cardinal splines.
+   * When tightness is 0, these splines are often known as
+   * Catmull-Rom splines
    */
   function splineProperty(property: string, value: any): void;