plotboilerplate 1.20.2 → 1.21.0

package/src/ts/BezierPath.ts

@@ -23,7 +23,9 @@
  * @modified 2022-01-31 Added `BezierPath.getEvenDistributionVertices(number)`.
  * @modified 2022-02-02 Added the `destroy` method.
  * @modified 2022-02-02 Cleared the `toSVGString` function (deprecated). Use `drawutilssvg` instead.
- * @version 2.5.0
+ * @modified 2023-10-06 Adding the `BezierPath.toPathPoints()` method.
+ * @modified 2023-10-07 Adding the `BezierPath.fromCurve(CubicBezierCurve)` static function.
+ * @version 2.6.0
  *
  * @file BezierPath
  * @public
@@ -139,10 +141,13 @@ export class BezierPath implements SVGSerializable {
    * @name BezierPath
    * @param {Vertex[]} pathPoints - An array of path vertices (no control points).
    **/
-  private constructor(pathPoints: Array<Vertex> | undefined | null) {
+  private constructor() {
+    // pathPoints: Array<Vertex> | undefined | null) {
     this.uid = UIDGenerator.next();
 
-    if (!pathPoints) pathPoints = [];
+    // if (!pathPoints) {
+    //   pathPoints = [];
+    // }
     this.totalArcLength = 0.0;
     // Set this flag to true if you want the first point and
     // last point of the path to be auto adjusted, too.
@@ -300,220 +305,6 @@ export class BezierPath implements SVGSerializable {
     return this.bezierCurves[curveIndex];
   }
 
-  /**
-   * Remove the end point of this path (which removes the last curve from this path).<br>
-   * <br>
-   * Please note that this function does never remove the first curve, thus the path
-   * cannot be empty after this call.
-   *
-   * @method removeEndPoint
-   * @instance
-   * @memberof BezierPath
-   * @return {boolean} Indicating if the last curve was removed.
-   **/
-  /*
-    BezierPath.prototype.removeEndPoint = function() {
-	if( this.bezierCurves.length <= 1 )
-	    return false;
-	
-	var newArray = [ this.bezierCurves.length-1 ];
-	for( var i = 0; i < this.bezierCurves.length-1; i++ ) {
-	    newArray[i] = this.bezierCurves[i];
-	}
-	
-	// Update arc length
-	this.totalArcLength -= this.bezierCurves[ this.bezierCurves.length-1 ].getLength();
-	this.bezierCurves = newArray;	
-	return true;
-    }
-    */
-
-  /**
-   * Remove the start point of this path (which removes the first curve from this path).<br>
-   * <br>
-   * Please note that this function does never remove the last curve, thus the path
-   * cannot be empty after this call.<br>
-   *
-   * @method removeStartPoint
-   * @instance
-   * @memberof BezierPath
-   * @return {boolean} Indicating if the first curve was removed.
-   **/
-  /*
-    BezierPath.prototype.removeStartPoint = function() {
-
-	if( this.bezierCurves.length <= 1 )
-	    return false;
-
-	var newArray = [ this.bezierCurves.length-1 ];
-	for( var i = 1; i < this.bezierCurves.length; i++ ) {
-
-	    newArray[i-1] = this.bezierCurves[i];
-
-	}
-	
-	// Update arc length
-	this.totalArcLength -= this.bezierCurves[ 0 ].getLength();
-	this.bezierCurves = newArray;
-	
-	return true;
-    }
-    */
-
-  /**
-   * Removes a path point inside the path.
-   *
-   * This function joins the bezier curve at the given index with
-   * its predecessor, which means that the start point at the given
-   * curve index will be removed.
-   *
-   * @method joinAt
-   * @param {number} curveIndex - The index of the curve to be joined with its predecessor.
-   * @instance
-   * @memberof BezierPath
-   * @return {boolean} True if the passed index indicated an inner vertex and the two curves were joined.
-   **/
-  /*
-    BezierPath.prototype.joinAt = function( curveIndex ) {
-
-	if( curveIndex < 0 || curveIndex >= this.bezierCurves.length )
-	    return false;
-	
-	var leftCurve  = this.bezierCurves[ curveIndex-1 ];
-	var rightCurve = this.bezierCurves[ curveIndex ];
-
-	// Make the length of the new handle double that long
-	var leftControlPoint = leftCurve.getStartControlPoint().clone();
-	leftControlPoint.sub( leftCurve.getStartPoint() );
-	leftControlPoint.multiplyScalar( 2.0 );
-	leftControlPoint.add( leftCurve.getStartPoint() );
-	
-	var rightControlPoint = rightCurve.getEndControlPoint().clone();
-	rightControlPoint.sub( rightCurve.getEndPoint() );
-	rightControlPoint.multiplyScalar( 2.0 );
-	rightControlPoint.add( rightCurve.getEndPoint() );	
-
-	var newCurve = new IKRS.CubicBezierCurve( leftCurve.getStartPoint(),
-						  rightCurve.getEndPoint(),
-						  leftControlPoint,
-						  rightControlPoint 
-						);	
-	// Place into array
-	var newArray = [ this.bezierCurves.length - 1 ];
-
-	for( var i = 0; i < curveIndex-1; i++ ) 
-	    newArray[ i ] = this.bezierCurves[i];
-	
-	newArray[ curveIndex-1 ] = newCurve;
-	
-	// Shift trailing curves left
-	for( var i = curveIndex; i+1 < this.bezierCurves.length; i++ ) 
-	    newArray[ i ] = this.bezierCurves[ i+1 ];
-		
-	this.bezierCurves = newArray;
-	this.updateArcLengths();
-
-	return true;
-    }
-    */
-
-  /**
-   * Add a new inner curve point to the path.<br>
-   * <br>
-   * This function splits the bezier curve at the given index and given
-   * curve segment index.
-   *
-   * @method splitAt
-   * @param {number} curveIndex - The index of the curve to split.
-   * @param {nunber} segmentIndex - The index of the curve segment where the split should be performed.
-   * @instance
-   * @memberof BezierPath
-   * @return {boolean} True if the passed indices were valid and the path was split.
-   **/
-  /*
-    BezierPath.prototype.splitAt = function( curveIndex,
-					     segmentIndex 
-					   ) {
-	// Must be a valid curve index
-	if( curveIndex < 0 || curveIndex >= this.bezierCurves.length )
-	    return false;
-
-	var oldCurve = this.bezierCurves[ curveIndex ];
-
-	// Segment must be an INNER point!
-	// (the outer points are already bezier end/start points!)
-	if( segmentIndex < 1 || segmentIndex-1 >= oldCurve.segmentCache.length )
-	    return false;
-
-	// Make room for a new curve
-	for( var c = this.bezierCurves.length; c > curveIndex; c-- ) {
-	    // Move one position to the right
-	    this.bezierCurves[ c ] = this.bezierCurves[ c-1 ];	    
-	}
-
-	// Accumulate segment lengths
-	var u = 0;
-	for( var i = 0; i < segmentIndex; i++ )
-	    u += oldCurve.segmentLengths[i];
-	//var tangent = oldCurve.getTangentAt( u );
-	var tangent = oldCurve.getTangent( u );
-	tangent = tangent.multiplyScalar( 0.25 ); 
-
-	var leftEndControlPoint = oldCurve.segmentCache[ segmentIndex ].clone();
-	leftEndControlPoint.sub( tangent );
-	
-	var rightStartControlPoint = oldCurve.segmentCache[ segmentIndex ].clone();
-	rightStartControlPoint.add( tangent );
-	
-	// Make the old existing handles a quarter that long
-	var leftStartControlPoint = oldCurve.getStartControlPoint().clone();
-	// move to (0,0)
-	leftStartControlPoint.sub( oldCurve.getStartPoint() );
-	leftStartControlPoint.multiplyScalar( 0.25 );
-	leftStartControlPoint.add( oldCurve.getStartPoint() );
-
-	var rightEndControlPoint = oldCurve.getEndControlPoint().clone(); 
-	// move to (0,0)
-	rightEndControlPoint.sub( oldCurve.getEndPoint() );
-	rightEndControlPoint.multiplyScalar( 0.25 );
-	rightEndControlPoint.add( oldCurve.getEndPoint() );
-
-	var newLeft  = new CubicBezierCurve( oldCurve.getStartPoint(),                      // old start point
-					     oldCurve.segmentCache[ segmentIndex ],         // new end point
-					     leftStartControlPoint,                         // old start control point 
-					     leftEndControlPoint                            // new end control point
-					   );
-	var newRight = new CubicBezierCurve( oldCurve.segmentCache[ segmentIndex ],         // new start point
-					     oldCurve.getEndPoint(),                        // old end point
-					     rightStartControlPoint,                        // new start control point 
-					     rightEndControlPoint                           // old end control point
-					   );
-	
-	// Insert split curve(s) at free index
-	this.bezierCurves[ curveIndex ]     = newLeft;
-	this.bezierCurves[ curveIndex + 1 ] = newRight;
-	
-	// Update total arc length, even if there is only a very little change!
-	this.totalArcLength -= oldCurve.getLength();
-	this.totalArcLength += newLeft.getLength();
-	this.totalArcLength += newRight.getLength();
-
-	return true;
-    };
-    */
-
-  /*
-    insertVertexAt( t:number ) : void {
-	console.log('Inserting vertex at', t );
-	// Find the curve index
-	var u : number = 0;
-	var curveIndex : number = -1;
-	var localT : number = 0.0;
-	for( var i = 0; curveIndex == -1 && i < this.bezierCurves.length; i++ ) {
-	    
-	}
-    }; */
-
   /**
    * Move the whole bezier path by the given (x,y)-amount.
    *
@@ -551,24 +342,6 @@ export class BezierPath implements SVGSerializable {
    * @return {BezierPath} this for chaining.
    **/
   scale(anchor: Vertex, scaleFactor: number): BezierPath {
-    // var scaleFactors : XYCoords = { x : scaleFactor, y : scaleFactor };
-    // for (var i = 0; i < this.bezierCurves.length; i++) {
-    //   var curve = this.bezierCurves[i];
-    //   curve.getStartPoint().scale(scaleFactor, anchor);
-    //   curve.getStartControlPoint().scale(scaleFactor, anchor);
-    //   curve.getEndControlPoint().scale(scaleFactor, anchor);
-    //   // Do NOT scale the end point here!
-    //   // Don't forget that the curves are connected and on curve's end point
-    //   // the the successor's start point (same instance)!
-    // }
-
-    // // Finally move the last end point (was not scaled yet)
-    // if (this.bezierCurves.length > 0 && !this.adjustCircular) {
-    //   this.bezierCurves[this.bezierCurves.length - 1].getEndPoint().scale(scaleFactor, anchor);
-    // }
-
-    // this.updateArcLengths();
-    // return this;
     return this.scaleXY({ x: scaleFactor, y: scaleFactor }, anchor);
   }
 
@@ -1132,7 +905,7 @@ export class BezierPath implements SVGSerializable {
    * @return {BezierPath}
    **/
   clone(): BezierPath {
-    var path: BezierPath = new BezierPath(undefined);
+    var path: BezierPath = new BezierPath(); // undefined);
     for (var i = 0; i < this.bezierCurves.length; i++) {
       path.bezierCurves.push(this.bezierCurves[i].clone());
       // Connect splines
@@ -1168,6 +941,10 @@ export class BezierPath implements SVGSerializable {
    * This function should invalidate any installed listeners and invalidate this object.
    * After calling this function the object might not hold valid data any more and
    * should not be used.
+   *
+   * @method destroy
+   * @instance
+   * @memberof BezierPath
    */
   destroy() {
     for (var i = 0; i < this.bezierCurves.length; i++) {
@@ -1176,6 +953,42 @@ export class BezierPath implements SVGSerializable {
     this.isDestroyed = true;
   }
 
+  /**
+   * Convert this path to an array of path points that can be drawn by the default DrawLib
+   * implementations.
+   *
+   * @method toPathPoints
+   * @instance
+   * @memberof BezierPath
+   * @return {Array<XYCoords>}
+   */
+  toPathPoints(): Array<XYCoords> {
+    if (this.bezierCurves.length === 0) {
+      return [];
+    }
+    if (this.bezierCurves.length === 1) {
+      return [
+        this.bezierCurves[0].startPoint,
+        this.bezierCurves[0].startControlPoint,
+        this.bezierCurves[0].endControlPoint,
+        this.bezierCurves[0].endPoint
+      ];
+    }
+    const arr: Array<XYCoords> = [];
+    arr.push(this.bezierCurves[0].startPoint);
+    arr.push(this.bezierCurves[0].startControlPoint);
+    for (var i = 1; i < this.bezierCurves.length; i++) {
+      arr.push(this.bezierCurves[i - 1].endControlPoint);
+      arr.push(this.bezierCurves[i - 1].endPoint);
+      arr.push(this.bezierCurves[i].startPoint);
+      arr.push(this.bezierCurves[i].startControlPoint);
+    }
+    arr.push(this.bezierCurves[0].endControlPoint);
+    arr.push(this.bezierCurves[0].endPoint);
+
+    return arr;
+  }
+
   /**
    * Create a JSON string representation of this bézier curve.
    *
@@ -1215,6 +1028,21 @@ export class BezierPath implements SVGSerializable {
     return BezierPath.fromArray(obj);
   }
 
+  /**
+   * Construct a new path with a single curve. Adding more curves is always possible.
+   *
+   * @method fromCurve
+   * @param {CubicBezierCurve} curve - The curve to construct a new path from.
+   * @static
+   * @memberof BezierPath
+   * @return {BezierPath} The constructed bezier path instance.
+   */
+  static fromCurve(curve: CubicBezierCurve): BezierPath {
+    const path = new BezierPath(); // []);
+    path.addCurve(curve);
+    return path;
+  }
+
   /**
    * Create a BezierPath instance from the given array.
    *
@@ -1225,16 +1053,19 @@ export class BezierPath implements SVGSerializable {
    * @memberof BezierPath
    * @return {BezierPath} The bezier path instance retrieved from the array data.
    **/
-  static fromArray(obj: any) {
-    if (!Array.isArray(obj)) throw "[BezierPath.fromArray] Passed object must be an array.";
+  static fromArray(obj: any): BezierPath {
+    if (!Array.isArray(obj)) {
+      throw "[BezierPath.fromArray] Passed object must be an array.";
+    }
 
     const arr: Array<any> = obj as Array<Array<Vertex>>; // FORCE?
 
-    if (arr.length < 1)
+    if (arr.length < 1) {
       throw "[BezierPath.fromArray] Passed array must contain at least one bezier curve (has " + arr.length + ").";
+    }
 
     // Create an empty bezier path
-    var bPath: BezierPath = new BezierPath(undefined);
+    var bPath: BezierPath = new BezierPath(); // undefined);
     var lastCurve: CubicBezierCurve | null = null;
     for (var i = 0; i < arr.length; i++) {
       // Convert object (or array?) to bezier curve
@@ -1352,7 +1183,7 @@ export class BezierPath implements SVGSerializable {
    */
   static fromReducedList(pointArray: Array<number>, adjustCircular?: boolean): BezierPath {
     // Convert to object
-    var bezierPath: BezierPath = new BezierPath(null); // No points yet
+    var bezierPath: BezierPath = new BezierPath(); // null); // No points yet
 
     var startPoint: Vertex = new Vertex();
     var startControlPoint: Vertex;

package/src/ts/Bounds.ts

@@ -8,12 +8,14 @@
  * @modified 2022-02-01 Added the `toString` function.
  * @modified 2022-10-09 Added the `fromDimension` function.
  * @modified 2022-11-28 Added the `clone` method.
- * @version  1.6.0
+ * @modified 2023-09-29 Added the `randomPoint` method.
+ * @version  1.7.0
  **/
 
 import { Polygon } from "./Polygon";
 import { XYCoords, IBounds, XYDimension } from "./interfaces";
 import { Vertex } from "./Vertex";
+import { VertTuple } from "./VertTuple";
 
 /**
  * @classdesc A bounds class with min and max values. Implementing IBounds.
@@ -97,6 +99,28 @@ export class Bounds implements IBounds, XYDimension {
     return new Vertex(this.min.x + (this.max.x - this.min.x) / 2.0, this.min.y + (this.max.y - this.min.y) / 2);
   }
 
+  /**
+   * Generate a random point inside this bounds object. Safe areas at the border to avoid
+   * included.
+   *
+   * @method randomPoint
+   * @instance
+   * @memberof Bounds
+   * @param {horizontalSafeArea} - (optional) The horizonal (left and right) safe area. No vertex will be created here. Can be used as percent in (0.0 ... 0.1) interval.
+   * @param {verticalSafeArea} - (optional) The vertical (top and bottom) safe area. No vertex will be created here. Can be used as percent in (0.0 ... 0.1) interval
+   * @returns {Vertex} A pseudo random point inside these bounds.
+   */
+  randomPoint(horizontalSafeArea: number = 0, verticalSafeArea: number = 0): Vertex {
+    // Check if the safe areas are meant as percent
+    const absHorizontalSafeArea =
+      horizontalSafeArea > 0 && horizontalSafeArea < 1 ? this.width * horizontalSafeArea : horizontalSafeArea;
+    const absVerticalSafeArea = verticalSafeArea > 0 && verticalSafeArea < 1 ? this.height * verticalSafeArea : verticalSafeArea;
+    return new Vertex(
+      this.min.x + absHorizontalSafeArea + Math.random() * (this.width - 2 * absHorizontalSafeArea),
+      this.min.y + absVerticalSafeArea + Math.random() * (this.height - 2 * absVerticalSafeArea)
+    );
+  }
+
   /**
    * Convert these bounds to a human readable form.
    *

package/src/ts/CubicBezierCurve.ts

@@ -21,7 +21,9 @@
  * @modified 2022-02-02 Added the `destroy` method.
  * @modified 2022-02-02 Cleared the `toSVGPathData` function (deprecated). Use `drawutilssvg` instead.
  * @modified 2022-10-17 The `CubicBezierCurve` class now implements the new `PathSegment` interface.
- * @version 2.7.1
+ * @modified 2023-09-30 Added the function `CubicbezierCurve.getSubCurve(number,number)` – similar to `getSubCurveAt(...)` but with absolute position parameters.
+ * @modified 2023-10-07 Added the `trimEnd`, `trimEndAt`, `trimStart`, `trimStartAt` methods.
+ * @version 2.8.0
  *
  * @file CubicBezierCurve
  * @public
@@ -523,6 +525,96 @@ export class CubicBezierCurve implements PathSegment {
     return new Vertex(tX, tY);
   }
 
+  /**
+   * Trim off a start section of this curve. The position parameter `uValue` is the absolute position on the
+   * curve in `[0...arcLength]`.
+   * The remaining curve will be the one in the bounds `[uValue,1]` (so `[0.0,uValue]` is cut off).
+   *
+   * Note this function just converts the absolute parameter to a relative one and call `trimStartAt`.
+   *
+   * @method trimStart
+   * @instance
+   * @memberof CubicBezierCurve
+   * @param {number} uValue - The absolute position parameter where to cut off the head curve.
+   * @returns {CubicBezierCurve} `this` for chanining.
+   */
+  trimStart(uValue: number): CubicBezierCurve {
+    return this.trimStartAt(this.convertU2T(uValue));
+  }
+
+  /**
+   * Trim off a start section of this curve. The position parameter `t` is the relative position in [0..1].
+   * The remaining curve will be the one in the bounds `[uValue,1]` (so `[0.0,uValue]` is cut off).
+   *
+   * @method trimStartAt
+   * @instance
+   * @memberof CubicBezierCurve
+   * @param {number} t - The relative position parameter where to cut off the head curve.
+   * @returns {CubicBezierCurve} `this` for chanining.
+   */
+  trimStartAt(t: number): CubicBezierCurve {
+    const subCurbePoints = CubicBezierCurve.utils.getSubCurvePointsAt(this, t, 1.0);
+    this.startPoint.set(subCurbePoints[0]);
+    this.startControlPoint.set(subCurbePoints[2]);
+    this.endPoint.set(subCurbePoints[1]);
+    this.endControlPoint.set(subCurbePoints[3]);
+    this.updateArcLengths();
+    return this;
+  }
+
+  /**
+   * Trim off the end of this curve. The position parameter `uValue` is the absolute position on the
+   * curve in `[0...arcLength]`.
+   * The remaining curve will be the one in the bounds `[0,uValue]` (so `[1.0-uValue,1.0]` is cut off).
+   *
+   * Note this function just converts the absolute parameter to a relative one and call `trimEndAt`.
+   *
+   * @method trimEnd
+   * @instance
+   * @memberof CubicBezierCurve
+   * @param {number} uValue - The absolute position parameter where to cut off the tail curve.
+   * @returns {CubicBezierCurve} `this` for chanining.
+   */
+  trimEnd(uValue: number): CubicBezierCurve {
+    return this.trimEndAt(this.convertU2T(uValue));
+  }
+
+  /**
+   * Trim off the end of this curve. The position parameter `t` is the relative position in [0..1].
+   * The remaining curve will be the one in the bounds `[0,t]` (so `[1.0-t,1.0]` is cut off).
+   *
+   * @method trimEndAt
+   * @instance
+   * @memberof CubicBezierCurve
+   * @param {number} t - The relative position parameter where to cut off the tail curve.
+   * @returns {CubicBezierCurve} `this` for chanining.
+   */
+  trimEndAt(t: number): CubicBezierCurve {
+    const subCurbePoints = CubicBezierCurve.utils.getSubCurvePointsAt(this, 0.0, t);
+    this.startPoint.set(subCurbePoints[0]);
+    this.startControlPoint.set(subCurbePoints[2]);
+    this.endPoint.set(subCurbePoints[1]);
+    this.endControlPoint.set(subCurbePoints[3]);
+    this.updateArcLengths();
+    return this;
+  }
+
+  /**
+   * Get a sub curve at the given start end end positions (values on the curve's length, between 0 and curve.arcLength).
+   *
+   * tStart >= tEnd is allowed, you will get a reversed sub curve then.
+   *
+   * @method getSubCurve
+   * @param {number} tStart – The start position of the desired sub curve (must be in [0..arcLength]).
+   * @param {number} tEnd – The end position if the desired cub curve (must be in [0..arcLength]).
+   * @instance
+   * @memberof CubicBezierCurve
+   * @return {CubicBezierCurve} The sub curve as a new curve.
+   **/
+  getSubCurve(uStart: number, uEnd: number): CubicBezierCurve {
+    return this.getSubCurveAt(this.convertU2T(uStart), this.convertU2T(uEnd));
+  }
+
   /**
    * Get a sub curve at the given start end end offsets (values between 0.0 and 1.0).
    *
@@ -536,20 +628,22 @@ export class CubicBezierCurve implements PathSegment {
    * @return {CubicBezierCurve} The sub curve as a new curve.
    **/
   getSubCurveAt(tStart: number, tEnd: number): CubicBezierCurve {
-    const startVec: Vector = new Vector(this.getPointAt(tStart), this.getTangentAt(tStart));
-    const endVec: Vector = new Vector(this.getPointAt(tEnd), this.getTangentAt(tEnd).inv());
+    // const startVec: Vector = new Vector(this.getPointAt(tStart), this.getTangentAt(tStart));
+    // const endVec: Vector = new Vector(this.getPointAt(tEnd), this.getTangentAt(tEnd).inv());
 
-    // Tangents are relative. Make absolute.
-    startVec.b.add(startVec.a);
-    endVec.b.add(endVec.a);
+    // // Tangents are relative. Make absolute.
+    // startVec.b.add(startVec.a);
+    // endVec.b.add(endVec.a);
 
-    // This 'splits' the curve at the given point at t.
-    startVec.scale(0.33333333 * (tEnd - tStart));
-    endVec.scale(0.33333333 * (tEnd - tStart));
+    // // This 'splits' the curve at the given point at t.
+    // startVec.scale(0.33333333 * (tEnd - tStart));
+    // endVec.scale(0.33333333 * (tEnd - tStart));
 
-    // Draw the bezier curve
-    // pb.draw.cubicBezier( startVec.a, endVec.a, startVec.b, endVec.b, '#8800ff', 2 );
-    return new CubicBezierCurve(startVec.a, endVec.a, startVec.b, endVec.b);
+    // // Draw the bezier curve
+    // // pb.draw.cubicBezier( startVec.a, endVec.a, startVec.b, endVec.b, '#8800ff', 2 );
+    // return new CubicBezierCurve(startVec.a, endVec.a, startVec.b, endVec.b);
+    const subCurbePoints = CubicBezierCurve.utils.getSubCurvePointsAt(this, tStart, tEnd);
+    return new CubicBezierCurve(subCurbePoints[0], subCurbePoints[1], subCurbePoints[2], subCurbePoints[3]);
   }
 
   /**
@@ -813,4 +907,37 @@ export class CubicBezierCurve implements PathSegment {
     if (arr.length != 4) throw "Can only build from array with four elements.";
     return new CubicBezierCurve(arr[0], arr[1], arr[2], arr[3]);
   }
+
+  /**
+   * Helper utils.
+   */
+  private static utils = {
+    /**
+     * Get the points of a sub curve at the given start end end offsets (values between 0.0 and 1.0).
+     *
+     * tStart >= tEnd is allowed, you will get a reversed sub curve then.
+     *
+     * @method getSubCurvePointsAt
+     * @param {CubicBezierCurve} curve – The curve to get the sub curve points from.
+     * @param {number} tStart – The start offset of the desired sub curve (must be in [0..1]).
+     * @param {number} tEnd – The end offset if the desired cub curve (must be in [0..1]).
+     * @instance
+     * @memberof CubicBezierCurve
+     * @return {CubicBezierCurve} The sub curve as a new curve.
+     **/
+    getSubCurvePointsAt: (curve: CubicBezierCurve, tStart: number, tEnd: number): [Vertex, Vertex, Vertex, Vertex] => {
+      const startVec: Vector = new Vector(curve.getPointAt(tStart), curve.getTangentAt(tStart));
+      const endVec: Vector = new Vector(curve.getPointAt(tEnd), curve.getTangentAt(tEnd).inv());
+
+      // Tangents are relative. Make absolute.
+      startVec.b.add(startVec.a);
+      endVec.b.add(endVec.a);
+
+      // This 'splits' the curve at the given point at t.
+      startVec.scale(0.33333333 * (tEnd - tStart));
+      endVec.scale(0.33333333 * (tEnd - tStart));
+
+      return [startVec.a, endVec.a, startVec.b, endVec.b];
+    }
+  };
 }

package/src/ts/Line.ts

@@ -15,6 +15,7 @@
  * @modified 2022-02-02 Added the `destroy` method.
  * @modified 2022-10-09 Changed the actual return value of the `intersection` function to null (was undefined before).
  * @modified 2022-10-17 Adding these methods from the `PathSegment` interface: getStartPoint, getEndPoint, revert.
+ * @modified 2023-09-25 Changed param type of `intersection()` from Line to VertTuple.
  * @version  2.3.0
  *
  * @file Line
@@ -61,7 +62,7 @@ export class Line extends VertTuple<Line> implements SVGSerializable, PathSegmen
    * @memberof Line
    **/
   // !!! DO NOT MOVE TO VertTuple
-  intersection(line: Line): Vertex | null {
+  intersection(line: VertTuple<any>): Vertex | null {
     const denominator: number = this.denominator(line);
     if (denominator == 0) {
       return null;

package/src/ts/PBText.ts

@@ -2,7 +2,8 @@
  * @author   Ikaros Kappler
  * @date     2021-11-16
  * @modified 2022-02-02 Added the `destroy` method.
- * @version  1.1.0
+ * @modified 2023-09-25 Fixed a type error in the constructor. Nothing vital.
+ * @version  1.1.1
  **/
 
 import { UIDGenerator } from "./UIDGenerator";
@@ -127,14 +128,14 @@ export class PBText implements SVGSerializable, FontOptions {
     this.uid = UIDGenerator.next();
     this.text = text;
     this.anchor = anchor ?? new Vertex();
-    this.color = options.color;
-    this.fontFamily = options.fontFamily;
-    this.fontSize = options.fontSize;
-    this.fontStyle = options.fontStyle;
-    this.fontWeight = options.fontWeight;
-    this.lineHeight = options.lineHeight;
-    this.textAlign = options.textAlign;
-    this.rotation = options.rotation;
+    this.color = options?.color;
+    this.fontFamily = options?.fontFamily;
+    this.fontSize = options?.fontSize;
+    this.fontStyle = options?.fontStyle;
+    this.fontWeight = options?.fontWeight;
+    this.lineHeight = options?.lineHeight;
+    this.textAlign = options?.textAlign;
+    this.rotation = options?.rotation;
   }
 
   /**