plotboilerplate 1.28.1 → 1.30.0

package/dist/plotboilerplate.js

@@ -1742,7 +1742,16 @@ exports.Bounds = Bounds;
  * @modified 2022-08-23 Added the `closestPoint` function.
  * @modified 2025-04-09 Added the `Circle.move(amount: XYCoords)` method.
  * @modified 2025-04-16 Class `Circle` now implements interface `Intersectable`.
- * @version  1.5.0
+ * @modified 2026-06-10 Adding the utility function `Circle.circleUtils.containsPoint`.
+ * @modified 2026-06-10 Adding the `Circle.clone` method.
+ * @modified 2026-01-13 Adding helper function `Circle.circleUtils.containsPoint` and refactored the member method `containsPoint`.
+ * @modified 2026-07-03 Adding the optional `epsilon` parameter to the `Circle.containsCircle` method.
+ * @modified 2026-07-03 Fixing the `Circle.clone` method; the center had not been cloned at all, this was fixed.
+ * @modified 2026-07-08 Adding the `Circle.setRadius` method (for chaining).
+ * @mofified 2026-07-31 Adding the `radicalAxis(Circle)` method. Added the `Circle.circleUtils.createRadicalAxisHelperCircle` and `.circleDistance` helper methods.
+ * @modified 2026-08-03 Adding `Circle.tangentsFromPoint`.
+ * @modified 2026-08-16 Adding the `Circle.sectorAngleByArcLength` method and the `Circle.circleUtils.sectorAngleByArcLength` helper method.
+ * @version  1.8.0
  **/
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Circle = void 0;
@@ -1751,6 +1760,7 @@ var Line_1 = __webpack_require__(939);
 var UIDGenerator_1 = __webpack_require__(938);
 var Vector_1 = __webpack_require__(30);
 var Vertex_1 = __webpack_require__(787);
+var geomutils_1 = __webpack_require__(328);
 /**
  * @classdesc A simple circle: center point and radius.
  *
@@ -1780,6 +1790,20 @@ var Circle = /** @class */ (function () {
         this.center = center;
         this.radius = radius;
     }
+    /**
+     * Set the radius of this circle.
+     * The method is meant for chaining, you may also alter the `radius` attribute directly.
+     *
+     * @method setRadius
+     * @param {number} radius - The amount to move.
+     * @instance
+     * @memberof Circle
+     * @return {Circle} this for chaining
+     **/
+    Circle.prototype.setRadius = function (radius) {
+        this.radius = radius;
+        return this;
+    };
     /**
      * Move the circle by the given amount.
      *
@@ -1803,7 +1827,8 @@ var Circle = /** @class */ (function () {
      * @return {boolean} `true` if the given point is inside this circle.
      */
     Circle.prototype.containsPoint = function (point) {
-        return this.center.distance(point) < this.radius;
+        // return this.center.distance(point) < this.radius;//
+        return Circle.circleUtils.containsPoint(this.center, this.radius, point);
     };
     /**
      * Check if the given circle is fully contained inside this circle.
@@ -1814,8 +1839,13 @@ var Circle = /** @class */ (function () {
      * @memberof Circle
      * @return {boolean} `true` if any only if the given circle is completely inside this circle.
      */
-    Circle.prototype.containsCircle = function (circle) {
-        return this.center.distance(circle.center) + circle.radius < this.radius;
+    Circle.prototype.containsCircle = function (circle, epsilon) {
+        if (typeof epsilon === "undefined" || Number.isNaN(epsilon)) {
+            return this.center.distance(circle.center) + circle.radius < this.radius;
+        }
+        else {
+            return this.center.distance(circle.center) + circle.radius < this.radius + Math.abs(epsilon);
+        }
     };
     /**
      * Calculate the distance from this circle to the given line.
@@ -2021,6 +2051,40 @@ var Circle = /** @class */ (function () {
         });
     };
     //--- END --- Implement interface `Intersectable`
+    /**
+     * Calculate the radical axis of this and a different circle.
+     * The two circles must not be co-centric.
+     *
+     * See this article for details:
+     *    https://www.cut-the-knot.org/Curriculum/Geometry/GeoGebra/RadicalAxes.shtml
+     *
+     * @method radicalAxis
+     * @instance
+     * @memberof Circle
+     * @param {Circle} circleB - The second circle to calculated the radical axis for.
+     * @return {Line} A line defining the radical axis of the two circles.
+     **/
+    Circle.prototype.radicalAxis = function (circleB) {
+        var helperCircle = Circle.circleUtils.createRadicalAxisHelperCircle(this, circleB);
+        var intersectionLineA = this.circleIntersection(helperCircle);
+        var intersectionLineB = circleB.circleIntersection(helperCircle);
+        var intersection = this.circleIntersection(circleB);
+        if (!intersectionLineA || !intersectionLineB) {
+            console.error("Critical error: none of the two intersections must be null.");
+            return intersection; // Fallback
+        }
+        var lineA = new Line_1.Line(intersectionLineA.a, intersectionLineA.b);
+        var lineB = new Line_1.Line(intersectionLineB.a, intersectionLineB.b);
+        var firstRadicalAxisPoint = lineA.intersection(lineB);
+        var centerConnectLine = new Line_1.Line(this.center, circleB.center);
+        var secondRadicalAxisPoint = centerConnectLine.getClosestPoint(firstRadicalAxisPoint);
+        // Create a mirrored version of the second radical axis point so both are located
+        // symmetrical from the circle connect point.
+        // (currently the second point is located ON the connect line)
+        var secondRadicalAxisPoint_mirrored = secondRadicalAxisPoint.clone().scale(2.0, firstRadicalAxisPoint);
+        var radicalAxis = new Line_1.Line(firstRadicalAxisPoint, secondRadicalAxisPoint_mirrored);
+        return intersection && intersection.length() > radicalAxis.length() ? intersection : radicalAxis;
+    };
     /**
      * Calculate the closest point on the outline of this circle to the given point.
      *
@@ -2044,6 +2108,80 @@ var Circle = /** @class */ (function () {
             return lineIntersection.b;
         }
     };
+    /**
+     * Get the two tangent vectors for the given point.
+     * If the point is on or in the circle then null is returned.
+     *
+     * @method tangentsFromPoint
+     * @instance
+     * @memberof Circle
+     * @param {Vertex} vert - The point to find the two tangents for.
+     * @return {[Vector,Vector]} The two tangent vector
+     **/
+    Circle.prototype.tangentsFromPoint = function (vert) {
+        // Inspired by
+        //   https://www.omnicalculator.com/math/tangent-circle
+        var centerDistance = this.center.distance(vert);
+        var tangentLength = Math.sqrt(centerDistance * centerDistance - this.radius * this.radius);
+        // console.log("this.radius ", this.radius, "centerDistance", centerDistance, "tangentLength", tangentLength);
+        if (Number.isNaN(tangentLength)) {
+            // vertex is inside circle
+            console.log("tangentLength is NaN", tangentLength);
+            return null;
+        }
+        var helperCircle = new Circle(vert, tangentLength);
+        var intersection = this.circleIntersection(helperCircle);
+        if (!intersection) {
+            // No intersection (vertex is inside circle)
+            return null;
+        }
+        return [new Vector_1.Vector(intersection.a, vert), new Vector_1.Vector(intersection.b, vert)];
+    };
+    /**
+     * Calculate inner sector angle for this circle and a given circle arc length.
+     *
+     * @param {number} sectorArcLength - The desired arc length (in units).
+     * @returns The sector's inner angle (in radians).
+     */
+    Circle.prototype.sectorAngleByArcLength = function (sectorArcLength) {
+        return Circle.circleUtils.sectorAngleByArcLength(sectorArcLength, this.radius);
+    };
+    /**
+     * Create a deep copy of this circle.
+     *
+     * @method clone
+     * @return {Circle} A new circle, an exact copy of this one.
+     * @instance
+     * @memberof Circle
+     **/
+    Circle.prototype.clone = function () {
+        return new Circle(this.center.clone(), this.radius);
+    };
+    Circle.fromICircle = function (obj) {
+        return new Circle(new Vertex_1.Vertex(obj.center), obj.radius);
+    };
+    // static fromObject(obj: object): Circle {
+    //   if (!obj) {
+    //     return null;
+    //   }
+    //   if (typeof obj !== "object") {
+    //     return null;
+    //   }
+    //   if (!obj.hasOwnProperty("center") || typeof (obj as any).center != "object") {
+    //     return null;
+    //   }
+    //   if (!obj.hasOwnProperty("radius") || typeof !(obj as any).radius != "number") {
+    //     return null;
+    //   }
+    //   var center = (obj as any).center;
+    //   if (!center.hasOwnProperty("x") || typeof (center as any).x != "number") {
+    //     return null;
+    //   }
+    //   if (!center.hasOwnProperty("y") || typeof (center as any).y != "number") {
+    //     return null;
+    //   }
+    //   return new Circle(new Vertex(center), (obj as any).radius);
+    // }
     /**
      * 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
@@ -2058,6 +2196,43 @@ var Circle = /** @class */ (function () {
             /* return new Vertex( Math.sin(angle) * radius,
                          Math.cos(angle) * radius ); */
             return new Vertex_1.Vertex(Math.cos(angle) * radius, Math.sin(angle) * radius);
+        },
+        containsPoint: function (circleCenter, circleRadius, point) {
+            // TODO: cleanup
+            // return (
+            //   (circle.center.x - point.x) * (circle.center.x - point.x) + (circle.center.y - point.y) * (circle.center.y - point.y) <=
+            //   circle.radius * circle.radius
+            // );
+            return geomutils_1.geomutils.dist4(point.x, point.y, circleCenter.x, circleCenter.y) < circleRadius;
+        },
+        createRadicalAxisHelperCircle: function (circleA, circleB) {
+            // We need to create a helper circle that intersects BOTH other circles,
+            // each in TWO points.
+            var circleConnectLine = new Vector_1.Vector(circleA.center.clone(), circleB.center);
+            circleConnectLine.a.set(circleConnectLine.vertAt(0.5));
+            // Get the perpendicular by half the circle distance.
+            var bisector = circleConnectLine.perp();
+            var bisectorLength = Math.max(circleA.radius, circleB.radius, bisector.length());
+            bisector.setLength(bisectorLength);
+            return new Circle(bisector.b, bisector.b.distance(circleA.center));
+        },
+        /**
+         * Calculate the outer distance between two circles. If the circles touch then the
+         * distance is 0.0.
+         * If the circles intersect then the distance in negative.
+         */
+        circleDistance: function (circleA, circleB) {
+            return circleA.center.distance(circleB.center) - circleA.radius - circleB.radius;
+        },
+        /**
+         * Calculate the inner sector angle for a given circle arc length and radius.
+         *
+         * @param {number} sectorArcLength - The desired arc length.
+         * @param {number} circleRadius - The circle's radius.
+         * @returns The sector angle in radians.
+         */
+        sectorAngleByArcLength: function (sectorArcLength, circleRadius) {
+            return sectorArcLength / circleRadius;
         }
     };
     return Circle;
@@ -8122,12 +8297,15 @@ exports["default"] = PlotBoilerplate;
  * @modified 2025-03-31 Added the `VertTuple.revert` method.
  * @modified 2025-04-15 Changed param of `VertTuple.moveTo` method from `Vertex` to `XYCoords`.
  * @modified 2025-04-15 Added method `VertTuple.move` method.
- * @version 1.4.0
+ * @modified 2026-06-10 Adding helper function `VertTuple.utils.calcCircumcircle`.
+ * @modified 2026-06-17 Adding method `VertTuple.asLine` for converting Vector to Line instances.
+ * @version 1.6.0
  */
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.VertTuple = void 0;
 var Vertex_1 = __webpack_require__(787);
 var UIDGenerator_1 = __webpack_require__(938);
+var Line_1 = __webpack_require__(939);
 /**
  * @classdesc An abstract base classes for vertex tuple constructs, like Lines or Vectors.
  * @abstract
@@ -8410,7 +8588,7 @@ var VertTuple = /** @class */ (function () {
     /**
      * Create a deep clone of this instance.
      *
-     * @method cloneLine
+     * @method clone
      * @return {T} A type safe clone if this instance.
      * @instance
      * @memberof VertTuple
@@ -8418,6 +8596,17 @@ var VertTuple = /** @class */ (function () {
     VertTuple.prototype.clone = function () {
         return this.factory(this.a.clone(), this.b.clone());
     };
+    /**
+     * Converts this `Vector` to a `Line` (segment).
+     *
+     * @method asLine
+     * @return {T} A type safe clone if this instance.
+     * @instance
+     * @memberof VertTuple
+     **/
+    VertTuple.prototype.asLine = function () {
+        return new Line_1.Line(this.a, this.b);
+    };
     /**
      * Create a string representation of this line.
      *
@@ -8445,6 +8634,10 @@ var VertTuple = /** @class */ (function () {
     VertTuple.vtutils = {
         dist2: function (v, w) {
             return (v.x - w.x) * (v.x - w.x) + (v.y - w.y) * (v.y - w.y);
+        },
+        calcCircumcircle: function (p1, p2) {
+            var p1x = p1.x, p1y = p1.y, p2x = p2.x, p2y = p2.y, cx = 0.5 * (p1x + p2x), cy = 0.5 * (p1y + p2y);
+            return { center: { x: cx, y: cy }, radius: Math.sqrt((p1x - cx) * (p1x - cx) + (p1y - cy) * (p1y - cy)) };
         }
     };
     return VertTuple;
@@ -11479,7 +11672,10 @@ exports.BezierPath = BezierPath;
  * @modified  2025-14-16 Class `Triangle` now implements interface `IBounded`.
  * @modified  2025-14-16 Class `Triangle` now implements interface `Intersectable`.
  * @modified  2025-14-16 Added method `Triangle.move`.
- * @version   2.10.0
+ * @modified  2026-06-10 Refactoring the `Trianble.bounds` method and added a plain `Triangle.utils.bounds` method.
+ * @modified  2026-06-10 Refactoring the `Trianble.calcCircumCircle` method and added a plain `Triangle.utils.calcCircumCircle` method.
+ * @modified  2026-06-13 Adding `Triangle.getVertices()`.
+ * @version   2.11.0
  *
  * @file Triangle
  * @fileoverview A simple triangle class: three vertices.
@@ -11493,6 +11689,7 @@ var Line_1 = __webpack_require__(939);
 var Polygon_1 = __webpack_require__(687);
 var UIDGenerator_1 = __webpack_require__(938);
 var Vector_1 = __webpack_require__(30);
+var VertTuple_1 = __webpack_require__(590);
 var Vertex_1 = __webpack_require__(787);
 var geomutils_1 = __webpack_require__(328);
 /**
@@ -11634,7 +11831,7 @@ var Triangle = /** @class */ (function () {
      * after triangle vertex changes.
      *
      * @method getCircumcircle
-     * @return {Object} - { center:Vertex, radius:float }
+     * @return {Circle} - The circle touching exactly all three triangle vertices.
      * @instance
      * @memberof Triangle
      */
@@ -11643,6 +11840,33 @@ var Triangle = /** @class */ (function () {
         this.calcCircumcircle();
         return new Circle_1.Circle(this.center.clone(), this.radius);
     };
+    /**
+     * Calculates the minimun enclosing circle.
+     *
+     * @method getMinimumEnclosingCircle
+     * @return {Object} - { center:Vertex, radius:float }
+     * @instance
+     * @memberof Triangle
+     * @returns
+     */
+    Triangle.prototype.getMinimumEnclosingCircle = function () {
+        // First option: two points construct a circle and the third point is contained.
+        var circleAB = VertTuple_1.VertTuple.vtutils.calcCircumcircle(this.a, this.b);
+        if (Circle_1.Circle.circleUtils.containsPoint(circleAB.center, circleAB.radius, this.c)) {
+            return Circle_1.Circle.fromICircle(circleAB);
+        }
+        var circleBC = VertTuple_1.VertTuple.vtutils.calcCircumcircle(this.b, this.c);
+        if (Circle_1.Circle.circleUtils.containsPoint(circleBC.center, circleBC.radius, this.c)) {
+            return Circle_1.Circle.fromICircle(circleBC);
+        }
+        var circleCA = VertTuple_1.VertTuple.vtutils.calcCircumcircle(this.c, this.a);
+        if (Circle_1.Circle.circleUtils.containsPoint(circleCA.center, circleCA.radius, this.c)) {
+            return Circle_1.Circle.fromICircle(circleCA);
+        }
+        // If none of the three upper cases applies: return the circumcircle.
+        var circumCircle = Triangle.utils.calcCircumcircle(this.a, this.b, this.c);
+        return Circle_1.Circle.fromICircle(circumCircle);
+    };
     /**
      * Check if this triangle and the passed triangle share an
      * adjacent edge.
@@ -11681,6 +11905,17 @@ var Triangle = /** @class */ (function () {
         //if( this.c.equals(vert1) && this.a.equals(vert2) || this.c.equals(vert2) && this.a.equals(vert1) )
         return this.b;
     };
+    /**
+     * Get the three triangele vertices in a 3-element array.
+     *
+     * @method getVertices
+     * @returns {[Vertex, Vertex, Vertex]} - The three vertices – real instances, not copies.
+     * @instance
+     * @memberof Triangle
+     */
+    Triangle.prototype.getVertices = function () {
+        return [this.a, this.b, this.c];
+    };
     /**
      * Re-compute the circumcircle of this triangle (if the vertices
      * have changed).
@@ -11694,32 +11929,35 @@ var Triangle = /** @class */ (function () {
      * @memberof Triangle
      */
     Triangle.prototype.calcCircumcircle = function () {
-        // From
-        //    http://www.exaflop.org/docs/cgafaq/cga1.html
-        var A = this.b.x - this.a.x;
-        var B = this.b.y - this.a.y;
-        var C = this.c.x - this.a.x;
-        var D = this.c.y - this.a.y;
-        var E = A * (this.a.x + this.b.x) + B * (this.a.y + this.b.y);
-        var F = C * (this.a.x + this.c.x) + D * (this.a.y + this.c.y);
-        var G = 2.0 * (A * (this.c.y - this.b.y) - B * (this.c.x - this.b.x));
-        var dx, dy;
-        if (Math.abs(G) < Triangle.EPSILON) {
-            // Collinear - find extremes and use the midpoint
-            var bounds = this.bounds();
-            this.center = new Vertex_1.Vertex((bounds.min.x + bounds.max.x) / 2, (bounds.min.y + bounds.max.y) / 2);
-            dx = this.center.x - bounds.min.x;
-            dy = this.center.y - bounds.min.y;
-        }
-        else {
-            var cx = (D * E - B * F) / G;
-            var cy = (A * F - C * E) / G;
-            this.center = new Vertex_1.Vertex(cx, cy);
-            dx = this.center.x - this.a.x;
-            dy = this.center.y - this.a.y;
-        }
-        this.radius_squared = dx * dx + dy * dy;
-        this.radius = Math.sqrt(this.radius_squared);
+        // // From
+        // //    http://www.exaflop.org/docs/cgafaq/cga1.html
+        // const A: number = this.b.x - this.a.x;
+        // const B: number = this.b.y - this.a.y;
+        // const C: number = this.c.x - this.a.x;
+        // const D: number = this.c.y - this.a.y;
+        // const E: number = A * (this.a.x + this.b.x) + B * (this.a.y + this.b.y);
+        // const F: number = C * (this.a.x + this.c.x) + D * (this.a.y + this.c.y);
+        // const G: number = 2.0 * (A * (this.c.y - this.b.y) - B * (this.c.x - this.b.x));
+        // let dx: number, dy: number;
+        // if (Math.abs(G) < Triangle.EPSILON) {
+        //   // Collinear - find extremes and use the midpoint
+        //   const bounds: Bounds = this.bounds();
+        //   this.center = new Vertex((bounds.min.x + bounds.max.x) / 2, (bounds.min.y + bounds.max.y) / 2);
+        //   dx = this.center.x - bounds.min.x;
+        //   dy = this.center.y - bounds.min.y;
+        // } else {
+        //   const cx: number = (D * E - B * F) / G;
+        //   const cy: number = (A * F - C * E) / G;
+        //   this.center = new Vertex(cx, cy);
+        //   dx = this.center.x - this.a.x;
+        //   dy = this.center.y - this.a.y;
+        // }
+        // this.radius_squared = dx * dx + dy * dy;
+        // this.radius = Math.sqrt(this.radius_squared);
+        var tmpCircle = Triangle.utils.calcCircumcircle(this.a, this.b, this.c);
+        this.center = new Vertex_1.Vertex(tmpCircle.center.x, tmpCircle.center.y);
+        this.radius = tmpCircle.radius;
+        this.radius_squared = tmpCircle.radius_squared;
     }; // END calcCircumcircle
     /**
      * Check if the passed vertex is inside this triangle's
@@ -11746,7 +11984,11 @@ var Triangle = /** @class */ (function () {
      * @memberof Triangle
      */
     Triangle.prototype.bounds = function () {
-        return new Bounds_1.Bounds(new Vertex_1.Vertex(Triangle.utils.min3(this.a.x, this.b.x, this.c.x), Triangle.utils.min3(this.a.y, this.b.y, this.c.y)), new Vertex_1.Vertex(Triangle.utils.max3(this.a.x, this.b.x, this.c.x), Triangle.utils.max3(this.a.y, this.b.y, this.c.y)));
+        // return new Bounds(
+        //   new Vertex(Triangle.utils.min3(this.a.x, this.b.x, this.c.x), Triangle.utils.min3(this.a.y, this.b.y, this.c.y)),
+        //   new Vertex(Triangle.utils.max3(this.a.x, this.b.x, this.c.x), Triangle.utils.max3(this.a.y, this.b.y, this.c.y))
+        // );
+        return Triangle.utils.bounds(this.a, this.b, this.c);
     };
     //--- BEGIN --- Implement interface `Intersectable`
     /**
@@ -11872,8 +12114,9 @@ var Triangle = /** @class */ (function () {
      * @return Vertex The incenter of this triangle.
      **/
     Triangle.prototype.getIncenter = function () {
-        if (!this.center || !this.radius)
+        if (!this.center || !this.radius) {
             this.calcCircumcircle();
+        }
         return this.center.clone();
     };
     /**
@@ -11940,7 +12183,53 @@ var Triangle = /** @class */ (function () {
          */
         determinant: function (a, b, c) {
             return (b.y - a.y) * (c.x - b.x) - (c.y - b.y) * (b.x - a.x);
-        }
+        },
+        bounds: function (a, b, c) {
+            return new Bounds_1.Bounds(new Vertex_1.Vertex(Triangle.utils.min3(a.x, b.x, c.x), Triangle.utils.min3(a.y, b.y, c.y)), new Vertex_1.Vertex(Triangle.utils.max3(a.x, b.x, c.x), Triangle.utils.max3(a.y, b.y, c.y)));
+        },
+        /**
+         * Re-compute the circumcircle of this triangle (if the vertices
+         * have changed).
+         *
+         * The circumcenter and radius are stored in this.center and
+         * this.radius. There is a third result: radius_squared (for internal computations).
+         *
+         * @method calcCircumcircle
+         * @return void
+         * @instance
+         * @memberof Triangle
+         */
+        calcCircumcircle: function (a, b, c) {
+            // From
+            //    http://www.exaflop.org/docs/cgafaq/cga1.html
+            var A = b.x - a.x;
+            var B = b.y - a.y;
+            var C = c.x - a.x;
+            var D = c.y - a.y;
+            var E = A * (a.x + b.x) + B * (a.y + b.y);
+            var F = C * (a.x + c.x) + D * (a.y + c.y);
+            var G = 2.0 * (A * (c.y - b.y) - B * (c.x - b.x));
+            var dx, dy;
+            var center;
+            if (Math.abs(G) < Triangle.EPSILON) {
+                // Collinear - find extremes and use the midpoint
+                // const bounds: Bounds = this.bounds();
+                var bounds = Triangle.utils.bounds(a, b, c);
+                center = new Vertex_1.Vertex((bounds.min.x + bounds.max.x) / 2, (bounds.min.y + bounds.max.y) / 2);
+                dx = center.x - bounds.min.x;
+                dy = center.y - bounds.min.y;
+            }
+            else {
+                var cx = (D * E - B * F) / G;
+                var cy = (A * F - C * E) / G;
+                center = new Vertex_1.Vertex(cx, cy);
+                dx = center.x - a.x;
+                dy = center.y - a.y;
+            }
+            var radius_squared = dx * dx + dy * dy;
+            var radius = Math.sqrt(radius_squared);
+            return { center: center, radius: radius, radius_squared: radius_squared };
+        } // END calcCircumcircle
     };
     return Triangle;
 }());
@@ -11991,7 +12280,8 @@ exports.Triangle = Triangle;
  * @modified 2025-03-24 Making the second parameter `center` of the `Vertex.rotate` method optional.
  * @modified 2025-04-13 Adding the `Vertex.move(amount: XYCoords)` method (does the same as `add`, added by naming convention).
  * @modified 2025-05-07 Class `Vertex` is now implementing interface `IBounded` (to meet convention).
- * @version  2.11.0
+ * @modified 2026-06-10 Adding methods `Vertex.findClosestPoint` and `Vertex.findFarestPoint`.
+ * @version  2.12.0
  *
  * @file Vertex
  * @public
@@ -12558,6 +12848,47 @@ var Vertex = /** @class */ (function () {
         return Bounds_1.Bounds.computeFromVertices([this]);
     };
     //--- END --- Implement interface `IBounded`
+    /**
+     * Find the one of two given points that's closest to this point.
+     *
+     * @method findClosestPoint
+     * @instance
+     * @memberof Vertex
+     * @param {XYCoords | Vertex} pointA
+     * @param {XYCoords | Vertex} pointB
+     * @returns  {XYCoords | Vertex}
+     */
+    Vertex.prototype.findClosestPoint = function (pointA, pointB) {
+        // TODO: put this implementation to geomutils?
+        var distA = this.distance(pointA);
+        var distB = this.distance(pointB);
+        if (distA < distB) {
+            return pointA;
+        }
+        else {
+            return pointB;
+        }
+    };
+    /**
+     * Find the one of two given points that's farest from this point.
+     *
+     * @method findFarestPoint
+     * @instance
+     * @memberof Vertex
+     * @param {XYCoords | Vertex} pointA
+     * @param {XYCoords | Vertex} pointB
+     * @returns  {XYCoords | Vertex}
+     */
+    Vertex.prototype.findFarestPoint = function (pointA, pointB) {
+        var distA = this.distance(pointA);
+        var distB = this.distance(pointB);
+        if (distA > distB) {
+            return pointA;
+        }
+        else {
+            return pointB;
+        }
+    };
     /**
      * Get a string representation of this vertex.
      *
@@ -14066,7 +14397,8 @@ exports.UIDGenerator = UIDGenerator;
  * @modified 2023-09-25 Changed param type of `intersection()` from Line to VertTuple.
  * @modified 2025-04-15 Class `Line` now implements interface `Intersectable`.
  * @modified 2025-04-16 Class `Line` now implements interface `IBounded`.
- * @version  2.4.0
+ * @modified 2026-08-16 Adding methods `Line.trimStart` and `Line.trimEnd`. Adding methods `Line.trimStartAt` and `Line.trimEndAt`.
+ * @version  2.5.0
  *
  * @file Line
  * @public
@@ -14216,6 +14548,84 @@ var Line = /** @class */ (function (_super) {
         return this;
     };
     //--- END Implement PathSegment ---
+    /**
+     * Trim this line segment from the start point by the given amount.
+     * The amount must be positive and should be withing the segment's length. If the amount exceeds the segment's length
+     * then the length of the resulting line will be zero (0.0).
+     *
+     * @method trimStart
+     * @memberof Line
+     * @param {number} amount - The positive amount to trim the line from the start point `a`.
+     * @returns {Line} This for chaining, with updated point `a`.
+     */
+    Line.prototype.trimStart = function (amount) {
+        // Calculate the relative position `t` on this line.
+        var t = amount / this.length();
+        // `t` should be inside 0..1 – otherwise the amount was too large or negative.
+        if (t < 0.0) {
+            return this;
+        }
+        if (t > 1.0) {
+            // Set the line to length zero (endpoint only)
+            this.a = this.b.clone();
+            return this;
+        }
+        this.a = this.vertAt(t);
+        return this;
+    };
+    /**
+     * Trim this line segment from the start point by the given relative amount.
+     * The amount must be positive and should be within 0.0 and 1.0. If the amount exceeds the segment's length
+     * then the length of the resulting line will be zero (0.0).
+     *
+     * @method trimStartAt
+     * @memberof Line
+     * @param {number} amount - The positive amount to trim the line from the start point `a`.
+     * @returns {Line} This for chaining, with updated point `a`.
+     */
+    Line.prototype.trimStartAt = function (relativeAmount) {
+        // Calculate the relative position `t` on this line.
+        return this.trimStart(relativeAmount * this.length());
+    };
+    /**
+     * Trim this line segment from the end point by the given amount.
+     * The amount must be positive and should be withing the segment's length. If the amount exceeds the segment's length
+     * then the length of the resulting line will be zero (0.0).
+     *
+     * @method trimEnd
+     * @memberof Line
+     * @param {number} amount - The positive amount to trim the line from the end point `b`.
+     * @returns {Line} This for chaining, with updated point `b`.
+     */
+    Line.prototype.trimEnd = function (amount) {
+        // Calculate the relative position `t` on this line.
+        var t = 1.0 - amount / this.length();
+        // `t` should be inside 0..1 – otherwise the amount was too large or negative.
+        if (t < 0.0) {
+            return this;
+        }
+        if (t > 1.0) {
+            // Set the line to length zero (endpoint only)
+            this.b = this.a.clone();
+            return this;
+        }
+        this.b = this.vertAt(t);
+        return this;
+    };
+    /**
+     * Trim this line segment from the end point by the given relative amount.
+     * The amount must be positive and should be within 0.0 and 1.0. If the amount exceeds the segment's length
+     * then the length of the resulting line will be zero (0.0).
+     *
+     * @method trimEndAt
+     * @memberof Line
+     * @param {number} amount - The positive amount to trim the line from the start point `a`.
+     * @returns {Line} This for chaining, with updated point `a`.
+     */
+    Line.prototype.trimEndAt = function (relativeAmount) {
+        // Calculate the relative position `t` on this line.
+        return this.trimEnd(relativeAmount * this.length());
+    };
     //--- BEGIN --- Implement interface `Intersectable`
     /**
      * Get all line intersections with this polygon.
@@ -14306,8 +14716,9 @@ exports.Line = Line;
  * @modified 2025-04-18 Added evaluation method for cubic Bézier curves `CubicBezierCurve.utils.evaluateT`.
  * @modified 2025-04-18 Refactored method `CubicBezierCurve.getPointAt` to use `evaluateT`.
  * @modified 2025-04-18 Fixed the `CubicBezierCurve.getBounds` method: now returning the real bounding box. Before it was an approximated one.
- * @modified 2025-ß4-18 Added helper methods for bounding box calculation `CubucBezierCurve.util.cubicPolyMinMax` and `cubicPoly`.
- * @version 2.9.0
+ * @modified 2025-04-18 Added helper methods for bounding box calculation `CubucBezierCurve.util.cubicPolyMinMax` and `cubicPoly`.
+ * @modified 2026-09-09 Adding methods `CubicBezierCurve.trimStartEnd` and `CubicBezierCurve.trimStartEndAt`.
+ * @version 2.10.0
  *
  * @file CubicBezierCurve
  * @public
@@ -14762,6 +15173,7 @@ var CubicBezierCurve = /** @class */ (function () {
         this.endControlPoint.set(subCurbePoints[3]);
         this.updateArcLengths();
         return this;
+        // return this.trimStartEndAt(t, null);
     };
     /**
      * Trim off the end of this curve. The position parameter `uValue` is the absolute position on the
@@ -14797,7 +15209,79 @@ var CubicBezierCurve = /** @class */ (function () {
         this.endControlPoint.set(subCurbePoints[3]);
         this.updateArcLengths();
         return this;
+        // return this.trimStartEndAt(null, t);
     };
+    /**
+     * Trim off a start and end section of this curve. The position parameters `uStart` and `uEnd` are the absolute positions in [0..arcLength].
+     * The remaining curve will be the one in the bounds `[uStart,uEnd]` (so `[0.0,uStart]` and `[uEnd,1.0]` are cut off).
+     *
+     * Parameters out of bounds (< 0.0 or > arcLength) are ignored.
+     * If `uEnd` is smaller than `uStart` then a curve with length zero (0) at `uStart` is returned.
+     *
+     * @method trimStartEndAt
+     * @instance
+     * @memberof CubicBezierCurve
+     * @param {number} tStart - The relative position parameter where to cut off the head curve.
+     * @param {number} tEnd - The relative position parameter where to cut off the tail curve.
+     * @returns {CubicBezierCurve} `this` for chanining.
+     */
+    CubicBezierCurve.prototype.trimStartEnd = function (uStart, uEnd) {
+        return this.trimStartEndAt(this.convertU2T(uStart), this.convertU2T(uEnd));
+    };
+    /**
+     * Trim off a start and end section of this curve. The position parameters `tStart` and `tEnd` are the relative positions in [0..1].
+     * The remaining curve will be the one in the bounds `[tStart,tEnd]` (so `[0.0,tStart]` and `[tEnd,1.0]` are cut off).
+     *
+     * Parameters out of bounds (< 0.0 or > 1.0) are ignored.
+     * If `tEnd` is smaller than `tStart` then a curve with length zero (0) at `tStart` is returned.
+     *
+     * @method trimStartEndAt
+     * @instance
+     * @memberof CubicBezierCurve
+     * @param {number} tStart - The relative position parameter where to cut off the head curve.
+     * @param {number} tEnd - The relative position parameter where to cut off the tail curve.
+     * @returns {CubicBezierCurve} `this` for chanining.
+     */
+    CubicBezierCurve.prototype.trimStartEndAt = function (tStart, tEnd) {
+        var cleanTrimStart = Math.min(Math.max(0.0, tStart), 1.0);
+        var cleanTrimEnd = Math.min(Math.max(cleanTrimStart, tEnd), 1.0);
+        this.trimStartAt(cleanTrimStart);
+        var relativeTrimEnd = (cleanTrimEnd - cleanTrimStart) / (1.0 - cleanTrimStart);
+        this.trimEndAt(relativeTrimEnd);
+        return this;
+    };
+    // __trimStartEndAt(tStart: number, tEnd: number): CubicBezierCurve {
+    //   var finalCurvePoints = [
+    //     this.startPoint.clone(),
+    //     this.endPoint.clone(),
+    //     this.startControlPoint.clone(),
+    //     this.endControlPoint.clone()
+    //   ];
+    //   if (typeof tStart === "number" && !Number.isNaN(tStart)) {
+    //     const subCurvePointsStart = CubicBezierCurve.utils.getSubCurvePointsAt(this, tStart, 1.0);
+    //     finalCurvePoints[0].set(subCurvePointsStart[0]);
+    //     finalCurvePoints[2].set(subCurvePointsStart[2]);
+    //     // this.startPoint.set(subCurvePointsStart[0]);
+    //     // this.startControlPoint.set(subCurvePointsStart[2]);
+    //     // this.endPoint.set(subCurvePointsStart[1]);
+    //     // this.endControlPoint.set(subCurvePointsStart[3]);
+    //   }
+    //   if (typeof tEnd === "number" && !Number.isNaN(tEnd)) {
+    //     const subCurvePointsEnd = CubicBezierCurve.utils.getSubCurvePointsAt(this, 0.0, tEnd);
+    //     // this.startPoint.set(subCurvePointsEnd[0]);
+    //     // this.startControlPoint.set(subCurvePointsEnd[2]);
+    //     // this.endPoint.set(subCurvePointsEnd[1]);
+    //     // this.endControlPoint.set(subCurvePointsEnd[3]);
+    //     finalCurvePoints[1].set(subCurvePointsEnd[1]);
+    //     finalCurvePoints[3].set(subCurvePointsEnd[3]);
+    //   }
+    //   this.startPoint.set(finalCurvePoints[0]);
+    //   this.endPoint.set(finalCurvePoints[1]);
+    //   this.startControlPoint.set(finalCurvePoints[2]);
+    //   this.endControlPoint.set(finalCurvePoints[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).
      *
@@ -15152,10 +15636,7 @@ var CubicBezierCurve = /** @class */ (function () {
      */
     CubicBezierCurve.utils = {
         evaluateT: function (p0, p1, p2, p3, t) {
-            return p0 * Math.pow(1.0 - t, 3) +
-                p1 * 3 * t * Math.pow(1.0 - t, 2) +
-                p2 * 3 * Math.pow(t, 2) * (1.0 - t) +
-                p3 * Math.pow(t, 3);
+            return (p0 * Math.pow(1.0 - t, 3) + p1 * 3 * t * Math.pow(1.0 - t, 2) + p2 * 3 * Math.pow(t, 2) * (1.0 - t) + p3 * Math.pow(t, 3));
         },
         cubicPolyMinMax: function (p0, p1, p2, p3) {
             // var polyX = CubicBezierCurve.utils.cubicPoly2(
@@ -15227,7 +15708,7 @@ var CubicBezierCurve = /** @class */ (function () {
          * @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.
+         * @return {[Vertex, Vertex, Vertex, Vertex]} The sub curve as curve vertices.
          **/
         getSubCurvePointsAt: function (curve, tStart, tEnd) {
             var startVec = new Vector_1.Vector(curve.getPointAt(tStart), curve.getTangentAt(tStart));
@@ -15316,11 +15797,7 @@ var CubicBezierCurve = /** @class */ (function () {
          * @returns {[number,number,number]}
          */
         cubicPoly: function (p0, p1, p2, p3) {
-            return [
-                3 * p3 - 9 * p2 + 9 * p1 - 3 * p0,
-                6 * p0 - 12 * p1 + 6 * p2,
-                3 * p1 - 3 * p0
-            ];
+            return [3 * p3 - 9 * p2 + 9 * p1 - 3 * p0, 6 * p0 - 12 * p1 + 6 * p2, 3 * p1 - 3 * p0];
         },
         /**
          * sign of number, but is division safe: no zero returned :)