} - An array of all intersections within the polygon bounds.\n */\n Polygon.prototype.lineIntersections = function (line, inVectorBoundsOnly) {\n if (inVectorBoundsOnly === void 0) { inVectorBoundsOnly = false; }\n // Find the intersections of all lines inside the edge bounds\n return Polygon.utils\n .locateLineIntersecion(line, this.vertices, this.isOpen, inVectorBoundsOnly)\n .map(function (intersectionTuple) { return intersectionTuple.intersection; });\n };\n /**\n * Get all line intersections of this polygon and their tangents along the shape.\n *\n * This method returns all intersection tangents (as vectors) with this shape. The returned array of vectors is in no specific order.\n *\n * @param line\n * @param inVectorBoundsOnly\n * @returns\n */\n Polygon.prototype.lineIntersectionTangents = function (line, inVectorBoundsOnly) {\n var _this = this;\n if (inVectorBoundsOnly === void 0) { inVectorBoundsOnly = false; }\n // Find the intersection tangents of all lines inside the edge bounds\n return Polygon.utils.locateLineIntersecion(line, this.vertices, this.isOpen, inVectorBoundsOnly).map(function (intersectionTuple) {\n var polyLine = _this.getEdgeAt(intersectionTuple.edgeIndex);\n return new Vector_1.Vector(polyLine.a.clone(), polyLine.b.clone()).moveTo(intersectionTuple.intersection);\n });\n };\n //--- END --- Implement interface `Intersectable`\n /**\n * Get all line intersections of this polygon and their tangents along the shape.\n *\n * This method returns all intersection tangents (as vectors) with this shape. The returned array of vectors is in no specific order.\n *\n * @param line\n * @param inVectorBoundsOnly\n * @returns\n */\n Polygon.prototype.lineIntersectionTangentsIndices = function (line, inVectorBoundsOnly) {\n var _this = this;\n if (inVectorBoundsOnly === void 0) { inVectorBoundsOnly = false; }\n // Find the intersection tangents of all lines inside the edge bounds\n return Polygon.utils.locateLineIntersecion(line, this.vertices, this.isOpen, inVectorBoundsOnly).map(function (intersectionTuple) {\n var polyLine = _this.getEdgeAt(intersectionTuple.edgeIndex);\n return {\n intersection: new Vector_1.Vector(polyLine.a.clone(), polyLine.b.clone()).moveTo(intersectionTuple.intersection),\n edgeIndex: intersectionTuple.edgeIndex\n };\n });\n };\n /**\n * Get the closest line-polygon-intersection point (closest the line point A).\n *\n * See demo `47-closest-vector-projection-on-polygon` for how it works.\n *\n * @param {VertTuple} line - The line to find intersections with.\n * @param {boolean} inVectorBoundsOnly - If set to true only intersecion points on the passed vector are considered (located strictly between start and end vertex).\n * @returns {Vertex | null} - The intersection point within the polygon bounds.\n */\n Polygon.prototype.closestLineIntersection = function (line, inVectorBoundsOnly) {\n if (inVectorBoundsOnly === void 0) { inVectorBoundsOnly = false; }\n var closestInterSectionIndex = this.closestLineIntersectionIndex(line, inVectorBoundsOnly);\n if (closestInterSectionIndex) {\n return closestInterSectionIndex.intersection;\n }\n else {\n return null;\n }\n };\n /**\n * Get the closest line-polygon-intersection point (closest the line point A) plus the edge index..\n *\n * See demo `63-measure-angles-on-polygon` for how it works.\n *\n * @param {VertTuple} line - The line to find intersections with.\n * @param {boolean} inVectorBoundsOnly - If set to true only intersecion points on the passed vector are considered (located strictly between start and end vertex).\n * @returns {PolygonIntersectionTuple| null} - A pair containing the intersection point and the affected polygon edge index.\n */\n Polygon.prototype.closestLineIntersectionIndex = function (line, inVectorBoundsOnly) {\n if (inVectorBoundsOnly === void 0) { inVectorBoundsOnly = false; }\n var allIntersections = this.lineIntersections(line, inVectorBoundsOnly);\n if (allIntersections.length <= 0) {\n // Empty polygon -> no intersections\n return null;\n }\n // Find the closest intersection\n var closestIntersection = new Vertex_1.Vertex(Number.MAX_VALUE, Number.MAX_VALUE);\n var closestInterSectionIndex = -1;\n var curDist = Number.MAX_VALUE;\n for (var i = 0; i < allIntersections.length; i++) {\n var curVert = allIntersections[i];\n var dist = curVert.distance(line.a);\n if (dist < curDist) {\n // && line.hasPoint(curVert)) {\n curDist = dist;\n closestIntersection = curVert;\n closestInterSectionIndex = i;\n }\n }\n // return [closestIntersection, closestInterSectionIndex];\n return { edgeIndex: closestInterSectionIndex, intersection: closestIntersection };\n };\n /**\n * Construct a new polygon from this polygon with more vertices on each edge. The\n * interpolation count determines the number of additional vertices on each edge.\n * An interpolation count of `0` will return a polygon that equals the source\n * polygon.\n *\n * @param {number} interpolationCount\n * @returns {Polygon} A polygon with `interpolationCount` more vertices (as as factor).\n */\n Polygon.prototype.getInterpolationPolygon = function (interpolationCount) {\n var verts = [];\n for (var i = 0; i < this.vertices.length; i++) {\n var curVert = this.vertices[i];\n var nextVert = this.vertices[(i + 1) % this.vertices.length];\n verts.push(curVert.clone());\n // Add interpolation points\n if (!this.isOpen || i + 1 !== this.vertices.length) {\n var lerpAmount = 1.0 / (interpolationCount + 1);\n for (var j = 1; j <= interpolationCount; j++) {\n verts.push(curVert.clone().lerp(nextVert, lerpAmount * j));\n }\n }\n }\n return new Polygon(verts, this.isOpen);\n };\n /**\n * Convert this polygon into a new polygon with n evenly distributed vertices.\n *\n * @param {number} pointCount - Must not be negative.\n */\n Polygon.prototype.getEvenDistributionPolygon = function (pointCount) {\n if (pointCount <= 0) {\n throw new Error(\"pointCount must be larger than zero; is \" + pointCount + \".\");\n }\n var result = new Polygon([], this.isOpen);\n if (this.vertices.length === 0) {\n return result;\n }\n // Fetch and add the start point from the source polygon\n var polygonPoint = new Vertex_1.Vertex(this.vertices[0]);\n result.vertices.push(polygonPoint);\n if (this.vertices.length === 1) {\n return result;\n }\n var perimeter = this.perimeter();\n var stepSize = perimeter / pointCount;\n var n = this.vertices.length;\n var polygonIndex = 1;\n var nextPolygonPoint = new Vertex_1.Vertex(this.vertices[1]);\n var segmentLength = polygonPoint.distance(nextPolygonPoint);\n var loopMax = this.isOpen ? n : n + 1;\n var curSegmentU = stepSize;\n var i = 1;\n while (i < pointCount && polygonIndex < loopMax) {\n // Check if next eq point is inside this segment\n if (curSegmentU < segmentLength) {\n var newPoint = polygonPoint.clone().lerpAbs(nextPolygonPoint, curSegmentU);\n result.vertices.push(newPoint);\n curSegmentU += stepSize;\n i++;\n }\n else {\n polygonIndex++;\n polygonPoint = nextPolygonPoint;\n nextPolygonPoint = new Vertex_1.Vertex(this.vertices[polygonIndex % n]);\n curSegmentU = curSegmentU - segmentLength;\n segmentLength = polygonPoint.distance(nextPolygonPoint);\n }\n }\n return result;\n };\n //--- BEGIN --- Implement interface `IBounded`\n /**\n * Get the bounding box (bounds) of this polygon.\n *\n * @method getBounds\n * @instance\n * @memberof Polygon\n * @return {Bounds} The rectangular bounds of this polygon.\n **/\n Polygon.prototype.getBounds = function () {\n return Bounds_1.Bounds.computeFromVertices(this.vertices);\n };\n //--- END --- Implement interface `IBounded`\n /**\n * Create a deep copy of this polygon.\n *\n * @method clone\n * @instance\n * @memberof Polygon\n * @return {Polygon} The cloned polygon.\n */\n Polygon.prototype.clone = function () {\n return new Polygon(this.vertices.map(function (vert) { return vert.clone(); }), this.isOpen);\n };\n /**\n * Create a new polygon without colinear adjacent edges. This method does not midify the current polygon\n * but creates a new one.\n *\n * Please note that this method does NOT create deep clones of the vertices. Use Polygon.clone() if you need to.\n *\n * Please also note that the `tolerance` may become really large here, as the denominator of two closely\n * parallel lines is usually pretty large. See the demo `57-eliminate-colinear-polygon-edges` to get\n * an impression of how denominators work.\n *\n * @method elimitateColinearEdges\n * @instance\n * @memberof Polygon\n * @param {number?} tolerance - (default is 1.0) The epsilon to detect co-linear edges.\n * @return {Polygon} A new polygon without co-linear adjacent edges – respective the given epsilon.\n */\n Polygon.prototype.elimitateColinearEdges = function (tolerance) {\n var eps = typeof tolerance === \"undefined\" ? 1.0 : tolerance;\n var verts = this.vertices.slice(); // Creates a shallow copy\n var i = 0;\n var lineA = new Line_1.Line(new Vertex_1.Vertex(), new Vertex_1.Vertex());\n var lineB = new Line_1.Line(new Vertex_1.Vertex(), new Vertex_1.Vertex());\n while (i + 1 < verts.length && verts.length > 2) {\n var vertA = verts[i];\n var vertB = verts[(i + 1) % verts.length];\n lineA.a = vertA;\n lineA.b = vertB;\n lineB.a = vertB;\n var areColinear = false;\n var j = i + 2;\n do {\n var vertC = verts[j % verts.length];\n lineB.b = vertC;\n areColinear = lineA.colinear(lineB, eps);\n // console.log(\"are colinear?\", i, i + 1, j, areColinear);\n if (areColinear) {\n j++;\n }\n } while (areColinear);\n // Now j points to the first vertex that's NOT colinear to the current lineA\n // -> delete all vertices in between\n if (j - i > 2) {\n // Means: there have been 'colinear vertices' in between\n verts.splice(i + 1, j - i - 2);\n }\n i++;\n }\n return new Polygon(verts, this.isOpen);\n };\n /**\n * Convert this polygon to a sequence of quadratic Bézier curves.
\n *
\n * The first vertex in the returned array is the start point.
\n * The following sequence are pairs of control-point-and-end-point:\n * startPoint, controlPoint0, pathPoint1, controlPoint1, pathPoint2, controlPoint2, ..., endPoint
\n *\n * @method toQuadraticBezierData\n * @return {Vertex[]} An array of 2d vertices that shape the quadratic Bézier curve.\n * @instance\n * @memberof Polygon\n **/\n Polygon.prototype.toQuadraticBezierData = function () {\n if (this.vertices.length < 3)\n return [];\n var qbezier = [];\n var cc0 = this.vertices[0];\n var cc1 = this.vertices[1];\n var edgeCenter = new Vertex_1.Vertex(cc0.x + (cc1.x - cc0.x) / 2, cc0.y + (cc1.y - cc0.y) / 2);\n qbezier.push(edgeCenter);\n var limit = this.isOpen ? this.vertices.length : this.vertices.length + 1;\n for (var t = 1; t < limit; t++) {\n cc0 = this.vertices[t % this.vertices.length];\n cc1 = this.vertices[(t + 1) % this.vertices.length];\n var edgeCenter = new Vertex_1.Vertex(cc0.x + (cc1.x - cc0.x) / 2, cc0.y + (cc1.y - cc0.y) / 2);\n qbezier.push(cc0);\n qbezier.push(edgeCenter);\n cc0 = cc1;\n }\n return qbezier;\n };\n /**\n * Convert this polygon to a quadratic bezier curve, represented as an SVG data string.\n *\n * @method toQuadraticBezierSVGString\n * @return {string} The 'd' part for an SVG 'path' element.\n * @instance\n * @memberof Polygon\n **/\n Polygon.prototype.toQuadraticBezierSVGString = function () {\n var qdata = this.toQuadraticBezierData();\n if (qdata.length == 0)\n return \"\";\n var buffer = [\"M \" + qdata[0].x + \" \" + qdata[0].y];\n for (var i = 1; i < qdata.length; i += 2) {\n buffer.push(\"Q \" + qdata[i].x + \" \" + qdata[i].y + \", \" + qdata[i + 1].x + \" \" + qdata[i + 1].y);\n }\n return buffer.join(\" \");\n };\n /**\n * Convert this polygon to a sequence of cubic Bézier curves.
\n *
\n * The first vertex in the returned array is the start point.
\n * The following sequence are triplets of (first-control-point, secnond-control-point, end-point):
\n * startPoint, controlPoint0_0, controlPoint1_1, pathPoint1, controlPoint1_0, controlPoint1_1, ..., endPoint
\n *\n * @method toCubicBezierData\n * @param {number=} threshold - An optional threshold (default=1.0) how strong the curve segments\n * should over-/under-drive. Should be between 0.0 and 1.0 for best\n * results but other values are allowed.\n * @return {Vertex[]} An array of 2d vertices that shape the cubic Bézier curve.\n * @instance\n * @memberof Polygon\n **/\n Polygon.prototype.toCubicBezierData = function (threshold) {\n if (typeof threshold == \"undefined\")\n threshold = 1.0;\n if (this.vertices.length < 3)\n return [];\n var cbezier = [];\n var a = this.vertices[0];\n var b = this.vertices[1];\n var edgeCenter = new Vertex_1.Vertex(a.x + (b.x - a.x) / 2, a.y + (b.y - a.y) / 2);\n cbezier.push(edgeCenter);\n var limit = this.isOpen ? this.vertices.length - 1 : this.vertices.length;\n for (var t = 0; t < limit; t++) {\n var a = this.vertices[t % this.vertices.length];\n var b = this.vertices[(t + 1) % this.vertices.length];\n var c = this.vertices[(t + 2) % this.vertices.length];\n var aCenter = new Vertex_1.Vertex(a.x + (b.x - a.x) / 2, a.y + (b.y - a.y) / 2);\n var bCenter = new Vertex_1.Vertex(b.x + (c.x - b.x) / 2, b.y + (c.y - b.y) / 2);\n var a2 = new Vertex_1.Vertex(aCenter.x + (b.x - aCenter.x) * threshold, aCenter.y + (b.y - aCenter.y) * threshold);\n var b0 = new Vertex_1.Vertex(bCenter.x + (b.x - bCenter.x) * threshold, bCenter.y + (b.y - bCenter.y) * threshold);\n cbezier.push(a2);\n cbezier.push(b0);\n cbezier.push(bCenter);\n }\n return cbezier;\n };\n /**\n * Convert this polygon to a cubic bezier curve, represented as an SVG data string.\n *\n * @method toCubicBezierSVGString\n * @return {string} The 'd' part for an SVG 'path' element.\n * @instance\n * @memberof Polygon\n **/\n Polygon.prototype.toCubicBezierSVGString = function (threshold) {\n var qdata = this.toCubicBezierData(threshold);\n if (qdata.length == 0) {\n return \"\";\n }\n var buffer = [\"M \" + qdata[0].x + \" \" + qdata[0].y];\n for (var i = 1; i < qdata.length; i += 3) {\n buffer.push(\"C \" +\n qdata[i].x +\n \" \" +\n qdata[i].y +\n \", \" +\n qdata[i + 1].x +\n \" \" +\n qdata[i + 1].y +\n \", \" +\n qdata[i + 2].x +\n \" \" +\n qdata[i + 2].y);\n }\n return buffer.join(\" \");\n };\n /**\n * Convert this polygon to a cubic bezier path instance.\n *\n * @method toCubicBezierPath\n * @param {number} threshold - The threshold, usually from 0.0 to 1.0.\n * @return {BezierPath} - A bezier path instance.\n * @instance\n * @memberof Polygon\n **/\n Polygon.prototype.toCubicBezierPath = function (threshold) {\n var qdata = this.toCubicBezierData(threshold);\n // Conver the linear path vertices to a two-dimensional path array\n var pathdata = [];\n for (var i = 0; i + 3 < qdata.length; i += 3) {\n pathdata.push([qdata[i], qdata[i + 3], qdata[i + 1], qdata[i + 2]]);\n }\n return BezierPath_1.BezierPath.fromArray(pathdata);\n };\n /**\n * This function should invalidate any installed listeners and invalidate this object.\n * After calling this function the object might not hold valid data any more and\n * should not be used.\n */\n Polygon.prototype.destroy = function () {\n for (var i = 0; i < this.vertices.length; i++) {\n this.vertices[i].destroy();\n }\n this.isDestroyed = true;\n };\n Polygon.utils = {\n /**\n * Calculate the area of the given polygon (unsigned).\n *\n * Note that this does not work for self-intersecting polygons.\n *\n * @name area\n * @return {number}\n */\n area: function (vertices) {\n // Found at:\n // https://stackoverflow.com/questions/16285134/calculating-polygon-area\n var total = 0.0;\n for (var i = 0, l = vertices.length; i < l; i++) {\n var addX = vertices[i].x;\n var addY = vertices[(i + 1) % l].y;\n var subX = vertices[(i + 1) % l].x;\n var subY = vertices[i].y;\n total += addX * addY * 0.5;\n total -= subX * subY * 0.5;\n }\n return Math.abs(total);\n },\n isClockwise: function (vertices) {\n return Polygon.utils.signedArea(vertices) < 0;\n },\n /**\n * Calulate the signed polyon area by interpreting the polygon as a matrix\n * and calculating its determinant.\n *\n * @name signedArea\n * @return {number}\n */\n signedArea: function (vertices) {\n var sum = 0;\n var n = vertices.length;\n for (var i = 0; i < n; i++) {\n var j = (i + 1) % n;\n sum += (vertices[j].x - vertices[i].x) * (vertices[i].y + vertices[j].y);\n }\n return sum;\n },\n /**\n * Find intersections of a line with a polygon (vertices).\n *\n * @param {VertTuple} line - The line to find intersections with.\n * @param {Array} vertices - The polygon's vertices.\n * @param {boolean} isOpen - True if the polygon is open, false otherwise.\n * @param {boolean} inVectorBoundsOnly - If only intersections in strict vector bounds should be returned.\n * @returns\n */\n locateLineIntersecion: function (line, vertices, isOpen, inVectorBoundsOnly) {\n // Find the intersections of all lines inside the edge bounds\n var intersectionPoints = [];\n var n = isOpen ? vertices.length - 1 : vertices.length;\n for (var i = 0; i < n; i++) {\n var polyLine = new Line_1.Line(vertices[i % n], vertices[(i + 1) % n]);\n var intersection = polyLine.intersection(line);\n // true => only inside bounds\n // ignore last edge if open\n if (intersection !== null &&\n polyLine.hasPoint(intersection, true) &&\n (!inVectorBoundsOnly || line.hasPoint(intersection, inVectorBoundsOnly))) {\n intersectionPoints.push({ edgeIndex: i, intersection: intersection });\n }\n }\n return intersectionPoints;\n }\n };\n return Polygon;\n}());\nexports.Polygon = Polygon;\n//# sourceMappingURL=Polygon.js.map","\"use strict\";\n/**\n * Implementation of elliptic sectors.\n * Note that sectors are constructed in clockwise direction.\n *\n * @author Ikaros Kappler\n * @date 2021-02-26\n * @modified 2022-02-02 Added the `destroy` method.\n * @modified 2022-11-01 Tweaked the `endpointToCenterParameters` function to handle negative values, too, without errors.\n * @modified 2025-04-01 Adapting a the `toCubicBezier` calculation to match an underlying change in the vertAt and tangentAt calculation of ellipses (was required to hamonize both methods with circles).\n * @modified 2025-04-02 Adding `VEllipseSector.containsAngle` method.\n * @modified 2025-04-02 Adding `VEllipseSector.lineIntersections` and `VEllipseSector.lineIntersectionTangents` and implementing `Intersectable`.\n * @modified 2025-04-07 Adding value wrapping (0 to TWO_PI) to the `VEllipseSector.containsAngle` method.\n * @modified 2025-04-09 Adding the `VEllipseSector.move` method.\n * @modified 2025-04-19 Added the `VEllipseSector.getStartPoint` and `getEndPoint` methods.\n * @modified 2025-04-23 Added the `VEllipseSector.getBounds` method.\n * @version 1.2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.VEllipseSector = void 0;\nvar Bounds_1 = require(\"./Bounds\");\nvar CubicBezierCurve_1 = require(\"./CubicBezierCurve\");\nvar geomutils_1 = require(\"./geomutils\");\nvar Line_1 = require(\"./Line\");\nvar UIDGenerator_1 = require(\"./UIDGenerator\");\nvar VEllipse_1 = require(\"./VEllipse\");\nvar Vertex_1 = require(\"./Vertex\");\n/**\n * @classdesc A class for elliptic sectors.\n *\n * @requires Line\n * @requires Vector\n * @requires VertTuple\n * @requires Vertex\n * @requires SVGSerializale\n * @requires UID\n * @requires UIDGenerator\n **/\nvar VEllipseSector = /** @class */ (function () {\n /**\n * Create a new elliptic sector from the given ellipse and two angles.\n *\n * Note that the direction from start to end goes clockwise, and that start and end angle\n * will be wrapped to [0,PI*2).\n *\n * @constructor\n * @name VEllipseSector\n * @param {VEllipse} - The underlying ellipse to use.\n * @param {number} startAngle - The start angle of the sector.\n * @param {numner} endAngle - The end angle of the sector.\n */\n function VEllipseSector(ellipse, startAngle, endAngle) {\n /**\n * Required to generate proper CSS classes and other class related IDs.\n **/\n this.className = \"VEllipseSector\";\n this.uid = UIDGenerator_1.UIDGenerator.next();\n this.ellipse = ellipse;\n this.startAngle = geomutils_1.geomutils.wrapMinMax(startAngle, 0, Math.PI * 2);\n this.endAngle = geomutils_1.geomutils.wrapMinMax(endAngle, 0, Math.PI * 2);\n }\n /**\n * Move the ellipse sector by the given amount.\n *\n * @method move\n * @param {XYCoords} amount - The amount to move.\n * @instance\n * @memberof VEllipseSector\n * @return {VEllipseSector} this for chaining\n **/\n VEllipseSector.prototype.move = function (amount) {\n this.ellipse.move(amount);\n return this;\n };\n /**\n * Checks wether the given angle (must be inside 0 and PI*2) is contained inside this sector.\n *\n * @param {number} angle - The numeric angle to check.\n * @method containsAngle\n * @instance\n * @memberof VEllipseSectpr\n * @return {boolean} True if (and only if) this sector contains the given angle.\n */\n VEllipseSector.prototype.containsAngle = function (angle) {\n angle = geomutils_1.geomutils.mapAngleTo2PI(angle); // wrapMinMax(angle, 0, Math.PI * 2);\n var sAngle = geomutils_1.geomutils.mapAngleTo2PI(this.startAngle);\n var eAngle = geomutils_1.geomutils.mapAngleTo2PI(this.endAngle);\n // TODO: cleanup\n // if (this.startAngle <= this.endAngle) {\n // return angle >= this.startAngle && angle < this.endAngle;\n // } else {\n // // startAngle > endAngle\n // return angle >= this.startAngle || angle < this.endAngle;\n // }\n if (sAngle <= eAngle) {\n return angle >= sAngle && angle < eAngle;\n }\n else {\n // startAngle > endAngle\n return angle >= sAngle || angle < eAngle;\n }\n };\n /**\n * Get the sectors starting point (on the underlying ellipse, located at the start angle).\n *\n * @method getStartPoint\n * @instance\n * @memberof VEllipseSector\n * @return {Vertex} The sector's stating point.\n */\n VEllipseSector.prototype.getStartPoint = function () {\n return this.ellipse.vertAt(this.startAngle);\n };\n /**\n * Get the sectors ending point (on the underlying ellipse, located at the end angle).\n *\n * @method getEndPoint\n * @instance\n * @memberof VEllipseSector\n * @return {Vertex} The sector's ending point.\n */\n VEllipseSector.prototype.getEndPoint = function () {\n return this.ellipse.vertAt(this.endAngle);\n };\n //--- BEGIN --- Implement interface `IBounded`\n /**\n * Get the bounds of this elliptic sector.\n *\n * The bounds are approximated by the underlying segment buffer; the more segment there are,\n * the more accurate will be the returned bounds.\n *\n * @method getBounds\n * @instance\n * @memberof VEllipse\n * @return {Bounds} The bounds of this elliptic sector.\n **/\n VEllipseSector.prototype.getBounds = function () {\n var _this = this;\n // Calculage angles from east, west, north and south box points and check if they are inside\n var extremes = this.ellipse.getExtremePoints();\n var candidates = extremes.filter(function (point) {\n var angle = new Line_1.Line(_this.ellipse.center, point).angle() - _this.ellipse.rotation;\n return _this.containsAngle(angle);\n });\n return Bounds_1.Bounds.computeFromVertices([this.getStartPoint(), this.getEndPoint()].concat(candidates));\n };\n //--- BEGIN --- Implement interface `Intersectable`\n /**\n * Get the line intersections as vectors with this ellipse.\n *\n * @method lineIntersections\n * @instance\n * @memberof VEllipseSectpr\n * @param {VertTuple} ray - The line/ray to intersect this ellipse with.\n * @param {boolean} inVectorBoundsOnly - (default=false) Set to true if only intersections within the vector bounds are of interest.\n * @returns\n */\n VEllipseSector.prototype.lineIntersections = function (ray, inVectorBoundsOnly) {\n var _this = this;\n if (inVectorBoundsOnly === void 0) { inVectorBoundsOnly = false; }\n // First get all line intersections from underlying ellipse.\n var ellipseIntersections = this.ellipse.lineIntersections(ray, inVectorBoundsOnly);\n // Drop all intersection points that are not contained in the circle sectors bounds.\n var tmpLine = new Line_1.Line(this.ellipse.center, new Vertex_1.Vertex());\n return ellipseIntersections.filter(function (intersectionPoint) {\n tmpLine.b.set(intersectionPoint);\n var lineAngle = tmpLine.angle();\n return _this.containsAngle(lineAngle - _this.ellipse.rotation);\n });\n };\n /**\n * Get all line intersections of this polygon and their tangents along the shape.\n *\n * This method returns all intersection tangents (as vectors) with this shape. The returned array of vectors is in no specific order.\n *\n * @method lineIntersections\n * @memberof VEllipseSectpr\n * @param line\n * @param lineIntersectionTangents\n * @returns\n */\n VEllipseSector.prototype.lineIntersectionTangents = function (line, inVectorBoundsOnly) {\n var _this = this;\n if (inVectorBoundsOnly === void 0) { inVectorBoundsOnly = false; }\n // Find the intersections of all lines plus their tangents inside the circle bounds\n var interSectionPoints = this.lineIntersections(line, inVectorBoundsOnly);\n return interSectionPoints.map(function (vert) {\n // Calculate angle\n var lineFromCenter = new Line_1.Line(_this.ellipse.center, vert);\n var angle = lineFromCenter.angle();\n // console.log(\"angle\", (angle / Math.PI) * 180.0);\n // const angle = Math.random() * Math.PI * 2; // TODO\n // Calculate tangent at angle\n return _this.ellipse.tangentAt(angle);\n });\n };\n //--- END --- Implement interface `Intersectable`\n /**\n * Convert this elliptic sector into cubic Bézier curves.\n *\n * @param {number=3} quarterSegmentCount - The number of segments per base elliptic quarter (default is 3, min is 1).\n * @param {number=0.666666} threshold - The Bézier threshold (default value 0.666666 approximates the ellipse with best results\n * but you might wish to use other values)\n * @return {Array} An array of cubic Bézier curves representing the elliptic sector.\n */\n VEllipseSector.prototype.toCubicBezier = function (quarterSegmentCount, threshold) {\n // There are at least 4 segments required (dour quarters) to approximate a whole\n // ellipse with Bézier curves.\n // A visually 'good' approximation should have 12; this seems to be a good value (anything multiple of 4).\n var segmentCount = Math.max(1, quarterSegmentCount || 3) * 4;\n threshold = typeof threshold === \"undefined\" ? 0.666666 : threshold;\n var radiusH = this.ellipse.radiusH();\n var radiusV = this.ellipse.radiusV();\n var startAngle = VEllipseSector.ellipseSectorUtils.normalizeAngle(this.startAngle);\n var endAngle = VEllipseSector.ellipseSectorUtils.normalizeAngle(this.endAngle);\n // Find all angles inside start and end\n var angles = VEllipseSector.ellipseSectorUtils.equidistantVertAngles(radiusH, radiusV, startAngle, endAngle, segmentCount);\n angles = [startAngle].concat(angles).concat([endAngle]);\n var curves = [];\n var curAngle = angles[0];\n var startPoint = this.ellipse.vertAt(curAngle);\n for (var i = 0; i + 1 < angles.length; i++) {\n var nextAngle = angles[(i + 1) % angles.length];\n var endPoint = this.ellipse.vertAt(nextAngle);\n var startTangent = this.ellipse.tangentAt(curAngle + this.ellipse.rotation);\n var endTangent = this.ellipse.tangentAt(nextAngle + this.ellipse.rotation);\n // Distorted ellipses can only be approximated by linear Bézier segments\n if (Math.abs(radiusV) < 0.0001 || Math.abs(radiusH) < 0.0001) {\n var diff = startPoint.difference(endPoint);\n var curve = new CubicBezierCurve_1.CubicBezierCurve(startPoint.clone(), endPoint.clone(), startPoint.clone().addXY(diff.x * 0.333, diff.y * 0.333), endPoint.clone().addXY(-diff.x * 0.333, -diff.y * 0.333));\n curves.push(curve);\n }\n else {\n // Find intersection\n var intersection = startTangent.intersection(endTangent);\n // What if intersection is undefined?\n // --> This *can* not happen if segmentCount > 2 and height and width of the ellipse are not zero.\n if (intersection) {\n // It's VERY LIKELY hat this ALWAYS happens; it's just a typesave variant.\n // Intersection cannot be null.\n var startDiff = startPoint.difference(intersection);\n var endDiff = endPoint.difference(intersection);\n var curve = new CubicBezierCurve_1.CubicBezierCurve(startPoint.clone(), endPoint.clone(), startPoint.clone().add(startDiff.scale(threshold)), endPoint.clone().add(endDiff.scale(threshold)));\n curves.push(curve);\n }\n }\n startPoint = endPoint;\n curAngle = nextAngle;\n }\n return curves;\n };\n /**\n * This function should invalidate any installed listeners and invalidate this object.\n * After calling this function the object might not hold valid data any more and\n * should not be used.\n */\n VEllipseSector.prototype.destroy = function () {\n this.ellipse.destroy();\n this.isDestroyed = true;\n };\n VEllipseSector.ellipseSectorUtils = {\n /**\n * Helper function to convert an elliptic section to SVG arc params (for the `d` attribute).\n * Inspiration found at:\n * https://stackoverflow.com/questions/5736398/how-to-calculate-the-svg-path-for-an-arc-of-a-circle\n *\n * @param {boolean} options.moveToStart - If false (default=true) the initial 'Move' command will not be used.\n * @return [ 'A', radiusH, radiusV, rotation, largeArcFlag=1|0, sweepFlag=0, endx, endy ]\n */\n describeSVGArc: function (x, y, radiusH, radiusV, startAngle, endAngle, rotation, options) {\n if (typeof options === \"undefined\")\n options = { moveToStart: true };\n if (typeof rotation === \"undefined\")\n rotation = 0.0;\n // Important note: this function only works if start- and end-angle are within\n // one whole circle [x,x+2*PI].\n // Revelations of more than 2*PI might result in unexpected arcs.\n // -> Use the geomutils.wrapMax( angle, 2*PI )\n startAngle = geomutils_1.geomutils.wrapMax(startAngle, Math.PI * 2);\n endAngle = geomutils_1.geomutils.wrapMax(endAngle, Math.PI * 2);\n // Find the start- and end-point on the rotated ellipse\n // XYCoords to Vertex (for rotation)\n var end = new Vertex_1.Vertex(VEllipse_1.VEllipse.utils.polarToCartesian(x, y, radiusH, radiusV, endAngle));\n var start = new Vertex_1.Vertex(VEllipse_1.VEllipse.utils.polarToCartesian(x, y, radiusH, radiusV, startAngle));\n end.rotate(rotation, { x: x, y: y });\n start.rotate(rotation, { x: x, y: y });\n // Boolean stored as integers (0|1).\n var diff = endAngle - startAngle;\n var largeArcFlag;\n if (diff < 0) {\n largeArcFlag = Math.abs(diff) < Math.PI ? 1 : 0;\n }\n else {\n largeArcFlag = Math.abs(diff) > Math.PI ? 1 : 0;\n }\n var sweepFlag = 1;\n var pathData = [];\n if (options.moveToStart) {\n pathData.push(\"M\", start.x, start.y);\n }\n // Arc rotation in degrees, not radians.\n var r2d = 180 / Math.PI;\n pathData.push(\"A\", radiusH, radiusV, rotation * r2d, largeArcFlag, sweepFlag, end.x, end.y);\n return pathData;\n }, // END function describeSVGArc\n /**\n * Helper function to find second-kind elliptic angles, so that the euclidean distance along the the\n * elliptic sector is the same for all.\n *\n * Note that this is based on the full ellipse calculuation and start and end will be cropped; so the\n * distance from the start angle to the first angle and/or the distance from the last angle to\n * the end angle may be different to the others.\n *\n * Furthermore the computation is only possible on un-rotated ellipses; if your source ellipse has\n * a rotation on the plane please 'rotate' the result angles afterwards to find matching angles.\n *\n * Returned angles are normalized to the interval `[ 0, PI*2 ]`.\n *\n * @param {number} radiusH - The first (horizonal) radius of the ellipse.\n * @param {number} radiusV - The second (vertical) radius of the ellipse.\n * @param {number} startAngle - The opening angle of your elliptic sector (please use normalized angles).\n * @param {number} endAngle - The closing angle of your elliptic sector (please use normalized angles).\n * @param {number} fullEllipsePointCount - The number of base segments to use from the source ellipse (12 or 16 are good numbers).\n * @return {Array} An array of n angles inside startAngle and endAngle (where n <= fullEllipsePointCount).\n */\n equidistantVertAngles: function (radiusH, radiusV, startAngle, endAngle, fullEllipsePointCount) {\n var ellipseAngles = VEllipse_1.VEllipse.utils.equidistantVertAngles(radiusH, radiusV, fullEllipsePointCount);\n ellipseAngles = ellipseAngles.map(function (angle) { return VEllipseSector.ellipseSectorUtils.normalizeAngle(angle); });\n var angleIsInRange = function (angle) {\n if (startAngle < endAngle)\n return angle >= startAngle && angle <= endAngle;\n else\n return angle >= startAngle || (angle <= endAngle && angle >= 0);\n };\n // Drop all angles outside the sector\n ellipseAngles = ellipseAngles.filter(angleIsInRange);\n // Now we need to sort the angles to the first one in the array is the closest to startAngle.\n // --> find the angle that is closest to the start angle\n var startIndex = VEllipseSector.ellipseSectorUtils.findClosestToStartAngle(startAngle, endAngle, ellipseAngles);\n // Bring all angles into the correct order\n // Idea: use splice or slice here?\n var angles = [];\n for (var i = 0; i < ellipseAngles.length; i++) {\n angles.push(ellipseAngles[(startIndex + i) % ellipseAngles.length]);\n }\n return angles;\n },\n findClosestToStartAngle: function (startAngle, endAngle, ellipseAngles) {\n // Note: endAngle > 0 && startAngle > 0\n if (startAngle > endAngle) {\n var n = ellipseAngles.length;\n for (var i = 0; i < n; i++) {\n var ea = geomutils_1.geomutils.wrapMinMax(ellipseAngles[i], 0, Math.PI * 2);\n if (ea >= startAngle && ea >= endAngle) {\n return i;\n }\n }\n }\n return 0;\n },\n normalizeAngle: function (angle) { return (angle < 0 ? Math.PI * 2 + angle : angle); },\n /**\n * Convert the elliptic arc from endpoint parameters to center parameters as described\n * in the w3c svg arc implementation note.\n *\n * https://www.w3.org/TR/SVG/implnote.html#ArcConversionEndpointToCenter\n *\n * @param {number} x1 - The x component of the start point (end of last SVG command).\n * @param {number} y1 - The y component of the start point (end of last SVG command).\n * @param {number} rx - The first (horizontal) radius of the ellipse.\n * @param {number} ry - The second (vertical) radius of the ellipse.\n * @param {number} phi - The ellipse's rotational angle (angle of axis rotation) in radians (not in degrees as the SVG command uses!)\n * @param {boolean} fa - The large-arc-flag (boolean, not 0 or 1).\n * @param {boolean} fs - The sweep-flag (boolean, not 0 or 1).\n * @param {number} x2 - The x component of the end point (end of last SVG command).\n * @param {number} y2 - The y component of the end point (end of last SVG command).\n * @returns\n */\n endpointToCenterParameters: function (x1, y1, rx, ry, phi, fa, fs, x2, y2) {\n // console.log(\"endpointToCenterParameters\", x1, y1, phi, rx, ry, fa, fs, x2, y2);\n // Thanks to\n // https://observablehq.com/@toja/ellipse-and-elliptical-arc-conversion\n var abs = Math.abs;\n var sin = Math.sin;\n var cos = Math.cos;\n var sqrt = Math.sqrt;\n var pow = function (n) {\n return n * n;\n };\n var sinphi = sin(phi);\n var cosphi = cos(phi);\n // Step 1: simplify through translation/rotation\n var x = (cosphi * (x1 - x2)) / 2 + (sinphi * (y1 - y2)) / 2;\n var y = (-sinphi * (x1 - x2)) / 2 + (cosphi * (y1 - y2)) / 2;\n var px = pow(x), py = pow(y), prx = pow(rx), pry = pow(ry);\n // correct of out-of-range radii\n var L = px / prx + py / pry;\n if (L > 1) {\n rx = sqrt(L) * abs(rx);\n ry = sqrt(L) * abs(ry);\n }\n else {\n rx = abs(rx);\n ry = abs(ry);\n }\n // Step 2 + 3: compute center\n var sign = fa === fs ? -1 : 1;\n // const M: number = sqrt((prx * pry - prx * py - pry * px) / (prx * py + pry * px)) * sign;\n var M = sqrt(Math.abs((prx * pry - prx * py - pry * px) / (prx * py + pry * px))) * sign;\n var _cx = (M * (rx * y)) / ry;\n var _cy = (M * (-ry * x)) / rx;\n var cx = cosphi * _cx - sinphi * _cy + (x1 + x2) / 2;\n var cy = sinphi * _cx + cosphi * _cy + (y1 + y2) / 2;\n // Step 4: Compute start and end angle\n var center = new Vertex_1.Vertex(cx, cy);\n var axis = center.clone().addXY(rx, ry);\n var ellipse = new VEllipse_1.VEllipse(center, axis, 0);\n // console.log(\"VELLIPSE::::::\", ellipse);\n ellipse.rotate(phi);\n var startAngle = new Line_1.Line(ellipse.center, new Vertex_1.Vertex(x1, y1)).angle();\n var endAngle = new Line_1.Line(ellipse.center, new Vertex_1.Vertex(x2, y2)).angle();\n return new VEllipseSector(ellipse, startAngle - phi, endAngle - phi);\n }\n }; // END ellipseSectorUtils\n return VEllipseSector;\n}());\nexports.VEllipseSector = VEllipseSector;\n//# sourceMappingURL=VEllipseSector.js.map","\"use strict\";\n/**\n * @author Ikaros Kappler\n * @date 2013-08-19\n * @modified 2018-08-16 Added closure. Removed the 'IKRS' wrapper.\n * @modified 2018-11-20 Added circular auto-adjustment.\n * @modified 2018-11-25 Added the point constants to the BezierPath class itself.\n * @modified 2018-11-28 Added the locateCurveByStartPoint() function.\n * @modified 2018-12-04 Added the toSVGString() function.\n * @modified 2019-03-23 Added JSDoc tags.\n * @modified 2019-03-23 Changed the fuctions getPoint and getPointAt to match semantics in the Line class.\n * @modified 2019-11-18 Fixed the clone function: adjustCircular attribute was not cloned.\n * @modified 2019-12-02 Removed some excessive comments.\n * @modified 2019-12-04 Fixed the missing obtainHandleLengths behavior in the adjustNeightbourControlPoint function.\n * @modified 2020-02-06 Added function locateCurveByEndPoint( Vertex ).\n * @modified 2020-02-11 Added 'return this' to the scale(Vertex,number) and to the translate(Vertex) function.\n * @modified 2020-03-24 Ported this class from vanilla-JS to Typescript.\n * @modified 2020-06-03 Made the private helper function _locateUIndex to a private function.\n * @modified 2020-06-03 Added the getBounds() function.\n * @modified 2020-07-14 Changed the moveCurvePoint(...,Vertex) to moveCurvePoint(...,XYCoords).\n * @modified 2020-07-24 Added the getClosestT(Vertex) function.\n * @modified 2020-12-29 Constructor is now private (no explicit use intended).\n * @modified 2021-05-25 Added BezierPath.fromReducedList( Array ).\n * @modified 2022-01-31 Added `BezierPath.getEvenDistributionVertices(number)`.\n * @modified 2022-02-02 Added the `destroy` method.\n * @modified 2022-02-02 Cleared the `toSVGString` function (deprecated). Use `drawutilssvg` instead.\n * @modified 2023-10-06 Adding the `BezierPath.toPathPoints()` method.\n * @modified 2023-10-07 Adding the `BezierPath.fromCurve(CubicBezierCurve)` static function.\n * @modified 2025-04-09 Added the `BezierPath.move` method to match the convention – which just calls `translate`.\n * @modified 2025-04-09 Modified the `BezierPath.translate` method: chaning parameter `Vertex` to more generalized `XYCoords`.\n * @modified 2025-04-14 Class `BezierPath` is now implementing interface `Intersectable`.\n * @version 2.7.0\n *\n * @file BezierPath\n * @public\n **/\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.BezierPath = void 0;\nvar Bounds_1 = require(\"./Bounds\");\nvar CubicBezierCurve_1 = require(\"./CubicBezierCurve\");\nvar UIDGenerator_1 = require(\"./UIDGenerator\");\nvar Vertex_1 = require(\"./Vertex\");\n/**\n * @classdesc A BezierPath class.\n *\n * This was refactored from an older project.\n *\n * @requires Bounds\n * @requires Vertex\n * @requires CubicBezierCurve\n * @requires XYCoords\n * @requires SVGSerializable\n * @requires UID\n * @requires UIDGenerator\n **/\nvar BezierPath = /** @class */ (function () {\n /**\n * The constructor.
\n *
\n * This constructor expects a sequence of path points and will approximate\n * the location of control points by picking some between the points.
\n * You should consider just constructing empty paths and then add more curves later using\n * the addCurve() function.\n *\n * @constructor\n * @name BezierPath\n * @param {Vertex[]} pathPoints - An array of path vertices (no control points).\n **/\n function BezierPath() {\n /**\n * Required to generate proper CSS classes and other class related IDs.\n **/\n this.className = \"BezierPath\";\n /** @constant {number} */\n this.START_POINT = 0;\n /** @constant {number} */\n this.START_CONTROL_POINT = 1;\n /** @constant {number} */\n this.END_CONTROL_POINT = 2;\n /** @constant {number} */\n this.END_POINT = 3;\n // pathPoints: Array | undefined | null) {\n this.uid = UIDGenerator_1.UIDGenerator.next();\n // if (!pathPoints) {\n // pathPoints = [];\n // }\n this.totalArcLength = 0.0;\n // Set this flag to true if you want the first point and\n // last point of the path to be auto adjusted, too.\n this.adjustCircular = false;\n this.bezierCurves = [];\n }\n /**\n * Add a cubic bezier curve to the end of this path.\n *\n * @method addCurve\n * @param {CubicBezierCurve} curve - The curve to be added to the end of the path.\n * @instance\n * @memberof BezierPath\n * @return {void}\n **/\n BezierPath.prototype.addCurve = function (curve) {\n if (curve == null || typeof curve == \"undefined\")\n throw \"Cannot add null curve to bézier path.\";\n this.bezierCurves.push(curve);\n if (this.bezierCurves.length > 1) {\n curve.startPoint = this.bezierCurves[this.bezierCurves.length - 2].endPoint;\n this.adjustSuccessorControlPoint(this.bezierCurves.length - 2, // curveIndex,\n true, // obtainHandleLength,\n true // updateArcLengths\n );\n }\n else {\n this.totalArcLength += curve.getLength();\n }\n };\n /**\n * Locate the curve with the given start point (function returns the index).\n *\n * @method locateCurveByStartPoint\n * @param {Vertex} point - The (curve start-) point to look for.\n * @instance\n * @memberof BezierPath\n * @return {number} The curve index or -1 if curve (start-) point not found\n **/\n BezierPath.prototype.locateCurveByStartPoint = function (point) {\n // for( var i in this.bezierCurves ) {\n for (var i = 0; i < this.bezierCurves.length; i++) {\n if (this.bezierCurves[i].startPoint.equals(point))\n return i;\n }\n return -1;\n };\n /**\n * Locate the curve with the given end point (function returns the index).\n *\n * @method locateCurveByEndPoint\n * @param {Vertex} point - The (curve end-) point to look for.\n * @instance\n * @memberof BezierPath\n * @return {number} The curve index or -1 if curve (end-) point not found\n **/\n BezierPath.prototype.locateCurveByEndPoint = function (point) {\n // for( var i in this.bezierCurves ) {\n for (var i = 0; i < this.bezierCurves.length; i++) {\n if (this.bezierCurves[i].endPoint.equals(point))\n return i;\n }\n return -1;\n };\n /**\n * Locate the curve with the given start point (function returns the index).\n *\n * @method locateCurveByStartControlPoint\n * @param {Vertex} point - The (curve endt-) point to look for.\n * @instance\n * @memberof BezierPath\n * @return {number} The curve index or -1 if curve (end-) point not found\n **/\n BezierPath.prototype.locateCurveByStartControlPoint = function (point) {\n // for( var i in this.bezierCurves ) {\n for (var i = 0; i < this.bezierCurves.length; i++) {\n if (this.bezierCurves[i].startControlPoint.equals(point))\n return i;\n }\n return -1;\n };\n // +---------------------------------------------------------------------------------\n // | Locate the curve with the given end control point.\n // |\n // | @param point:Vertex The point to look for.\n // | @return Number The index or -1 if not found.\n // +-------------------------------\n BezierPath.prototype.locateCurveByEndControlPoint = function (point) {\n // for( var i in this.bezierCurves ) {\n for (var i = 0; i < this.bezierCurves.length; i++) {\n if (this.bezierCurves[i].endControlPoint.equals(point))\n return i;\n }\n return -1;\n };\n /**\n * Get the total length of this path.
\n *
\n * Note that the returned value comes from the curve buffer. Unregistered changes\n * to the curve points will result in invalid path length values.\n *\n * @method getLength\n * @instance\n * @memberof BezierPath\n * @return {number} The (buffered) length of the path.\n **/\n BezierPath.prototype.getLength = function () {\n return this.totalArcLength;\n };\n /**\n * This function is internally called whenever the curve or path configuration\n * changed. It updates the attribute that stores the path length information.
\n *
\n * If you perform any unregistered changes to the curve points you should call\n * this function afterwards to update the curve buffer. Not updating may\n * result in unexpected behavior.\n *\n * @method updateArcLengths\n * @instance\n * @memberof BezierPath\n * @return {void}\n **/\n BezierPath.prototype.updateArcLengths = function () {\n this.totalArcLength = 0.0;\n for (var i = 0; i < this.bezierCurves.length; i++) {\n this.bezierCurves[i].updateArcLengths();\n this.totalArcLength += this.bezierCurves[i].getLength();\n }\n };\n /**\n * Get the number of curves in this path.\n *\n * @method getCurveCount\n * @instance\n * @memberof BezierPath\n * @return {number} The number of curves in this path.\n **/\n BezierPath.prototype.getCurveCount = function () {\n return this.bezierCurves.length;\n };\n /**\n * Get the cubic bezier curve at the given index.\n *\n * @method getCurveAt\n * @param {number} index - The curve index from 0 to getCurveCount()-1.\n * @instance\n * @memberof BezierPath\n * @return {CubicBezierCurve} The curve at the specified index.\n **/\n BezierPath.prototype.getCurveAt = function (curveIndex) {\n return this.bezierCurves[curveIndex];\n };\n /**\n * Move the whole bezier path by the given (x,y)-amount.\n *\n * @method translate\n * @param {XYCoords} amount - The amount to be added (amount.x and amount.y)\n * to each vertex of the curve.\n * @instance\n * @memberof BezierPath\n * @return {BezierPath} this for chaining\n **/\n BezierPath.prototype.translate = function (amount) {\n for (var i = 0; i < this.bezierCurves.length; i++) {\n var curve = this.bezierCurves[i];\n curve.getStartPoint().add(amount);\n curve.getStartControlPoint().add(amount);\n curve.getEndControlPoint().add(amount);\n }\n // Don't forget to translate the last curve's last point\n var curve = this.bezierCurves[this.bezierCurves.length - 1];\n curve.getEndPoint().add(amount);\n this.updateArcLengths();\n return this;\n };\n /**\n * Move the whole bezier path by the given (x,y)-amount.\n *\n * @method move\n * @param {XYCoords} amount - The amount to be added (amount.x and amount.y)\n * to each vertex of the curve.\n * @instance\n * @memberof BezierPath\n * @return {BezierPath} this for chaining\n **/\n BezierPath.prototype.move = function (amount) {\n return this.translate(amount);\n };\n /**\n * Scale the whole bezier path by the given uniform factor.\n *\n * @method scale\n * @param {Vertex} anchor - The scale origin to scale from.\n * @param {number} scaleFactor - The scalar to be multiplied with.\n * @instance\n * @memberof BezierPath\n * @return {BezierPath} this for chaining.\n **/\n BezierPath.prototype.scale = function (anchor, scaleFactor) {\n return this.scaleXY({ x: scaleFactor, y: scaleFactor }, anchor);\n };\n /**\n * Scale the whole bezier path by the given (x,y)-factors.\n *\n * @method scale\n * @param {Vertex} anchor - The scale origin to scale from.\n * @param {number} amount - The scalar to be multiplied with.\n * @instance\n * @memberof BezierPath\n * @return {BezierPath} this for chaining.\n **/\n BezierPath.prototype.scaleXY = function (scaleFactors, anchor) {\n for (var i = 0; i < this.bezierCurves.length; i++) {\n var curve = this.bezierCurves[i];\n curve.getStartPoint().scaleXY(scaleFactors, anchor);\n curve.getStartControlPoint().scaleXY(scaleFactors, anchor);\n curve.getEndControlPoint().scaleXY(scaleFactors, anchor);\n // Do NOT scale the end point here!\n // Don't forget that the curves are connected and on curve's end point\n // the the successor's start point (same instance)!\n }\n // Finally move the last end point (was not scaled yet)\n if (this.bezierCurves.length > 0 && !this.adjustCircular) {\n this.bezierCurves[this.bezierCurves.length - 1].getEndPoint().scaleXY(scaleFactors, anchor);\n }\n this.updateArcLengths();\n return this;\n };\n /**\n * Rotate the whole bezier path around a point..\n *\n * @method rotate\n * @param {Vertex} angle - The angle to rotate this path by.\n * @param {Vertex} center - The rotation center.\n * @instance\n * @memberof BezierPath\n * @return {void}\n **/\n BezierPath.prototype.rotate = function (angle, center) {\n for (var i = 0; i < this.bezierCurves.length; i++) {\n var curve = this.bezierCurves[i];\n curve.getStartPoint().rotate(angle, center);\n curve.getStartControlPoint().rotate(angle, center);\n curve.getEndControlPoint().rotate(angle, center);\n // Do NOT rotate the end point here!\n // Don't forget that the curves are connected and on curve's end point\n // the the successor's start point (same instance)!\n }\n // Finally move the last end point (was not scaled yet)\n if (this.bezierCurves.length > 0 && !this.adjustCircular) {\n this.bezierCurves[this.bezierCurves.length - 1].getEndPoint().rotate(angle, center);\n }\n };\n /**\n * Get the 't' position on this curve with the minimal distance to point p.\n *\n * @param {Vertex} p - The point to find the closest curve point for.\n * @return {number} A value t with 0.0 <= t <= 1.0.\n **/\n BezierPath.prototype.getClosestT = function (p) {\n // Find the spline to extract the value from\n var minIndex = -1;\n var minDist = 0.0;\n var dist = 0.0;\n var curveT = 0.0;\n var uMin = 0.0;\n var u = 0.0;\n for (var i = 0; i < this.bezierCurves.length; i++) {\n curveT = this.bezierCurves[i].getClosestT(p);\n dist = this.bezierCurves[i].getPointAt(curveT).distance(p);\n if (minIndex == -1 || dist < minDist) {\n minIndex = i;\n minDist = dist;\n uMin = u + curveT * this.bezierCurves[i].getLength();\n }\n u += this.bezierCurves[i].getLength();\n }\n return Math.max(0.0, Math.min(1.0, uMin / this.totalArcLength));\n };\n /**\n * Get the point on the bézier path at the given relative path location.\n *\n * @method getPoint\n * @param {number} u - The relative path position: 0 <= u <= this.getLength()
\n * @instance\n * @memberof BezierPath\n * @return {Vertex} The point at the relative path position.\n **/\n BezierPath.prototype.getPoint = function (u) {\n if (u < 0 || u > this.totalArcLength) {\n console.warn(\"[BezierPath.getPoint(u)] u is out of bounds: \" + u + \".\");\n u = Math.min(this.totalArcLength, Math.max(u, 0));\n }\n // Find the spline to extract the value from\n var i = 0;\n var uTemp = 0.0;\n while (i < this.bezierCurves.length && uTemp + this.bezierCurves[i].getLength() < u) {\n uTemp += this.bezierCurves[i].getLength();\n i++;\n }\n // if u == arcLength\n // -> i is max\n if (i >= this.bezierCurves.length)\n return this.bezierCurves[this.bezierCurves.length - 1].getEndPoint().clone();\n var bCurve = this.bezierCurves[i];\n var relativeU = u - uTemp;\n return bCurve.getPoint(relativeU);\n };\n /**\n * Get the point on the bézier path at the given path fraction.\n *\n * @method getPointAt\n * @param {number} t - The absolute path position: 0.0 <= t <= 1.0
\n * @instance\n * @memberof BezierPath\n * @return {Vertex} The point at the absolute path position.\n **/\n BezierPath.prototype.getPointAt = function (t) {\n return this.getPoint(t * this.totalArcLength);\n };\n /**\n * Get the tangent of the bézier path at the given path fraction.
\n *
\n * Note that the returned vector is not normalized.\n *\n * @method getTangentAt\n * @param {number} t - The absolute path position: 0.0 <= t <= 1.0
\n * @instance\n * @memberof BezierPath\n * @return {Vertex} The tangent vector at the absolute path position.\n **/\n BezierPath.prototype.getTangentAt = function (t) {\n return this.getTangent(t * this.totalArcLength);\n };\n /**\n * Get the tangent of the bézier path at the given path location.
\n *
\n * Note that the returned vector is not normalized.\n *\n * @method getTangent\n * @param {number} u - The relative path position: 0 <= u <= getLength()
\n * @instance\n * @memberof BezierPath\n * @return {Vertex} The tangent vector at the relative path position.\n **/\n BezierPath.prototype.getTangent = function (u) {\n if (u < 0 || u > this.totalArcLength) {\n console.warn(\"[BezierPath.getTangent(u)] u is out of bounds: \" + u + \".\");\n // return undefined;\n u = Math.min(this.totalArcLength, Math.max(0, u));\n }\n // Find the spline to extract the value from\n var i = 0;\n var uTemp = 0.0;\n while (i < this.bezierCurves.length && uTemp + this.bezierCurves[i].getLength() < u) {\n uTemp += this.bezierCurves[i].getLength();\n i++;\n }\n var bCurve = this.bezierCurves[i];\n var relativeU = u - uTemp;\n return bCurve.getTangent(relativeU);\n };\n /**\n * Get the perpendicular of the bézier path at the given absolute path location (fraction).
\n *
\n * Note that the returned vector is not normalized.\n *\n * @method getPerpendicularAt\n * @param {number} t - The absolute path position: 0.0 <= t <= 1.0
\n * @instance\n * @memberof BezierPath\n * @return {Vertex} The perpendicluar vector at the absolute path position.\n **/\n BezierPath.prototype.getPerpendicularAt = function (t) {\n return this.getPerpendicular(t * this.totalArcLength);\n };\n /**\n * Get the perpendicular of the bézier path at the given relative path location.
\n *
\n * Note that the returned vector is not normalized.\n *\n * @method getPerpendicular\n * @param {number} u - The relative path position: 0 <= u <= getLength()
\n * @instance\n * @memberof BezierPath\n * @return {Vertex} The perpendicluar vector at the relative path position.\n **/\n BezierPath.prototype.getPerpendicular = function (u) {\n if (u < 0 || u > this.totalArcLength) {\n console.log(\"[BezierPath.getPerpendicular(u)] u is out of bounds: \" + u + \".\");\n u = Math.min(this.totalArcLength, Math.max(0, u));\n }\n // Find the spline to extract the value from\n var uResult = BezierPath._locateUIndex(this, u);\n var bCurve = this.bezierCurves[uResult.i];\n var relativeU = u - uResult.uPart;\n return bCurve.getPerpendicular(relativeU);\n };\n //--- BEGIN --- Implement interface `Intersectable`\n /**\n * Get all line intersections with this shape.\n *\n * This method returns all intersections (as vertices) with this shape. The returned array of vertices is in no specific order.\n *\n * @param {VertTuple} line - The line to find intersections with.\n * @param {boolean} inVectorBoundsOnly - If set to true only intersecion points on the passed vector are returned (located strictly between start and end vertex).\n * @returns {Array} - An array of all intersections with the shape's outline.\n */\n BezierPath.prototype.lineIntersections = function (line, inVectorBoundsOnly) {\n if (inVectorBoundsOnly === void 0) { inVectorBoundsOnly = false; }\n return this.bezierCurves.reduce(function (accu, curCurve) {\n return accu.concat(curCurve.lineIntersections(line, inVectorBoundsOnly));\n }, []);\n };\n /**\n * Get all line intersections of this polygon and their tangents along the shape.\n *\n * This method returns all intersection tangents (as vectors) with this shape. The returned array of vectors is in no specific order.\n *\n * @param line\n * @param lineIntersectionTangents\n * @returns\n */\n BezierPath.prototype.lineIntersectionTangents = function (line, inVectorBoundsOnly) {\n if (inVectorBoundsOnly === void 0) { inVectorBoundsOnly = false; }\n return this.bezierCurves.reduce(function (accu, curCurve) {\n return accu.concat(curCurve.lineIntersectionTangents(line, inVectorBoundsOnly));\n }, []);\n };\n //--- END --- Implement interface `Intersectable`\n /**\n * This is a helper function to locate the curve index for a given\n * absolute path position u.\n *\n * I decided to put this into privat scope as it is really specific. Maybe\n * put this into a utils wrapper.\n *\n * Returns:\n * - {number} i - the index of the containing curve.\n * - {number} uPart - the absolute curve length sum (length from the beginning to u, should equal u itself).\n * - {number} uBefore - the absolute curve length for all segments _before_ the matched curve (usually uBefore <= uPart).\n **/\n BezierPath._locateUIndex = function (path, u) {\n var i = 0;\n var uTemp = 0.0;\n var uBefore = 0.0;\n while (i < path.bezierCurves.length && uTemp + path.bezierCurves[i].getLength() < u) {\n uTemp += path.bezierCurves[i].getLength();\n if (i + 1 < path.bezierCurves.length)\n uBefore += path.bezierCurves[i].getLength();\n i++;\n }\n return { i: i, uPart: uTemp, uBefore: uBefore };\n };\n /**\n * Get a specific sub path from this path. The start and end position are specified by\n * ratio number in [0..1].\n *\n * 0.0 is at the beginning of the path.\n * 1.0 is at the end of the path.\n *\n * Values below 0 or beyond 1 are cropped down to the [0..1] interval.\n *\n * startT > endT is allowed, the returned sub path will have inverse direction then.\n *\n * @method getSubPathAt\n * @param {number} startT - The start position of the sub path.\n * @param {number} endT - The end position of the sub path.\n * @instance\n * @memberof BezierPath\n * @return {BezierPath} The desired sub path in the bounds [startT..endT].\n **/\n BezierPath.prototype.getSubPathAt = function (startT, endT) {\n startT = Math.max(0, startT);\n endT = Math.min(1.0, endT);\n var startU = startT * this.totalArcLength;\n var endU = endT * this.totalArcLength;\n var uStartResult = BezierPath._locateUIndex(this, startU); // { i:int, uPart:float, uBefore:float }\n var uEndResult = BezierPath._locateUIndex(this, endU); // { i:int, uPart:float, uBefore:float }\n var firstT = (startU - uStartResult.uBefore) / this.bezierCurves[uStartResult.i].getLength();\n if (uStartResult.i == uEndResult.i) {\n // Subpath begins and ends in the same path segment (just get a simple sub curve from that path element).\n var lastT = (endU - uEndResult.uBefore) / this.bezierCurves[uEndResult.i].getLength();\n var firstCurve = this.bezierCurves[uStartResult.i].getSubCurveAt(firstT, lastT);\n return BezierPath.fromArray([firstCurve]);\n }\n else {\n var curves = [];\n if (uStartResult.i > uEndResult.i) {\n // Back to front direction\n var firstCurve = this.bezierCurves[uStartResult.i].getSubCurveAt(firstT, 0.0);\n curves.push(firstCurve);\n for (var i = uStartResult.i - 1; i > uEndResult.i; i--) {\n curves.push(this.bezierCurves[i].clone().reverse());\n }\n var lastT = (endU - uEndResult.uBefore) / this.bezierCurves[uEndResult.i].getLength();\n curves.push(this.bezierCurves[uEndResult.i].getSubCurveAt(1.0, lastT));\n }\n else {\n // Front to back direction\n var firstCurve = this.bezierCurves[uStartResult.i].getSubCurveAt(firstT, 1.0);\n curves.push(firstCurve);\n for (var i = uStartResult.i + 1; i < uEndResult.i && i < this.bezierCurves.length; i++) {\n curves.push(this.bezierCurves[i].clone());\n }\n var lastT = (endU - uEndResult.uBefore) / this.bezierCurves[uEndResult.i].getLength();\n curves.push(this.bezierCurves[uEndResult.i].getSubCurveAt(0, lastT));\n }\n return BezierPath.fromArray(curves);\n }\n };\n /**\n * This function moves the addressed curve point (or control point) with\n * keeping up the path's curve integrity.
\n *
\n * Thus is done by moving neighbour- and control- points as needed.\n *\n * @method moveCurvePoint\n * @param {number} curveIndex - The curve index to move a point from.\n * @param {number} pointID - One of the curve's four point IDs (START_POINT,\n * START_CONTROL_POINT, END_CONTRO_POINT or END_POINT).\n * @param {XYCoords} moveAmount - The amount to move the addressed vertex by.\n * @instance\n * @memberof BezierPath\n * @return {void}\n **/\n BezierPath.prototype.moveCurvePoint = function (curveIndex, pointID, moveAmount) {\n var bCurve = this.getCurveAt(curveIndex);\n bCurve.moveCurvePoint(pointID, moveAmount, true, // move control point, too\n true // updateArcLengths\n );\n // If inner point and NOT control point\n // --> move neightbour\n if (pointID == this.START_POINT && (curveIndex > 0 || this.adjustCircular)) {\n // Set predecessor's control point!\n var predecessor = this.getCurveAt(curveIndex - 1 < 0 ? this.bezierCurves.length + (curveIndex - 1) : curveIndex - 1);\n predecessor.moveCurvePoint(this.END_CONTROL_POINT, moveAmount, true, // move control point, too\n false // updateArcLengths\n );\n }\n else if (pointID == this.END_POINT && (curveIndex + 1 < this.bezierCurves.length || this.adjustCircular)) {\n // Set successcor\n var successor = this.getCurveAt((curveIndex + 1) % this.bezierCurves.length);\n successor.moveCurvePoint(this.START_CONTROL_POINT, moveAmount, true, // move control point, too\n false // updateArcLengths\n );\n }\n else if (pointID == this.START_CONTROL_POINT && curveIndex > 0) {\n this.adjustPredecessorControlPoint(curveIndex, true, // obtain handle length?\n false // update arc lengths\n );\n }\n else if (pointID == this.END_CONTROL_POINT && curveIndex + 1 < this.getCurveCount()) {\n this.adjustSuccessorControlPoint(curveIndex, true, // obtain handle length?\n false // update arc lengths\n );\n }\n // Don't forget to update the arc lengths!\n // Note: this can be optimized as only two curves have changed their lengths!\n this.updateArcLengths();\n };\n /**\n * This helper function adjusts the given point's predecessor's control point.\n *\n * @method adjustPredecessorControlPoint\n * @param {number} curveIndex - The curve index to move a point from.\n * @param {boolean} obtainHandleLength - Moves the point with keeping the original handle length.\n * @param {boolean} updateArcLength - The amount to move the addressed vertex by.\n * @instance\n * @private\n * @memberof BezierPath\n * @return {void}\n **/\n BezierPath.prototype.adjustPredecessorControlPoint = function (curveIndex, obtainHandleLength, updateArcLengths) {\n if (!this.adjustCircular && curveIndex <= 0)\n return; // false;\n var mainCurve = this.getCurveAt(curveIndex);\n var neighbourCurve = this.getCurveAt(curveIndex - 1 < 0 ? this.getCurveCount() + (curveIndex - 1) : curveIndex - 1);\n BezierPath.adjustNeighbourControlPoint(mainCurve, neighbourCurve, mainCurve.getStartPoint(), // the reference point\n mainCurve.getStartControlPoint(), // the dragged control point\n neighbourCurve.getEndPoint(), // the neighbour's point\n neighbourCurve.getEndControlPoint(), // the neighbour's control point to adjust\n obtainHandleLength, updateArcLengths);\n };\n /**\n * This helper function adjusts the given point's successor's control point.\n *\n * @method adjustSuccessorControlPoint\n * @param {number} curveIndex - The curve index to move a point from.\n * @param {boolean} obtainHandleLength - Moves the point with keeping the original handle length.\n * @param {boolean} updateArcLength - The amount to move the addressed vertex by.\n * @instance\n * @private\n * @memberof BezierPath\n * @return {void}\n **/\n BezierPath.prototype.adjustSuccessorControlPoint = function (curveIndex, obtainHandleLength, updateArcLengths) {\n if (!this.adjustCircular && curveIndex + 1 > this.getCurveCount())\n return; // false;\n var mainCurve = this.getCurveAt(curveIndex);\n var neighbourCurve = this.getCurveAt((curveIndex + 1) % this.getCurveCount());\n /* return */ BezierPath.adjustNeighbourControlPoint(mainCurve, neighbourCurve, mainCurve.getEndPoint(), // the reference point\n mainCurve.getEndControlPoint(), // the dragged control point\n neighbourCurve.getStartPoint(), // the neighbour's point\n neighbourCurve.getStartControlPoint(), // the neighbour's control point to adjust\n obtainHandleLength, updateArcLengths);\n };\n /**\n * This helper function adjusts the given point's successor's control point.\n *\n * @method adjustNeighbourControlPoint\n * @param {CubicBezierCurve} mainCurve\n * @param {CubicBezierCurve} neighbourCurve\n * @param {Vertex} mainPoint\n * @param {Vertex} mainControlPoint\n * @param {Vertex} neighbourPoint\n * @param {Vertex} neighbourControlPoint\n * @param {boolean} obtainHandleLengths\n * @param {boolean} updateArcLengths\n * @instance\n * @private\n * @memberof BezierPath\n * @return {void}\n **/\n BezierPath.adjustNeighbourControlPoint = function (_mainCurve, // TODO: remove param\n neighbourCurve, mainPoint, mainControlPoint, neighbourPoint, neighbourControlPoint, obtainHandleLengths, _updateArcLengths // TODO: remove param\n ) {\n // Calculate start handle length\n var mainHandleBounds = new Vertex_1.Vertex(mainControlPoint.x - mainPoint.x, mainControlPoint.y - mainPoint.y);\n var neighbourHandleBounds = new Vertex_1.Vertex(neighbourControlPoint.x - neighbourPoint.x, neighbourControlPoint.y - neighbourPoint.y);\n var mainHandleLength = Math.sqrt(Math.pow(mainHandleBounds.x, 2) + Math.pow(mainHandleBounds.y, 2));\n var neighbourHandleLength = Math.sqrt(Math.pow(neighbourHandleBounds.x, 2) + Math.pow(neighbourHandleBounds.y, 2));\n if (mainHandleLength <= 0.1)\n return; // no secure length available for division? What about zoom? Use EPSILON?\n // Just invert the main handle (keep length or not?\n if (obtainHandleLengths) {\n neighbourControlPoint.set(neighbourPoint.x - mainHandleBounds.x * (neighbourHandleLength / mainHandleLength), neighbourPoint.y - mainHandleBounds.y * (neighbourHandleLength / mainHandleLength));\n }\n else {\n neighbourControlPoint.set(neighbourPoint.x - mainHandleBounds.x, neighbourPoint.y - mainHandleBounds.y);\n }\n neighbourCurve.updateArcLengths();\n };\n //--- BEGIN --- Implement interface `IBounded`\n /**\n * Get the bounds of this Bézier path.\n *\n * Note the the curves' underlyung segment buffers are used to determine the bounds. The more\n * elements the segment buffers have, the more precise the returned bounds will be.\n *\n * @return {Bounds} The bounds of this Bézier path.\n **/\n BezierPath.prototype.getBounds = function () {\n var min = new Vertex_1.Vertex(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);\n var max = new Vertex_1.Vertex(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY);\n var b;\n for (var i = 0; i < this.bezierCurves.length; i++) {\n b = this.bezierCurves[i].getBounds();\n min.x = Math.min(min.x, b.min.x);\n min.y = Math.min(min.y, b.min.y);\n max.x = Math.max(max.x, b.max.x);\n max.y = Math.max(max.y, b.max.y);\n }\n return new Bounds_1.Bounds(min, max);\n };\n //--- END --- Implement interface `IBounded`\n /**\n * Get n 'equally' distributed vertices along this Bézier path.\n *\n * As the changing curvature of the B slines makes prediction of distances difficult, the\n * returned vertices' distances are only relatively equal:\n * - the distance grows where curvature is large.\n * - the distance shrinks where curvature is small.\n *\n * Only the distance mean of all consecutive is 1/n-th of the total arc length.\n *\n * Usually this approximation is good enough for most use cases.\n *\n * @param {number} pointCount - (must be at least 2) The number of desired points (start and end point included).\n * @return {Array}\n */\n BezierPath.prototype.getEvenDistributionVertices = function (pointCount) {\n if (pointCount < 2) {\n throw new Error(\"pointCount must be larger than one; is \" + pointCount + \".\");\n }\n var result = [];\n if (this.bezierCurves.length === 0) {\n return result;\n }\n // Fetch and add the start point from the source polygon\n var polygonPoint = new Vertex_1.Vertex(this.bezierCurves[0].startPoint);\n result.push(polygonPoint);\n // if (this.bezierCurves.length === 1) {\n // return result;\n // }\n var perimeter = this.totalArcLength;\n var stepSize = perimeter / (pointCount - 1);\n var n = this.bezierCurves.length;\n var curveIndex = 0;\n var segmentLength = this.bezierCurves[0].arcLength;\n var curSegmentU = stepSize;\n var i = 1;\n while (i < pointCount && curveIndex < n) {\n // Check if next eq point is inside this segment\n if (curSegmentU < segmentLength) {\n var newPoint = this.bezierCurves[curveIndex].getPoint(curSegmentU);\n result.push(newPoint);\n curSegmentU += stepSize;\n i++;\n }\n else {\n curveIndex++;\n curSegmentU = curSegmentU - segmentLength;\n segmentLength = curveIndex < n ? this.bezierCurves[curveIndex].arcLength : 0;\n }\n }\n result.push(new Vertex_1.Vertex(this.bezierCurves[n - 1].endPoint));\n return result;\n };\n /**\n * Clone this BezierPath (deep clone).\n *\n * @method clone\n * @instance\n * @memberof BezierPath\n * @return {BezierPath}\n **/\n BezierPath.prototype.clone = function () {\n var path = new BezierPath(); // undefined);\n for (var i = 0; i < this.bezierCurves.length; i++) {\n path.bezierCurves.push(this.bezierCurves[i].clone());\n // Connect splines\n if (i > 0)\n path.bezierCurves[i - 1].endPoint = path.bezierCurves[i].startPoint;\n }\n path.updateArcLengths();\n path.adjustCircular = this.adjustCircular;\n return path;\n };\n /**\n * Compare this and the passed Bézier path.\n *\n * @method equals\n * @param {BezierPath} path - The pass to compare with.\n * @instance\n * @memberof BezierPath\n * @return {boolean}\n **/\n BezierPath.prototype.equals = function (path) {\n if (!path)\n return false;\n // Check if path contains the credentials\n if (!path.bezierCurves)\n return false;\n if (typeof path.bezierCurves.length == \"undefined\")\n return false;\n if (path.bezierCurves.length != this.bezierCurves.length)\n return false;\n for (var i = 0; i < this.bezierCurves.length; i++) {\n if (!this.bezierCurves[i].equals(path.bezierCurves[i]))\n return false;\n }\n return true;\n };\n /**\n * This function should invalidate any installed listeners and invalidate this object.\n * After calling this function the object might not hold valid data any more and\n * should not be used.\n *\n * @method destroy\n * @instance\n * @memberof BezierPath\n */\n BezierPath.prototype.destroy = function () {\n for (var i = 0; i < this.bezierCurves.length; i++) {\n this.bezierCurves[i].destroy();\n }\n this.isDestroyed = true;\n };\n /**\n * Convert this path to an array of path points that can be drawn by the default DrawLib\n * implementations.\n *\n * @method toPathPoints\n * @instance\n * @memberof BezierPath\n * @return {Array}\n */\n BezierPath.prototype.toPathPoints = function () {\n if (this.bezierCurves.length === 0) {\n return [];\n }\n if (this.bezierCurves.length === 1) {\n return [\n this.bezierCurves[0].startPoint,\n this.bezierCurves[0].startControlPoint,\n this.bezierCurves[0].endControlPoint,\n this.bezierCurves[0].endPoint\n ];\n }\n var arr = [];\n arr.push(this.bezierCurves[0].startPoint);\n arr.push(this.bezierCurves[0].startControlPoint);\n for (var i = 1; i < this.bezierCurves.length; i++) {\n arr.push(this.bezierCurves[i - 1].endControlPoint);\n arr.push(this.bezierCurves[i - 1].endPoint);\n arr.push(this.bezierCurves[i].startPoint);\n arr.push(this.bezierCurves[i].startControlPoint);\n }\n arr.push(this.bezierCurves[0].endControlPoint);\n arr.push(this.bezierCurves[0].endPoint);\n return arr;\n };\n /**\n * Create a JSON string representation of this bézier curve.\n *\n * @method toJSON\n * @param {boolean} prettyFormat - If true then the function will add line breaks.\n * @instance\n * @memberof BezierPath\n * @return {string} The JSON string.\n **/\n BezierPath.prototype.toJSON = function (prettyFormat) {\n var buffer = [];\n buffer.push(\"[\"); // array begin\n for (var i = 0; i < this.bezierCurves.length; i++) {\n if (i > 0)\n buffer.push(\",\");\n if (prettyFormat)\n buffer.push(\"\\n\\t\");\n else\n buffer.push(\" \");\n buffer.push(this.bezierCurves[i].toJSON(prettyFormat));\n }\n if (this.bezierCurves.length != 0)\n buffer.push(\" \");\n buffer.push(\"]\"); // array end\n return buffer.join(\"\"); // Convert to string, with empty separator.\n };\n /**\n * Parse a BezierPath from the given JSON string.\n *\n * @method fromJSON\n * @param {string} jsonString - The string with the JSON data.\n * @throw An error if the string is not JSON or does not contain a bezier path object.\n * @static\n * @memberof BezierPath\n * @return {BezierPath} The parsed bezier path instance.\n **/\n BezierPath.fromJSON = function (jsonString) {\n var obj = JSON.parse(jsonString);\n return BezierPath.fromArray(obj);\n };\n /**\n * Construct a new path with a single curve. Adding more curves is always possible.\n *\n * @method fromCurve\n * @param {CubicBezierCurve} curve - The curve to construct a new path from.\n * @static\n * @memberof BezierPath\n * @return {BezierPath} The constructed bezier path instance.\n */\n BezierPath.fromCurve = function (curve) {\n var path = new BezierPath(); // []);\n path.addCurve(curve);\n return path;\n };\n /**\n * Create a BezierPath instance from the given array.\n *\n * @method fromArray\n * @param {Vertex[][]} arr - A two-dimensional array containing the bezier path vertices.\n * @throw An error if the array does not contain proper bezier path data.\n * @static\n * @memberof BezierPath\n * @return {BezierPath} The bezier path instance retrieved from the array data.\n **/\n BezierPath.fromArray = function (obj) {\n if (!Array.isArray(obj)) {\n throw \"[BezierPath.fromArray] Passed object must be an array.\";\n }\n var arr = obj; // FORCE?\n if (arr.length < 1) {\n throw \"[BezierPath.fromArray] Passed array must contain at least one bezier curve (has \" + arr.length + \").\";\n }\n // Create an empty bezier path\n var bPath = new BezierPath(); // undefined);\n var lastCurve = null;\n for (var i = 0; i < arr.length; i++) {\n // Convert object (or array?) to bezier curve\n var bCurve;\n if (CubicBezierCurve_1.CubicBezierCurve.isInstance(arr[i])) {\n bCurve = arr[i].clone();\n }\n else if (0 in arr[i] && 1 in arr[i] && 2 in arr[i] && 3 in arr[i]) {\n if (!arr[i][0] || !arr[i][1] || !arr[i][2] || !arr[i][3])\n throw \"Cannot convert path data to BezierPath instance. At least one element is undefined (index=\" + i + \"): \" + arr[i];\n bCurve = CubicBezierCurve_1.CubicBezierCurve.fromArray(arr[i]);\n }\n else {\n bCurve = CubicBezierCurve_1.CubicBezierCurve.fromObject(arr[i]);\n }\n // Set curve start point?\n // (avoid duplicate point instances!)\n if (lastCurve)\n bCurve.startPoint = lastCurve.endPoint;\n // Add to path's internal list\n bPath.bezierCurves.push(bCurve);\n // bPath.totalArcLength += bCurve.getLength();\n lastCurve = bCurve;\n }\n bPath.updateArcLengths();\n // Bezier segments added. Done\n return bPath;\n };\n /**\n * This function converts the bezier path into a string containing\n * integer values only.\n * The points' float values are rounded to 1 digit after the comma.\n *\n * The returned string represents a JSON array (with leading '[' and\n * trailing ']', the separator is ',').\n *\n * @method toReducedListRepresentation\n * @param {number} digits - The number of digits to be used after the comma '.'.\n * @instance\n * @memberof BezierPath\n * @return {string} The reduced list representation of this path.\n **/\n BezierPath.prototype.toReducedListRepresentation = function (digits) {\n if (typeof digits == \"undefined\")\n digits = 1;\n var buffer = [];\n buffer.push(\"[\"); // array begin\n for (var i = 0; i < this.bezierCurves.length; i++) {\n var curve = this.bezierCurves[i];\n buffer.push(curve.getStartPoint().x.toFixed(digits));\n buffer.push(\",\");\n buffer.push(curve.getStartPoint().y.toFixed(digits));\n buffer.push(\",\");\n buffer.push(curve.getStartControlPoint().x.toFixed(digits));\n buffer.push(\",\");\n buffer.push(curve.getStartControlPoint().y.toFixed(digits));\n buffer.push(\",\");\n buffer.push(curve.getEndControlPoint().x.toFixed(digits));\n buffer.push(\",\");\n buffer.push(curve.getEndControlPoint().y.toFixed(digits));\n buffer.push(\",\");\n }\n if (this.bezierCurves.length != 0) {\n var curve = this.bezierCurves[this.bezierCurves.length - 1];\n buffer.push(curve.getEndPoint().x.toFixed(digits));\n buffer.push(\",\");\n buffer.push(curve.getEndPoint().y.toFixed(digits));\n }\n buffer.push(\"]\"); // array end\n return buffer.join(\"\"); // Convert to string, with empty separator.\n };\n /**\n * Parse a BezierPath instance from the reduced list representation.
\n *
\n * The passed string must represent a JSON array containing numbers only.\n *\n * @method fromReducedListRepresentation\n * @param {string} listJSON - The number of digits to be used after the floating point.\n * @throw An error if the string is malformed.\n * @instance\n * @memberof BezierPath\n * @return {BezierPath} The bezier path instance retrieved from the string.\n **/\n BezierPath.fromReducedListRepresentation = function (listJSON, adjustCircular) {\n // Parse the array\n var pointArray = JSON.parse(listJSON);\n if (!pointArray.length) {\n console.log(\"Cannot parse bezier path from non-array object nor from empty point list.\");\n throw \"Cannot parse bezier path from non-array object nor from empty point list.\";\n }\n if (pointArray.length < 8) {\n console.log(\"Cannot build bezier path. The passed array must contain at least 8 elements (numbers).\");\n throw \"Cannot build bezier path. The passed array must contain at least 8 elements (numbers).\";\n }\n return BezierPath.fromReducedList(pointArray, adjustCircular);\n };\n /**\n * Convert a reduced list representation (array of numeric coordinates) to a BezierPath instance.\n *\n * The array's length must be 6*n + 2:\n * - [sx, sy, scx, scy, ecx, ecy, ... , ex, ey ]\n * | | | |\n * +--- sequence of curves --------+ +-end-+\n *\n * @param {number[]} pointArray\n * @returns BezierPath\n */\n BezierPath.fromReducedList = function (pointArray, adjustCircular) {\n // Convert to object\n var bezierPath = new BezierPath(); // null); // No points yet\n var startPoint = new Vertex_1.Vertex();\n var startControlPoint;\n var endControlPoint;\n var endPoint;\n var i = 0;\n do {\n if (i == 0) {\n // firstStartPoint =\n startPoint = new Vertex_1.Vertex(pointArray[i], pointArray[i + 1]);\n }\n startControlPoint = new Vertex_1.Vertex(pointArray[i + 2], pointArray[i + 3]);\n endControlPoint = new Vertex_1.Vertex(pointArray[i + 4], pointArray[i + 5]);\n // if (i + 8 >= pointArray.length) {\n // endPoint = firstStartPoint;\n // } else {\n endPoint = new Vertex_1.Vertex(pointArray[i + 6], pointArray[i + 7]);\n // }\n var bCurve = new CubicBezierCurve_1.CubicBezierCurve(startPoint, endPoint, startControlPoint, endControlPoint);\n bezierPath.bezierCurves.push(bCurve);\n startPoint = endPoint;\n i += 6;\n } while (i + 2 < pointArray.length);\n bezierPath.adjustCircular = adjustCircular !== null && adjustCircular !== void 0 ? adjustCircular : false;\n if (adjustCircular) {\n bezierPath.bezierCurves[bezierPath.bezierCurves.length - 1].endPoint = bezierPath.bezierCurves[0].startPoint;\n }\n bezierPath.updateArcLengths();\n return bezierPath;\n };\n // +---------------------------------------------------------------------------------\n // | These constants equal the values from CubicBezierCurve.\n // +-------------------------------\n /** @constant {number} */\n BezierPath.START_POINT = 0;\n /** @constant {number} */\n BezierPath.START_CONTROL_POINT = 1;\n /** @constant {number} */\n BezierPath.END_CONTROL_POINT = 2;\n /** @constant {number} */\n BezierPath.END_POINT = 3;\n return BezierPath;\n}());\nexports.BezierPath = BezierPath;\n//# sourceMappingURL=BezierPath.js.map","\"use strict\";\n/**\n * @author Ikaros Kappler\n * @date_init 2012-10-17 (Wrote a first version of this in that year).\n * @date 2018-04-03 (Refactored the code into a new class).\n * @modified 2018-04-28 Added some documentation.\n * @modified 2019-09-11 Added the scaleToCentroid(Number) function (used by the walking triangle demo).\n * @modified 2019-09-12 Added beautiful JSDoc compliable comments.\n * @modified 2019-11-07 Added to toSVG(options) function to make Triangles renderable as SVG.\n * @modified 2019-12-09 Fixed the determinant() function. The calculation was just wrong.\n * @modified 2020-03-16 (Corona times) Added the 'fromArray' function.\n * @modified 2020-03-17 Added the Triangle.toPolygon() function.\n * @modified 2020-03-17 Added proper JSDoc comments.\n * @modified 2020-03-25 Ported this class from vanilla-JS to Typescript.\n * @modified 2020-05-09 Added the new Circle class (ported to Typescript from the demos).\n * @modified 2020-05-12 Added getIncircularTriangle() function.\n * @modified 2020-05-12 Added getIncircle() function.\n * @modified 2020-05-12 Fixed the signature of getCircumcirle(). Was still a generic object.\n * @modified 2020-06-18 Added the `getIncenter` function.\n * @modified 2020-12-28 Added the `getArea` function.\n * @modified 2021-01-20 Added UID.\n * @modified 2021-01-22 Always updating circumcircle when retieving it.\n * @modified 2022-02-02 Added the `destroy` method.\n * @modified 2022-02-02 Cleared the `Triangle.toSVGString` function (deprecated). Use `drawutilssvg` instead.\n * @modified 2024-11-22 Added static utility function Triangle.utils.determinant; adapted method `determinant`.\n * @modified 2024-11-22 Changing visibility of `Triangle.utils` from `private` to `public`.\n * @modified 2025-14-16 Class `Triangle` now implements interface `Intersectable`.\n * @modified 2025-14-16 Class `Triangle` now implements interface `IBounded`.\n * @modified 2025-14-16 Class `Triangle` now implements interface `Intersectable`.\n * @modified 2025-14-16 Added method `Triangle.move`.\n * @modified 2026-06-10 Refactoring the `Trianble.bounds` method and added a plain `Triangle.utils.bounds` method.\n * @modified 2026-06-10 Refactoring the `Trianble.calcCircumCircle` method and added a plain `Triangle.utils.calcCircumCircle` method.\n * @modified 2026-06-13 Adding `Triangle.getVertices()`.\n * @version 2.11.0\n *\n * @file Triangle\n * @fileoverview A simple triangle class: three vertices.\n * @public\n **/\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Triangle = void 0;\nvar Bounds_1 = require(\"./Bounds\");\nvar Circle_1 = require(\"./Circle\");\nvar Line_1 = require(\"./Line\");\nvar Polygon_1 = require(\"./Polygon\");\nvar UIDGenerator_1 = require(\"./UIDGenerator\");\nvar Vector_1 = require(\"./Vector\");\nvar VertTuple_1 = require(\"./VertTuple\");\nvar Vertex_1 = require(\"./Vertex\");\nvar geomutils_1 = require(\"./geomutils\");\n/**\n * @classdesc A triangle class for triangulations.\n *\n * The class was written for a Delaunay trinagulation demo so it might\n * contain some strange and unexpected functions.\n *\n * @requires Bounds\n * @requires Circle\n * @requires Line\n * @requires Vertex\n * @requires Polygon\n * @requires SVGSerializale\n * @requires UID\n * @requires UIDGenerator\n * @requires geomutils\n *\n */\nvar Triangle = /** @class */ (function () {\n /**\n * The constructor.\n *\n * @constructor\n * @name Triangle\n * @param {Vertex} a - The first vertex of the triangle.\n * @param {Vertex} b - The second vertex of the triangle.\n * @param {Vertex} c - The third vertex of the triangle.\n **/\n function Triangle(a, b, c) {\n /**\n * Required to generate proper CSS classes and other class related IDs.\n **/\n this.className = \"Triangle\";\n this.uid = UIDGenerator_1.UIDGenerator.next();\n this.a = a;\n this.b = b;\n this.c = c;\n this.calcCircumcircle();\n }\n /**\n * Create a new triangle from the given array of vertices.\n *\n * The array must have at least three vertices, otherwise an error will be raised.\n * This function will not create copies of the vertices.\n *\n * @method fromArray\n * @static\n * @param {Array} arr - The required array with at least three vertices.\n * @memberof Vertex\n * @return {Triangle}\n **/\n Triangle.fromArray = function (arr) {\n if (arr.length < 3)\n throw \"Cannot create triangle from array with less than three vertices (\".concat(arr.length, \")\");\n return new Triangle(arr[0], arr[1], arr[2]);\n };\n /**\n * Get the area of this triangle. The returned area is never negative.\n *\n * If you are interested in the signed area, please consider using the\n * `Triangle.utils.signedArea` helper function. This method just returns\n * the absolute value of the signed area.\n *\n * @method getArea\n * @instance\n * @memberof Triangle\n * @return {number} The non-negative area of this triangle.\n */\n Triangle.prototype.getArea = function () {\n return Math.abs(Triangle.utils.signedArea(this.a.x, this.a.y, this.b.x, this.b.y, this.c.x, this.c.y));\n };\n /**\n * Get the centroid of this triangle.\n *\n * The centroid is the average midpoint for each side.\n *\n * @method getCentroid\n * @return {Vertex} The centroid\n * @instance\n * @memberof Triangle\n **/\n Triangle.prototype.getCentroid = function () {\n return new Vertex_1.Vertex((this.a.x + this.b.x + this.c.x) / 3, (this.a.y + this.b.y + this.c.y) / 3);\n };\n /**\n * Scale the triangle towards its centroid.\n *\n * @method scaleToCentroid\n * @param {number} - The scale factor to use. That can be any scalar.\n * @return {Triangle} this (for chaining)\n * @instance\n * @memberof Triangle\n */\n Triangle.prototype.scaleToCentroid = function (factor) {\n var centroid = this.getCentroid();\n this.a.scale(factor, centroid);\n this.b.scale(factor, centroid);\n this.c.scale(factor, centroid);\n return this;\n };\n //--- BEGIN --- Implement interface `IBounded`\n /**\n * Get the bounding box (bounds) of this Triangle.\n *\n * @method getBounds\n * @instance\n * @memberof Triangle\n * @return {Bounds} The rectangular bounds of this Triangle.\n **/\n Triangle.prototype.getBounds = function () {\n // return Bounds.computeFromVertices([this.a, this.b, this.c]);\n return this.bounds();\n };\n //--- END --- Implement interface `IBounded`\n /**\n * Move the Triangle's vertices by the given amount.\n *\n * @method move\n * @param {XYCoords} amount - The amount to move.\n * @instance\n * @memberof Triangle\n * @return {Triangle} this for chaining\n **/\n Triangle.prototype.move = function (amount) {\n this.a.add(amount);\n this.b.add(amount);\n this.c.add(amount);\n return this;\n };\n /**\n * Get the circumcircle of this triangle.\n *\n * The circumcircle is that unique circle on which all three\n * vertices of this triangle are located on.\n *\n * Please note that for performance reasons any changes to vertices will not reflect in changes\n * of the circumcircle (center or radius). Please call the calcCirumcircle() function\n * after triangle vertex changes.\n *\n * @method getCircumcircle\n * @return {Circle} - The circle touching exactly all three triangle vertices.\n * @instance\n * @memberof Triangle\n */\n Triangle.prototype.getCircumcircle = function () {\n // if( !this.center || !this.radius )\n this.calcCircumcircle();\n return new Circle_1.Circle(this.center.clone(), this.radius);\n };\n /**\n * Calculates the minimun enclosing circle.\n *\n * @method getMinimumEnclosingCircle\n * @return {Object} - { center:Vertex, radius:float }\n * @instance\n * @memberof Triangle\n * @returns\n */\n Triangle.prototype.getMinimumEnclosingCircle = function () {\n // First option: two points construct a circle and the third point is contained.\n var circleAB = VertTuple_1.VertTuple.vtutils.calcCircumcircle(this.a, this.b);\n if (Circle_1.Circle.circleUtils.containsPoint(circleAB.center, circleAB.radius, this.c)) {\n return Circle_1.Circle.fromICircle(circleAB);\n }\n var circleBC = VertTuple_1.VertTuple.vtutils.calcCircumcircle(this.b, this.c);\n if (Circle_1.Circle.circleUtils.containsPoint(circleBC.center, circleBC.radius, this.c)) {\n return Circle_1.Circle.fromICircle(circleBC);\n }\n var circleCA = VertTuple_1.VertTuple.vtutils.calcCircumcircle(this.c, this.a);\n if (Circle_1.Circle.circleUtils.containsPoint(circleCA.center, circleCA.radius, this.c)) {\n return Circle_1.Circle.fromICircle(circleCA);\n }\n // If none of the three upper cases applies: return the circumcircle.\n var circumCircle = Triangle.utils.calcCircumcircle(this.a, this.b, this.c);\n return Circle_1.Circle.fromICircle(circumCircle);\n };\n /**\n * Check if this triangle and the passed triangle share an\n * adjacent edge.\n *\n * For edge-checking Vertex.equals is used which uses an\n * an epsilon for comparison.\n *\n * @method isAdjacent\n * @param {Triangle} tri - The second triangle to check adjacency with.\n * @return {boolean} - True if this and the passed triangle have at least one common edge.\n * @instance\n * @memberof Triangle\n */\n Triangle.prototype.isAdjacent = function (tri) {\n var a = this.a.equals(tri.a) || this.a.equals(tri.b) || this.a.equals(tri.c);\n var b = this.b.equals(tri.a) || this.b.equals(tri.b) || this.b.equals(tri.c);\n var c = this.c.equals(tri.a) || this.c.equals(tri.b) || this.c.equals(tri.c);\n return (a && b) || (a && c) || (b && c);\n };\n /**\n * Get that vertex of this triangle (a,b,c) that is not vert1 nor vert2 of\n * the passed two.\n *\n * @method getThirdVertex\n * @param {Vertex} vert1 - The first vertex.\n * @param {Vertex} vert2 - The second vertex.\n * @return {Vertex} - The third vertex of this triangle that makes up the whole triangle with vert1 and vert2.\n * @instance\n * @memberof Triangle\n */\n Triangle.prototype.getThirdVertex = function (vert1, vert2) {\n if ((this.a.equals(vert1) && this.b.equals(vert2)) || (this.a.equals(vert2) && this.b.equals(vert1)))\n return this.c;\n if ((this.b.equals(vert1) && this.c.equals(vert2)) || (this.b.equals(vert2) && this.c.equals(vert1)))\n return this.a;\n //if( this.c.equals(vert1) && this.a.equals(vert2) || this.c.equals(vert2) && this.a.equals(vert1) )\n return this.b;\n };\n /**\n * Get the three triangele vertices in a 3-element array.\n *\n * @method getVertices\n * @returns {[Vertex, Vertex, Vertex]} - The three vertices – real instances, not copies.\n * @instance\n * @memberof Triangle\n */\n Triangle.prototype.getVertices = function () {\n return [this.a, this.b, this.c];\n };\n /**\n * Re-compute the circumcircle of this triangle (if the vertices\n * have changed).\n *\n * The circumcenter and radius are stored in this.center and\n * this.radius. There is a third result: radius_squared (for internal computations).\n *\n * @method calcCircumcircle\n * @return void\n * @instance\n * @memberof Triangle\n */\n Triangle.prototype.calcCircumcircle = function () {\n // // From\n // // http://www.exaflop.org/docs/cgafaq/cga1.html\n // const A: number = this.b.x - this.a.x;\n // const B: number = this.b.y - this.a.y;\n // const C: number = this.c.x - this.a.x;\n // const D: number = this.c.y - this.a.y;\n // const E: number = A * (this.a.x + this.b.x) + B * (this.a.y + this.b.y);\n // const F: number = C * (this.a.x + this.c.x) + D * (this.a.y + this.c.y);\n // const G: number = 2.0 * (A * (this.c.y - this.b.y) - B * (this.c.x - this.b.x));\n // let dx: number, dy: number;\n // if (Math.abs(G) < Triangle.EPSILON) {\n // // Collinear - find extremes and use the midpoint\n // const bounds: Bounds = this.bounds();\n // this.center = new Vertex((bounds.min.x + bounds.max.x) / 2, (bounds.min.y + bounds.max.y) / 2);\n // dx = this.center.x - bounds.min.x;\n // dy = this.center.y - bounds.min.y;\n // } else {\n // const cx: number = (D * E - B * F) / G;\n // const cy: number = (A * F - C * E) / G;\n // this.center = new Vertex(cx, cy);\n // dx = this.center.x - this.a.x;\n // dy = this.center.y - this.a.y;\n // }\n // this.radius_squared = dx * dx + dy * dy;\n // this.radius = Math.sqrt(this.radius_squared);\n var tmpCircle = Triangle.utils.calcCircumcircle(this.a, this.b, this.c);\n this.center = new Vertex_1.Vertex(tmpCircle.center.x, tmpCircle.center.y);\n this.radius = tmpCircle.radius;\n this.radius_squared = tmpCircle.radius_squared;\n }; // END calcCircumcircle\n /**\n * Check if the passed vertex is inside this triangle's\n * circumcircle.\n *\n * @method inCircumcircle\n * @param {Vertex} v - The vertex to check.\n * @return {boolean}\n * @instance\n * @memberof Triangle\n */\n Triangle.prototype.inCircumcircle = function (v) {\n var dx = this.center.x - v.x;\n var dy = this.center.y - v.y;\n var dist_squared = dx * dx + dy * dy;\n return dist_squared <= this.radius_squared;\n };\n /**\n * Get the rectangular bounds for this triangle.\n *\n * @method bounds\n * @return {Bounds} - The min/max bounds of this triangle.\n * @instance\n * @memberof Triangle\n */\n Triangle.prototype.bounds = function () {\n // return new Bounds(\n // 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)),\n // 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))\n // );\n return Triangle.utils.bounds(this.a, this.b, this.c);\n };\n //--- BEGIN --- Implement interface `Intersectable`\n /**\n * Get all line intersections with this polygon.\n *\n * This method returns all intersections (as vertices) with this shape. The returned array of vertices is in no specific order.\n *\n * See demo `47-closest-vector-projection-on-polygon` for how it works.\n *\n * @param {VertTuple} line - The line to find intersections with.\n * @param {boolean} inVectorBoundsOnly - If set to true only intersecion points on the passed vector are returned (located strictly between start and end vertex).\n * @returns {Array} - An array of all intersections within the polygon bounds.\n */\n Triangle.prototype.lineIntersections = function (line, inVectorBoundsOnly) {\n if (inVectorBoundsOnly === void 0) { inVectorBoundsOnly = false; }\n // Find the intersections of all lines inside the edge bounds\n return Polygon_1.Polygon.utils\n .locateLineIntersecion(line, [this.a, this.b, this.c], false, inVectorBoundsOnly)\n .map(function (intersectionTuple) { return intersectionTuple.intersection; });\n };\n /**\n * Get all line intersections of this polygon and their tangents along the shape.\n *\n * This method returns all intersection tangents (as vectors) with this shape. The returned array of vectors is in no specific order.\n *\n * @param line\n * @param inVectorBoundsOnly\n * @returns\n */\n Triangle.prototype.lineIntersectionTangents = function (line, inVectorBoundsOnly) {\n var _this = this;\n if (inVectorBoundsOnly === void 0) { inVectorBoundsOnly = false; }\n // Find the intersection tangents of all lines inside the edge bounds\n return Polygon_1.Polygon.utils\n .locateLineIntersecion(line, [this.a, this.b, this.c], false, inVectorBoundsOnly)\n .map(function (intersectionTuple) {\n // const polyLine = this.getEdgeAt(intersectionTuple.edgeIndex);\n var polyLine = _this.getEdgeAt(intersectionTuple.edgeIndex);\n return new Vector_1.Vector(polyLine.a.clone(), polyLine.b.clone()).moveTo(intersectionTuple.intersection);\n });\n };\n //--- END --- Implement interface `Intersectable`\n Triangle.prototype.getEdgeAt = function (edgeIndex) {\n var modIndex = edgeIndex % 3;\n return modIndex === 0 ? new Line_1.Line(this.a, this.b) : modIndex === 1 ? new Line_1.Line(this.b, this.c) : new Line_1.Line(this.c, this.a);\n };\n /**\n * Convert this triangle to a polygon instance.\n *\n * Plase note that this conversion does not perform a deep clone.\n *\n * @method toPolygon\n * @return {Polygon} A new polygon representing this triangle.\n * @instance\n * @memberof Triangle\n **/\n Triangle.prototype.toPolygon = function () {\n return new Polygon_1.Polygon([this.a, this.b, this.c]);\n };\n /**\n * Get the determinant of this triangle.\n *\n * @method determinant\n * @return {number} - The determinant (float).\n * @instance\n * @memberof Triangle\n */\n Triangle.prototype.determinant = function () {\n // (b.y - a.y)*(c.x - b.x) - (c.y - b.y)*(b.x - a.x);\n // return (this.b.y - this.a.y) * (this.c.x - this.b.x) - (this.c.y - this.b.y) * (this.b.x - this.a.x);\n return Triangle.utils.determinant(this.a, this.b, this.c);\n };\n /**\n * Checks if the passed vertex (p) is inside this triangle.\n *\n * Note: matrix determinants rock.\n *\n * @method containsPoint\n * @param {Vertex} p - The vertex to check.\n * @return {boolean}\n * @instance\n * @memberof Triangle\n */\n Triangle.prototype.containsPoint = function (p) {\n return Triangle.utils.pointIsInTriangle(p.x, p.y, this.a.x, this.a.y, this.b.x, this.b.y, this.c.x, this.c.y);\n };\n /**\n * Get that inner triangle which defines the maximal incircle.\n *\n * @return {Triangle} The triangle of those points in this triangle that define the incircle.\n */\n Triangle.prototype.getIncircularTriangle = function () {\n var lineA = new Line_1.Line(this.a, this.b);\n var lineB = new Line_1.Line(this.b, this.c);\n var lineC = new Line_1.Line(this.c, this.a);\n var bisector1 = geomutils_1.geomutils.nsectAngle(this.b, this.a, this.c, 2)[0]; // bisector of first angle (in b)\n var bisector2 = geomutils_1.geomutils.nsectAngle(this.c, this.b, this.a, 2)[0]; // bisector of second angle (in c)\n // Cast to non-null here because we know there _is_ an intersection\n var intersection = bisector1.intersection(bisector2);\n // Find the closest points on one of the polygon lines (all have same distance by construction)\n var circleIntersA = lineA.getClosestPoint(intersection);\n var circleIntersB = lineB.getClosestPoint(intersection);\n var circleIntersC = lineC.getClosestPoint(intersection);\n return new Triangle(circleIntersA, circleIntersB, circleIntersC);\n };\n /**\n * Get the incircle of this triangle. That is the circle that touches each side\n * of this triangle in exactly one point.\n *\n * Note this just calls getIncircularTriangle().getCircumcircle()\n *\n * @return {Circle} The incircle of this triangle.\n */\n Triangle.prototype.getIncircle = function () {\n return this.getIncircularTriangle().getCircumcircle();\n };\n /**\n * Get the incenter of this triangle (which is the center of the circumcircle).\n *\n * Note: due to performance reasonst the incenter is buffered inside the triangle because\n * computing it is relatively expensive. If a, b or c have changed you should call the\n * calcCircumcircle() function first, otherwise you might get wrong results.\n * @return Vertex The incenter of this triangle.\n **/\n Triangle.prototype.getIncenter = function () {\n if (!this.center || !this.radius) {\n this.calcCircumcircle();\n }\n return this.center.clone();\n };\n /**\n * Converts this triangle into a human-readable string.\n *\n * @method toString\n * @return {string}\n * @instance\n * @memberof Triangle\n */\n Triangle.prototype.toString = function () {\n return \"{ a : \" + this.a.toString() + \", b : \" + this.b.toString() + \", c : \" + this.c.toString() + \"}\";\n };\n /**\n * This function should invalidate any installed listeners and invalidate this object.\n * After calling this function the object might not hold valid data any more and\n * should not be used.\n */\n Triangle.prototype.destroy = function () {\n this.a.destroy();\n this.b.destroy();\n this.c.destroy();\n this.isDestroyed = true;\n };\n /**\n * An epsilon for comparison.\n * This should be the same epsilon as in Vertex.\n *\n * @private\n **/\n Triangle.EPSILON = 1.0e-6;\n Triangle.utils = {\n // Used in the bounds() function.\n max3: function (a, b, c) {\n return a >= b && a >= c ? a : b >= a && b >= c ? b : c;\n },\n min3: function (a, b, c) {\n return a <= b && a <= c ? a : b <= a && b <= c ? b : c;\n },\n signedArea: function (p0x, p0y, p1x, p1y, p2x, p2y) {\n return 0.5 * (-p1y * p2x + p0y * (-p1x + p2x) + p0x * (p1y - p2y) + p1x * p2y);\n },\n /**\n * Used by the containsPoint() function.\n *\n * @private\n **/\n pointIsInTriangle: function (px, py, p0x, p0y, p1x, p1y, p2x, p2y) {\n //\n // Point-in-Triangle test found at\n // http://stackoverflow.com/questions/2049582/how-to-determine-a-point-in-a-2d-triangle\n // var area : number = 1/2*(-p1y*p2x + p0y*(-p1x + p2x) + p0x*(p1y - p2y) + p1x*p2y);\n var area = Triangle.utils.signedArea(p0x, p0y, p1x, p1y, p2x, p2y);\n var s = (1 / (2 * area)) * (p0y * p2x - p0x * p2y + (p2y - p0y) * px + (p0x - p2x) * py);\n var t = (1 / (2 * area)) * (p0x * p1y - p0y * p1x + (p0y - p1y) * px + (p1x - p0x) * py);\n return s > 0 && t > 0 && 1 - s - t > 0;\n },\n /**\n * Calculate the determinant of the three vertices a, b and c (in this order).\n * @param {XYCords} a - The first vertex.\n * @param {XYCords} b - The first vertex.\n * @param {XYCords} c - The first vertex.\n * @returns {nmber}\n */\n determinant: function (a, b, c) {\n return (b.y - a.y) * (c.x - b.x) - (c.y - b.y) * (b.x - a.x);\n },\n bounds: function (a, b, c) {\n 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)));\n },\n /**\n * Re-compute the circumcircle of this triangle (if the vertices\n * have changed).\n *\n * The circumcenter and radius are stored in this.center and\n * this.radius. There is a third result: radius_squared (for internal computations).\n *\n * @method calcCircumcircle\n * @return void\n * @instance\n * @memberof Triangle\n */\n calcCircumcircle: function (a, b, c) {\n // From\n // http://www.exaflop.org/docs/cgafaq/cga1.html\n var A = b.x - a.x;\n var B = b.y - a.y;\n var C = c.x - a.x;\n var D = c.y - a.y;\n var E = A * (a.x + b.x) + B * (a.y + b.y);\n var F = C * (a.x + c.x) + D * (a.y + c.y);\n var G = 2.0 * (A * (c.y - b.y) - B * (c.x - b.x));\n var dx, dy;\n var center;\n if (Math.abs(G) < Triangle.EPSILON) {\n // Collinear - find extremes and use the midpoint\n // const bounds: Bounds = this.bounds();\n var bounds = Triangle.utils.bounds(a, b, c);\n center = new Vertex_1.Vertex((bounds.min.x + bounds.max.x) / 2, (bounds.min.y + bounds.max.y) / 2);\n dx = center.x - bounds.min.x;\n dy = center.y - bounds.min.y;\n }\n else {\n var cx = (D * E - B * F) / G;\n var cy = (A * F - C * E) / G;\n center = new Vertex_1.Vertex(cx, cy);\n dx = center.x - a.x;\n dy = center.y - a.y;\n }\n var radius_squared = dx * dx + dy * dy;\n var radius = Math.sqrt(radius_squared);\n return { center: center, radius: radius, radius_squared: radius_squared };\n } // END calcCircumcircle\n };\n return Triangle;\n}());\nexports.Triangle = Triangle;\n//# sourceMappingURL=Triangle.js.map","\"use strict\";\n/**\n * @author Ikaros Kappler\n * @date 2012-10-17\n * @modified 2018-04-03 Refactored the code of october 2012 into a new class.\n * @modified 2018-04-28 Added some documentation.\n * @modified 2018-08-16 Added the set() function.\n * @modified 2018-08-26 Added VertexAttr.\n * @modified 2018-10-31 Extended the constructor by object{x,y}.\n * @modified 2018-11-19 Extended the set(number,number) function to set(Vertex).\n * @modified 2018-11-28 Added 'this' to the VertexAttr constructor.\n * @modified 2018-12-05 Added the sub(...) function. Changed the signature of the add() function! add(Vertex) and add(number,number) are now possible.\n * @modified 2018-12-21 (It's winter solstice) Added the inv()-function.\n * @modified 2019-01-30 Added the setX(Number) and setY(Number) functions.\n * @modified 2019-02-19 Added the difference(Vertex) function.\n * @modified 2019-03-20 Added JSDoc tags.\n * @modified 2019-04-24 Added the randomVertex(ViewPort) function.\n * @modified 2019-11-07 Added toSVGString(object) function.\n * @modified 2019-11-18 Added the rotate(number,Vertex) function.\n * @modified 2019-11-21 Fixed a bug in the rotate(...) function (elements were moved).\n * @modified 2020-03-06 Added functions invX() and invY().\n * @modified 2020-03-23 Ported to Typescript from JS.\n * @modified 2020-05-26 Added functions addX(number) and addY(number).\n * @modified 2020-10-30 Changed the warnings in `sub(...)` and `add(...)` into real errors.\n * @modified 2021-03-01 Changed the second param `center` in the `rotate` function from Vertex to XYCoords.\n * @modified 2021-12-01 Changed the type of param of `scale` to XYCoords.\n * @modified 2021-12-01 Added function `scaleXY` for non uniform scaling.\n * @modified 2021-12-17 Added the functions `lerp` and `lerpAbs` for linear interpolations.\n * @modified 2022-01-31 Added `Vertex.utils.arrayToJSON`.\n * @modified 2022-02-02 Added the `destroy` method.\n * @modified 2022-02-02 Cleared the `Vertex.toSVGString` function (deprecated). Use `drawutilssvg` instead.\n * @modified 2022-11-28 Added the `subXY`, `subX` and `subY` methods to the `Vertex` class.\n * @modified 2023-09-29 Downgraded types for the `Vertex.utils.buildArrowHead` function (replacing Vertex params by more generic XYCoords type).\n * @modified 2023-09-29 Added the `Vertex.abs()` method as it seems useful.\n * @modified 2024-03-08 Added the optional `precision` param to the `toString` method.\n * @modified 2024-12-17 Outsourced the euclidean distance calculation of `Vertex.distance` to `geomutils.dist4`.\n * @modified 2025-03-24 Making the second parameter `center` of the `Vertex.rotate` method optional.\n * @modified 2025-04-13 Adding the `Vertex.move(amount: XYCoords)` method (does the same as `add`, added by naming convention).\n * @modified 2025-05-07 Class `Vertex` is now implementing interface `IBounded` (to meet convention).\n * @modified 2026-06-10 Adding methods `Vertex.findClosestPoint` and `Vertex.findFarestPoint`.\n * @version 2.12.0\n *\n * @file Vertex\n * @public\n **/\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Vertex = void 0;\nvar VertexAttr_1 = require(\"./VertexAttr\");\nvar UIDGenerator_1 = require(\"./UIDGenerator\");\nvar VertexListeners_1 = require(\"./VertexListeners\");\nvar geomutils_1 = require(\"./geomutils\");\nvar Bounds_1 = require(\"./Bounds\");\n/**\n * @classdesc A vertex is a pair of two numbers.
\n *
\n * It is used to identify a 2-dimensional point on the x-y-plane.\n *\n * @requires IVertexAttr\n * @requires SVGSerializable\n * @requires UID\n * @requires UIDGenerator\n * @requires VertexAttr\n * @requires VertexListeners\n * @requires XYCoords\n *\n */\nvar Vertex = /** @class */ (function () {\n /**\n * The constructor for the vertex class.\n *\n * @constructor\n * @name Vertex\n * @param {number} x - The x-coordinate of the new vertex.\n * @param {number} y - The y-coordinate of the new vertex.\n **/\n function Vertex(x, y) {\n /**\n * Required to generate proper CSS classes and other class related IDs.\n **/\n this.className = \"Vertex\";\n this.uid = UIDGenerator_1.UIDGenerator.next();\n if (typeof x == \"undefined\") {\n this.x = 0;\n this.y = 0;\n }\n else if (typeof x == \"number\" && typeof y == \"number\") {\n this.x = x;\n this.y = y;\n }\n else {\n var tuple = x;\n if (typeof tuple.x == \"number\" && typeof tuple.y == \"number\") {\n this.x = tuple.x;\n this.y = tuple.y;\n }\n else {\n if (typeof x == \"number\")\n this.x = x;\n else if (typeof x == \"undefined\")\n this.x = 0;\n else\n this.x = NaN;\n if (typeof y == \"number\")\n this.y = y;\n else if (typeof y == \"undefined\")\n this.y = 0;\n else\n this.y = NaN;\n }\n }\n this.attr = new VertexAttr_1.VertexAttr();\n this.listeners = new VertexListeners_1.VertexListeners(this);\n }\n /**\n * Set the x- and y- component of this vertex.\n *\n * @method set\n * @param {number} x - The new x-component.\n * @param {number} y - The new y-component.\n * @return {Vertex} this\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.set = function (x, y) {\n if (typeof x == \"number\" && typeof y == \"number\") {\n this.x = x;\n this.y = y;\n }\n else {\n var tuple = x;\n if (typeof tuple.x == \"number\" && typeof tuple.y == \"number\") {\n this.x = tuple.x;\n this.y = tuple.y;\n }\n else {\n if (typeof x == \"number\")\n this.x = x;\n else if (typeof x == \"undefined\")\n this.x = 0;\n else\n this.x = NaN;\n if (typeof y == \"number\")\n this.y = y;\n else if (typeof y == \"undefined\")\n this.y = 0;\n else\n this.y = NaN;\n }\n }\n return this;\n };\n /**\n * Set the x-component of this vertex.\n *\n * @method setX\n * @param {number} x - The new x-component.\n * @return {Vertex} this\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.setX = function (x) {\n this.x = x;\n return this;\n };\n /**\n * Set the y-component of this vertex.\n *\n * @method setY\n * @param {number} y - The new y-component.\n * @return {Vertex} this\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.setY = function (y) {\n this.y = y;\n return this;\n };\n /**\n * Set the x-component if this vertex to the inverse of its value.\n *\n * @method invX\n * @return {Vertex} this\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.invX = function () {\n this.x = -this.x;\n return this;\n };\n /**\n * Set the y-component if this vertex to the inverse of its value.\n *\n * @method invY\n * @return {Vertex} this\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.invY = function () {\n this.y = -this.y;\n return this;\n };\n /**\n * Add the passed amount to x- and y- component of this vertex.
\n *
\n * This function works with add( {number}, {number} ) and\n * add( {Vertex} ), as well.\n *\n * @method add\n * @param {(number|Vertex)} x - The amount to add to x (or a vertex itself).\n * @param {number=} y - The amount to add to y.\n * @return {Vertex} this\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.add = function (x, y) {\n if (typeof x == \"number\" && typeof y == \"number\") {\n this.x += x;\n this.y += y;\n }\n else {\n var tuple = x;\n if (typeof tuple.x == \"number\" && typeof tuple.y == \"number\") {\n this.x += tuple.x;\n this.y += tuple.y;\n }\n else {\n if (typeof x == \"number\")\n this.x += x;\n else\n throw \"Cannot add \".concat(typeof x, \" to numeric x component!\");\n if (typeof y == \"number\")\n this.y += y;\n else\n throw \"Cannot add \".concat(typeof y, \" to numeric y component!\");\n }\n }\n return this;\n };\n /**\n * Move this point by the given amount.\n *\n * This method just calls `add(amount).\n *\n *\n * @method move\n * @param {Vertex} amount - The amount to move this vertex.\n * @return {Vertex} this - For chaining.\n * @instance\n * @memberof Vertex\n */\n Vertex.prototype.move = function (amount) {\n return this.add(amount);\n };\n /**\n * Add the passed amounts to the x- and y- components of this vertex.\n *\n * @method addXY\n * @param {number} x - The amount to add to x.\n * @param {number} y - The amount to add to y.\n * @return {Vertex} this\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.addXY = function (amountX, amountY) {\n this.x += amountX;\n this.y += amountY;\n return this;\n };\n /**\n * Add the passed amounts to the x-component of this vertex.\n *\n * @method addX\n * @param {number} x - The amount to add to x.\n * @return {Vertex} this\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.addX = function (amountX) {\n this.x += amountX;\n return this;\n };\n /**\n * Add the passed amounts to the y-component of this vertex.\n *\n * @method addY\n * @param {number} y - The amount to add to y.\n * @return {Vertex} this\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.addY = function (amountY) {\n this.y += amountY;\n return this;\n };\n /**\n * Substract the passed amount from x- and y- component of this vertex.
\n *
\n * This function works with sub( {number}, {number} ) and\n * sub( {Vertex} ), as well.\n *\n * @method sub\n * @param {(number|Vertex)} x - The amount to substract from x (or a vertex itself).\n * @param {number=} y - The amount to substract from y.\n * @return {Vertex} this\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.sub = function (x, y) {\n if (typeof x == \"number\" && typeof y == \"number\") {\n this.x -= x;\n this.y -= y;\n }\n else {\n var tuple = x;\n if (typeof tuple.x == \"number\" && typeof tuple.y == \"number\") {\n this.x -= tuple.x;\n this.y -= tuple.y;\n }\n else {\n if (typeof x == \"number\")\n this.x -= x;\n else\n throw \"Cannot add \".concat(typeof x, \" to numeric x component!\");\n if (typeof y == \"number\")\n this.y -= y;\n else\n throw \"Cannot add \".concat(typeof y, \" to numeric y component!\");\n }\n }\n return this;\n };\n /**\n * Substract the passed amounts from the x- and y- components of this vertex.\n *\n * @method subXY\n * @param {number} x - The amount to substract from x.\n * @param {number} y - The amount to substract from y.\n * @return {Vertex} this\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.subXY = function (amountX, amountY) {\n this.x -= amountX;\n this.y -= amountY;\n return this;\n };\n /**\n * Substract the passed amounts from the x-component of this vertex.\n *\n * @method addX\n * @param {number} x - The amount to substract from x.\n * @return {Vertex} this\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.subX = function (amountX) {\n this.x -= amountX;\n return this;\n };\n /**\n * Substract the passed amounts from the y-component of this vertex.\n *\n * @method subY\n * @param {number} y - The amount to substract from y.\n * @return {Vertex} this\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.subY = function (amountY) {\n this.y -= amountY;\n return this;\n };\n /**\n * Check if this vertex equals the passed one.\n *
\n * This function uses an internal epsilon as tolerance.\n *\n * @method equals\n * @param {Vertex} vertex - The vertex to compare this with.\n * @return {boolean}\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.equals = function (vertex) {\n var eqX = Math.abs(this.x - vertex.x) < Vertex.EPSILON;\n var eqY = Math.abs(this.y - vertex.y) < Vertex.EPSILON;\n var result = eqX && eqY;\n return result;\n };\n /**\n * Create a copy of this vertex.\n *\n * @method clone\n * @return {Vertex} A new vertex, an exact copy of this.\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.clone = function () {\n return new Vertex(this.x, this.y);\n };\n /**\n * Get the distance to the passed point (in euclidean metric)\n *\n * @method distance\n * @param {XYCoords} vert - The vertex to measure the distance to.\n * @return {number}\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.distance = function (vert) {\n // return Math.sqrt(Math.pow(vert.x - this.x, 2) + Math.pow(vert.y - this.y, 2));\n return geomutils_1.geomutils.dist4(this.x, this.y, vert.x, vert.y);\n };\n /**\n * Get the angle of this point (relative to (0,0) or to the given other origin point).\n *\n * @method angle\n * @param {XYCoords} origin - The vertex to measure the angle from.\n * @return {number}\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.angle = function (origin) {\n var a = typeof origin === \"undefined\"\n ? Math.PI / 2 - Math.atan2(this.x, this.y)\n : Math.PI / 2 - Math.atan2(origin.x - this.x, origin.y - this.y);\n // Map to positive value\n return a < 0 ? Math.PI * 2 + a : a;\n };\n /**\n * Get the difference to the passed point.
\n *
\n * The difference is (vert.x-this.x, vert.y-this.y).\n *\n * @method difference\n * @param {Vertex} vert - The vertex to measure the x-y-difference to.\n * @return {Vertex} A new vertex.\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.difference = function (vert) {\n return new Vertex(vert.x - this.x, vert.y - this.y);\n };\n /**\n * This is a vector-like behavior and 'scales' this vertex\n * towards/from a given center by one uniform scale factor.\n *\n * @method scale\n * @param {number} factor - The factor to 'scale' this vertex; 1.0 means no change.\n * @param {XYCoords=} center - The origin of scaling; default is (0,0).\n * @return {Vertex} this\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.scale = function (factor, center) {\n return this.scaleXY({ x: factor, y: factor }, center);\n };\n /**\n * Perform a linear interpolation towards the given target vertex.\n * The amount value `t` is relative, `t=0.0` means no change, `t=1.0`\n * means this point will be moved to the exact target position.\n *\n * `t=0.5` will move this point to the middle of the connecting\n * linear segment.\n *\n * @param {XYCoords} target - The target position to lerp this vertex to.\n * @param {number} t - The relative amount, usually in [0..1], but other values will work, too.\n * @returns\n */\n Vertex.prototype.lerp = function (target, t) {\n var diff = this.difference(target);\n // return new Vertex(this.x + diff.x * t, this.y + diff.y * t);\n this.x += diff.x * t;\n this.y += diff.y * t;\n return this;\n };\n /**\n * Perform a linear interpolation towards the given target vertex (absolute variant).\n * The amount value `t` is absolute, which means the lerp amount is a direct distance\n * value. This point will have move the amount of the passed distance `u`.\n *\n * @param {XYCoords} target - The target position to lerp this vertex to.\n * @param {number} t - The absolute move amount to use to lerping.\n * @returns\n */\n Vertex.prototype.lerpAbs = function (target, u) {\n var dist = this.distance(target);\n var diff = this.difference(target);\n var step = { x: diff.x / dist, y: diff.y / dist };\n // return new Vertex(this.x + step.x * u, this.y + step.y * u);\n this.x += step.x * u;\n this.y += step.y * u;\n return this;\n };\n /**\n * This is a vector-like behavior and 'scales' this vertex\n * towards/from a given center by two independent x- and y- scale factors.\n *\n * @method scale\n * @param {number} factor - The factor to 'scale' this vertex; 1.0 means no change.\n * @param {XYCoords=} center - The origin of scaling; default is (0,0).\n * @return {Vertex} this\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.scaleXY = function (factors, center) {\n if (!center || typeof center === \"undefined\") {\n center = { x: 0, y: 0 };\n }\n this.x = center.x + (this.x - center.x) * factors.x;\n this.y = center.y + (this.y - center.y) * factors.y;\n return this;\n };\n /**\n * This is a vector-like behavior and 'rotates' this vertex\n * around given center.\n *\n * @method rotate\n * @param {number} angle - The angle to 'rotate' this vertex; 0.0 means no change.\n * @param {XYCoords=} center - The center of rotation; default is (0,0).\n * @return {Vertex} this\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.rotate = function (angle, center) {\n if (!center || typeof center === \"undefined\") {\n center = { x: 0, y: 0 };\n }\n this.sub(center);\n angle += Math.atan2(this.y, this.x);\n var len = this.distance(Vertex.ZERO); // {x:0,y:0});\n this.x = len * Math.cos(angle);\n this.y = len * Math.sin(angle);\n this.add(center);\n return this;\n };\n /**\n * Multiply both components of this vertex with the given scalar.
\n *
\n * Note: as in
\n * https://threejs.org/docs/#api/math/Vector2.multiplyScalar\n *\n * @method multiplyScalar\n * @param {number} scalar - The scale factor; 1.0 means no change.\n * @return {Vertex} this\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.multiplyScalar = function (scalar) {\n this.x *= scalar;\n this.y *= scalar;\n return this;\n };\n /**\n * Round the two components x and y of this vertex.\n *\n * @method round\n * @return {Vertex} this\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.round = function () {\n this.x = Math.round(this.x);\n this.y = Math.round(this.y);\n return this;\n };\n /**\n * Change this vertex (x,y) to its inverse (-x,-y).\n *\n * @method inv\n * @return {Vertex} this\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.inv = function () {\n this.x = -this.x;\n this.y = -this.y;\n return this;\n };\n /**\n * Set both coordinates of this vertex to their absolute value (abs(x), abs(y)).\n *\n * @method abs\n * @return {Vertex} this\n * @instance\n * @memberof Vertex\n */\n Vertex.prototype.abs = function () {\n this.x = Math.abs(this.x);\n this.y = Math.abs(this.y);\n return this;\n };\n //--- BEGIN --- Implement interface `IBounded`\n /**\n * Get the bounding box (bounds) of this Vertex.\n * This is just by convention – any vertex is just a position without any useful with or height (0).\n *\n * @method getBounds\n * @instance\n * @memberof Vertex\n * @return {Bounds} The rectangular bounds of this Vertex (width and height are zero).\n **/\n Vertex.prototype.getBounds = function () {\n // return Bounds.computeFromVertices([this.a, this.b, this.c]);\n return Bounds_1.Bounds.computeFromVertices([this]);\n };\n //--- END --- Implement interface `IBounded`\n /**\n * Find the one of two given points that's closest to this point.\n *\n * @method findClosestPoint\n * @instance\n * @memberof Vertex\n * @param {XYCoords | Vertex} pointA\n * @param {XYCoords | Vertex} pointB\n * @returns {XYCoords | Vertex}\n */\n Vertex.prototype.findClosestPoint = function (pointA, pointB) {\n // TODO: put this implementation to geomutils?\n var distA = this.distance(pointA);\n var distB = this.distance(pointB);\n if (distA < distB) {\n return pointA;\n }\n else {\n return pointB;\n }\n };\n /**\n * Find the one of two given points that's farest from this point.\n *\n * @method findFarestPoint\n * @instance\n * @memberof Vertex\n * @param {XYCoords | Vertex} pointA\n * @param {XYCoords | Vertex} pointB\n * @returns {XYCoords | Vertex}\n */\n Vertex.prototype.findFarestPoint = function (pointA, pointB) {\n var distA = this.distance(pointA);\n var distB = this.distance(pointB);\n if (distA > distB) {\n return pointA;\n }\n else {\n return pointB;\n }\n };\n /**\n * Get a string representation of this vertex.\n *\n * @method toString\n * @return {string} The string representation of this vertex.\n * @instance\n * @memberof Vertex\n **/\n Vertex.prototype.toString = function (precision) {\n if (typeof precision === \"undefined\") {\n return \"(\" + this.x + \",\" + this.y + \")\";\n }\n else {\n return \"(\" + this.x.toFixed(precision) + \",\" + this.y.toFixed(precision) + \")\";\n }\n };\n /**\n * This function should invalidate any installed listeners and invalidate this object.\n * After calling this function the object might not hold valid data any more and\n * should not be used.\n */\n Vertex.prototype.destroy = function () {\n this.listeners.removeAllListeners();\n this.isDestroyed = true;\n };\n /**\n * Create a new random vertex inside the given viewport.\n *\n * @param {ViewPort} viewPort - A {min:Vertex, max:Vertex} viewport specifying the bounds.\n * @return A new vertex with a random position.\n **/\n Vertex.randomVertex = function (viewPort) {\n return new Vertex(viewPort.min.x + Math.random() * (viewPort.max.x - viewPort.min.x), viewPort.min.y + Math.random() * (viewPort.max.y - viewPort.min.y));\n };\n Vertex.ZERO = new Vertex(0, 0);\n /**\n * An epsilon for comparison\n *\n * @private\n * @readonly\n **/\n Vertex.EPSILON = 1.0e-6;\n Vertex.utils = {\n /**\n * Generate a four-point arrow head, starting at the vector end minus the\n * arrow head length.\n *\n * The first vertex in the returned array is guaranteed to be the located\n * at the vector line end minus the arrow head length.\n *\n *\n * Due to performance all params are required.\n *\n * The params scaleX and scaleY are required for the case that the scaling is not uniform (x and y\n * scaling different). Arrow heads should not look distored on non-uniform scaling.\n *\n * If unsure use 1.0 for scaleX and scaleY (=no distortion).\n * For headlen use 8, it's a good arrow head size.\n *\n * Example:\n * buildArrowHead( new Vertex(0,0), new Vertex(50,100), 8, 1.0, 1.0 )\n *\n * @param {XYCoords} zA - The start vertex of the vector to calculate the arrow head for.\n * @param {XYCoords} zB - The end vertex of the vector.\n * @param {number} headlen - The length of the arrow head (along the vector direction. A good value is 12).\n * @param {number} scaleX - The horizontal scaling during draw.\n * @param {number} scaleY - the vertical scaling during draw.\n **/\n // @DEPRECATED: use Vector.utils.buildArrowHead instead!!!\n buildArrowHead: function (zA, zB, headlen, scaleX, scaleY) {\n console.warn(\"[DEPRECATION] Vertex.utils.buildArrowHead is deprecated. Please use Vector.utils.buildArrowHead instead.\");\n var angle = Math.atan2((zB.y - zA.y) * scaleY, (zB.x - zA.x) * scaleX);\n var vertices = [];\n vertices.push(new Vertex(zB.x * scaleX - headlen * Math.cos(angle), zB.y * scaleY - headlen * Math.sin(angle)));\n vertices.push(new Vertex(zB.x * scaleX - headlen * 1.35 * Math.cos(angle - Math.PI / 8), zB.y * scaleY - headlen * 1.35 * Math.sin(angle - Math.PI / 8)));\n vertices.push(new Vertex(zB.x * scaleX, zB.y * scaleY));\n vertices.push(new Vertex(zB.x * scaleX - headlen * 1.35 * Math.cos(angle + Math.PI / 8), zB.y * scaleY - headlen * 1.35 * Math.sin(angle + Math.PI / 8)));\n return vertices;\n },\n /**\n * Convert the given vertices (array) to a JSON string.\n *\n * @param {number?} precision - (optional) The numeric precision to be used (number of precision digits).\n * @returns {string}\n */\n arrayToJSON: function (vertices, precision) {\n return JSON.stringify(vertices.map(function (vert) {\n return typeof precision === undefined\n ? { x: vert.x, y: vert.y }\n : { x: Number(vert.x.toFixed(precision)), y: Number(vert.y.toFixed(precision)) };\n }));\n }\n };\n return Vertex;\n}());\nexports.Vertex = Vertex;\n//# sourceMappingURL=Vertex.js.map","\"use strict\";\n/**\n * @author Ikaros Kappler\n * @date 2019-01-30\n * @modified 2019-03-23 Added JSDoc tags.\n * @modified 2020-03-25 Ported this class from vanilla-JS to Typescript.\n * @modified 2021-01-20 Added UID.\n * @modified 2022-02-02 Added the `destroy` method.\n * @modified 2022-02-02 Cleared the `PBImage.toSVGString` function (deprecated). Use `drawutilssvg` instead.\n * @version 1.2.0\n *\n * @file PBImage\n * @fileoverview As native Image objects have only a position and with\n * and height thei are not suitable for UI dragging interfaces.\n * @public\n **/\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.PBImage = void 0;\nvar UIDGenerator_1 = require(\"./UIDGenerator\");\n/**\n * @classdesc A wrapper for image objects. Has an upper left and a lower right corner point.\n *\n * @requires Vertex\n * @requires SVGSerializable\n * @requires UID\n * @requires UIDGenerator\n */\nvar PBImage = /** @class */ (function () {\n /**\n * The constructor.\n *\n * @constructor\n * @name PBImage\n * @param {Image} image - The actual image.\n * @param {Vertex} upperLeft - The upper left corner.\n * @param {Vertex} lowerRight - The lower right corner.\n **/\n function PBImage(image, upperLeft, lowerRight) {\n /**\n * Required to generate proper CSS classes and other class related IDs.\n **/\n this.className = \"PBImage\";\n this.uid = UIDGenerator_1.UIDGenerator.next();\n this.image = image;\n this.upperLeft = upperLeft;\n this.lowerRight = lowerRight;\n }\n /**\n * This function should invalidate any installed listeners and invalidate this object.\n * After calling this function the object might not hold valid data any more and\n * should not be used.\n */\n PBImage.prototype.destroy = function () {\n this.upperLeft.destroy();\n this.lowerRight.destroy();\n this.isDestroyed = true;\n };\n return PBImage;\n}());\nexports.PBImage = PBImage;\n//# sourceMappingURL=PBImage.js.map","\"use strict\";\n/**\n * @author Ikaros Kappler\n * @date 2018-11-28\n * @modified 2018-12-04 Added the toSVGString function.\n * @modified 2020-03-25 Ported this class from vanilla-JS to Typescript.\n * @modified 2021-01-20 Added UID.\n * @modified 2021-02-14 Added functions `radiusH` and `radiusV`.\n * @modified 2021-02-26 Added helper function `decribeSVGArc(...)`.\n * @modified 2021-03-01 Added attribute `rotation` to allow rotation of ellipses.\n * @modified 2021-03-03 Added the `vertAt` and `perimeter` methods.\n * @modified 2021-03-05 Added the `getFoci`, `normalAt` and `tangentAt` methods.\n * @modified 2021-03-09 Added the `clone` and `rotate` methods.\n * @modified 2021-03-10 Added the `toCubicBezier` method.\n * @modified 2021-03-15 Added `VEllipse.quarterSegmentCount` and `VEllipse.scale` functions.\n * @modified 2021-03-19 Added the `VEllipse.rotate` function.\n * @modified 2022-02-02 Added the `destroy` method.\n * @modified 2022-02-02 Cleared the `VEllipse.toSVGString` function (deprecated). Use `drawutilssvg` instead.\n * @modified 2025-03-31 ATTENTION: modified the winding direction of the `tangentAt` method to match with the Circle method. This is a breaking change!\n * @modified 2025-03-31 Adding the `VEllipse.move(amount: XYCoords)` method.\n * @modified 2025-04-19 Adding the `VEllipse.getBounds()` method.\n * @modified 2025-04-24 Adding the `VEllipse.getExtremePoints()` method for calculating minima and maxima.\n * @version 1.4.0\n *\n * @file VEllipse\n * @fileoverview Ellipses with a center and an x- and a y-axis (stored as a vertex).\n **/\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.VEllipse = void 0;\nvar Line_1 = require(\"./Line\");\nvar Vector_1 = require(\"./Vector\");\nvar Vertex_1 = require(\"./Vertex\");\nvar UIDGenerator_1 = require(\"./UIDGenerator\");\nvar CubicBezierCurve_1 = require(\"./CubicBezierCurve\");\nvar Circle_1 = require(\"./Circle\");\nvar Bounds_1 = require(\"./Bounds\");\n/**\n * @classdesc An ellipse class based on two vertices [centerX,centerY] and [radiusX,radiusY].\n *\n * @requires SVGSerializable\n * @requires UID\n * @requires UIDGenerator\n * @requires Vertex\n */\nvar VEllipse = /** @class */ (function () {\n /**\n * The constructor.\n *\n * @constructor\n * @param {Vertex} center - The ellipses center.\n * @param {Vertex} axis - The x- and y-axis (the two radii encoded in a control point).\n * @param {Vertex} rotation - [optional, default=0] The rotation of this ellipse.\n * @name VEllipse\n **/\n function VEllipse(center, axis, rotation) {\n /**\n * Required to generate proper CSS classes and other class related IDs.\n **/\n this.className = \"VEllipse\";\n this.uid = UIDGenerator_1.UIDGenerator.next();\n this.center = center;\n this.axis = axis;\n this.rotation = rotation || 0.0;\n }\n /**\n * Clone this ellipse (deep clone).\n *\n * @return {VEllipse} A copy of this ellipse.s\n */\n VEllipse.prototype.clone = function () {\n return new VEllipse(this.center.clone(), this.axis.clone(), this.rotation);\n };\n /**\n * Get the non-negative horizonal radius of this ellipse.\n *\n * @method radiusH\n * @instance\n * @memberof VEllipse\n * @return {number} The unsigned horizontal radius of this ellipse.\n */\n VEllipse.prototype.radiusH = function () {\n return Math.abs(this.signedRadiusH());\n };\n /**\n * Get the signed horizonal radius of this ellipse.\n *\n * @method signedRadiusH\n * @instance\n * @memberof VEllipse\n * @return {number} The signed horizontal radius of this ellipse.\n */\n VEllipse.prototype.signedRadiusH = function () {\n // return Math.abs(this.axis.x - this.center.x);\n // Rotate axis back to origin before calculating radius\n // return Math.abs(new Vertex(this.axis).rotate(-this.rotation,this.center).x - this.center.x);\n return new Vertex_1.Vertex(this.axis).rotate(-this.rotation, this.center).x - this.center.x;\n };\n /**\n * Get the non-negative vertical radius of this ellipse.\n *\n * @method radiusV\n * @instance\n * @memberof VEllipse\n * @return {number} The unsigned vertical radius of this ellipse.\n */\n VEllipse.prototype.radiusV = function () {\n return Math.abs(this.signedRadiusV());\n };\n /**\n * Get the signed vertical radius of this ellipse.\n *\n * @method radiusV\n * @instance\n * @memberof VEllipse\n * @return {number} The signed vertical radius of this ellipse.\n */\n VEllipse.prototype.signedRadiusV = function () {\n // Rotate axis back to origin before calculating radius\n return new Vertex_1.Vertex(this.axis).rotate(-this.rotation, this.center).y - this.center.y;\n };\n /**\n * Get the the minima and maxima (points) of this (rotated) ellipse.\n *\n * @method getExtremePoints\n * @instance\n * @memberof VEllipse\n * @return {[Vertex, Vertex, Vertex, Vertex]} Get the the minima and maxima (points) of this (rotated) ellipse.\n */\n VEllipse.prototype.getExtremePoints = function () {\n var a = this.radiusH();\n var b = this.radiusV();\n // Calculate t_x values\n var t_x1 = Math.atan2(-b * Math.sin(this.rotation), a * Math.cos(this.rotation));\n var t_x2 = t_x1 + Math.PI;\n // Calculate x values at t_x\n var x_x1 = this.center.x + a * Math.cos(t_x1) * Math.cos(this.rotation) - b * Math.sin(t_x1) * Math.sin(this.rotation);\n var y_x1 = this.center.y + a * Math.cos(t_x1) * Math.sin(this.rotation) + b * Math.sin(t_x1) * Math.cos(this.rotation);\n var x_x2 = this.center.x + a * Math.cos(t_x2) * Math.cos(this.rotation) - b * Math.sin(t_x2) * Math.sin(this.rotation);\n var y_x2 = this.center.y + a * Math.cos(t_x2) * Math.sin(this.rotation) + b * Math.sin(t_x2) * Math.cos(this.rotation);\n var x_max, x_min;\n if (x_x1 > x_x2) {\n x_max = new Vertex_1.Vertex(x_x1, y_x1);\n x_min = new Vertex_1.Vertex(x_x2, y_x2);\n }\n else {\n x_max = new Vertex_1.Vertex(x_x2, y_x2);\n x_min = new Vertex_1.Vertex(x_x1, y_x1);\n }\n // Calculate t_y values\n var t_y1 = Math.atan2(b * Math.cos(this.rotation), a * Math.sin(this.rotation));\n var t_y2 = t_y1 + Math.PI;\n // Calculate y values at t_y\n var x_y1 = this.center.x + a * Math.cos(t_y1) * Math.cos(this.rotation) - b * Math.sin(t_y1) * Math.sin(this.rotation);\n var y_y1 = this.center.y + a * Math.cos(t_y1) * Math.sin(this.rotation) + b * Math.sin(t_y1) * Math.cos(this.rotation);\n var x_y2 = this.center.x + a * Math.cos(t_y2) * Math.cos(this.rotation) - b * Math.sin(t_y2) * Math.sin(this.rotation);\n var y_y2 = this.center.y + a * Math.cos(t_y2) * Math.sin(this.rotation) + b * Math.sin(t_y2) * Math.cos(this.rotation);\n var y_max, y_min;\n if (y_y1 > y_y2) {\n y_max = new Vertex_1.Vertex(x_y1, y_y1);\n y_min = new Vertex_1.Vertex(x_y2, y_y2);\n }\n else {\n y_max = new Vertex_1.Vertex(x_y2, y_y2);\n y_min = new Vertex_1.Vertex(x_y1, y_y1);\n }\n return [x_max, x_min, y_max, y_min];\n };\n //--- BEGIN --- Implement interface `IBounded`\n /**\n * Get the bounds of this ellipse.\n *\n * The bounds are approximated by the underlying segment buffer; the more segment there are,\n * the more accurate will be the returned bounds.\n *\n * @method getBounds\n * @instance\n * @memberof VEllipse\n * @return {Bounds} The bounds of this ellipse.\n **/\n VEllipse.prototype.getBounds = function () {\n // Thanks to Cuixiping\n // https://stackoverflow.com/questions/87734/how-do-you-calculate-the-axis-aligned-bounding-box-of-an-ellipse\n var r1 = this.radiusH();\n var r2 = this.radiusV();\n var ux = r1 * Math.cos(this.rotation);\n var uy = r1 * Math.sin(this.rotation);\n var vx = r2 * Math.cos(this.rotation + Math.PI / 2);\n var vy = r2 * Math.sin(this.rotation + Math.PI / 2);\n var bbox_halfwidth = Math.sqrt(ux * ux + vx * vx);\n var bbox_halfheight = Math.sqrt(uy * uy + vy * vy);\n return new Bounds_1.Bounds({ x: this.center.x - bbox_halfwidth, y: this.center.y - bbox_halfheight }, { x: this.center.x + bbox_halfwidth, y: this.center.y + bbox_halfheight });\n };\n //--- BEGIN --- Implement interface `IBounded`\n /**\n * Move the ellipse by the given amount. This is equivalent by moving the `center` and `axis` points.\n *\n * @method move\n * @param {XYCoords} amount - The amount to move.\n * @instance\n * @memberof VEllipse\n * @return {VEllipse} this for chaining\n **/\n VEllipse.prototype.move = function (amount) {\n this.center.add(amount);\n this.axis.add(amount);\n return this;\n };\n /**\n * Scale this ellipse by the given factor from the center point. The factor will be applied to both radii.\n *\n * @method scale\n * @instance\n * @memberof VEllipse\n * @param {number} factor - The factor to scale by.\n * @return {VEllipse} this for chaining.\n */\n VEllipse.prototype.scale = function (factor) {\n this.axis.scale(factor, this.center);\n return this;\n };\n /**\n * Rotate this ellipse around its center.\n *\n * @method rotate\n * @instance\n * @memberof VEllipse\n * @param {number} angle - The angle to rotate by.\n * @returns {VEllipse} this for chaining.\n */\n VEllipse.prototype.rotate = function (angle) {\n this.axis.rotate(angle, this.center);\n this.rotation += angle;\n return this;\n };\n /**\n * Get the vertex on the ellipse's outline at the given angle.\n *\n * @method vertAt\n * @instance\n * @memberof VEllipse\n * @param {number} angle - The angle to determine the vertex at.\n * @return {Vertex} The vertex on the outline at the given angle.\n */\n VEllipse.prototype.vertAt = function (angle) {\n // Tanks to Narasinham for the vertex-on-ellipse equations\n // https://math.stackexchange.com/questions/22064/calculating-a-point-that-lies-on-an-ellipse-given-an-angle\n var a = this.radiusH();\n var b = this.radiusV();\n return new Vertex_1.Vertex(VEllipse.utils.polarToCartesian(this.center.x, this.center.y, a, b, angle)).rotate(this.rotation, this.center);\n };\n /**\n * Get the normal vector at the given angle.\n * The normal vector is the vector that intersects the ellipse in a 90 degree angle\n * at the given point (speicified by the given angle).\n *\n * Length of desired normal vector can be specified, default is 1.0.\n *\n * @method normalAt\n * @instance\n * @memberof VEllipse\n * @param {number} angle - The angle to get the normal vector at.\n * @param {number=1.0} length - [optional, default=1] The length of the returned vector.\n */\n VEllipse.prototype.normalAt = function (angle, length) {\n var point = this.vertAt(angle - this.rotation); // HERE IS THE CORRECT BEHAVIOR!\n var foci = this.getFoci();\n // Calculate the angle between [point,focusA] and [point,focusB]\n var angleA = new Line_1.Line(point, foci[0]).angle();\n var angleB = new Line_1.Line(point, foci[1]).angle();\n var centerAngle = angleA + (angleB - angleA) / 2.0;\n var endPointA = point.clone().addX(50).clone().rotate(centerAngle, point);\n var endPointB = point\n .clone()\n .addX(50)\n .clone()\n .rotate(Math.PI + centerAngle, point);\n var resultVector = this.center.distance(endPointA) < this.center.distance(endPointB)\n ? new Vector_1.Vector(point, endPointB)\n : new Vector_1.Vector(point, endPointA);\n if (typeof length === \"number\") {\n resultVector.setLength(length);\n }\n return resultVector;\n };\n /**\n * Get the tangent vector at the given angle.\n * The tangent vector is the vector that touches the ellipse exactly at the given given\n * point (speicified by the given angle).\n *\n * Note that the tangent is just 90 degree rotated normal vector.\n *\n * Length of desired tangent vector can be specified, default is 1.0.\n *\n * @method tangentAt\n * @instance\n * @memberof VEllipse\n * @param {number} angle - The angle to get the tangent vector at.\n * @param {number=1.0} length - [optional, default=1] The length of the returned vector.\n */\n VEllipse.prototype.tangentAt = function (angle, length) {\n var normal = this.normalAt(angle, length);\n return normal.inv().perp();\n };\n /**\n * Get the perimeter of this ellipse.\n *\n * @method perimeter\n * @instance\n * @memberof VEllipse\n * @return {number}\n */\n VEllipse.prototype.perimeter = function () {\n // This method does not use an iterative approximation to determine the perimeter, but it uses\n // a wonderful closed approximation found by Srinivasa Ramanujan.\n // Matt Parker made a neat video about it:\n // https://www.youtube.com/watch?v=5nW3nJhBHL0\n var a = this.radiusH();\n var b = this.radiusV();\n return Math.PI * (3 * (a + b) - Math.sqrt((3 * a + b) * (a + 3 * b)));\n };\n /**\n * Get the two foci of this ellipse.\n *\n * @method getFoci\n * @instance\n * @memberof VEllipse\n * @return {Array} An array with two elements, the two focal points of the ellipse (foci).\n */\n VEllipse.prototype.getFoci = function () {\n // https://www.mathopenref.com/ellipsefoci.html\n var rh = this.radiusH();\n var rv = this.radiusV();\n var sdiff = rh * rh - rv * rv;\n // f is the distance of each focs to the center.\n var f = Math.sqrt(Math.abs(sdiff));\n // Foci on x- or y-axis?\n if (sdiff < 0) {\n return [\n this.center.clone().addY(f).rotate(this.rotation, this.center),\n this.center.clone().addY(-f).rotate(this.rotation, this.center)\n ];\n }\n else {\n return [\n this.center.clone().addX(f).rotate(this.rotation, this.center),\n this.center.clone().addX(-f).rotate(this.rotation, this.center)\n ];\n }\n };\n /**\n * Get equally distributed points on the outline of this ellipse.\n *\n * @method getEquidistantVertices\n * @instance\n * @param {number} pointCount - The number of points.\n * @returns {Array}\n */\n VEllipse.prototype.getEquidistantVertices = function (pointCount) {\n var angles = VEllipse.utils.equidistantVertAngles(this.radiusH(), this.radiusV(), pointCount);\n var result = [];\n for (var i = 0; i < angles.length; i++) {\n result.push(this.vertAt(angles[i]));\n }\n return result;\n };\n //--- BEGIN --- Implement interface `Intersectable`\n /**\n * Get the line intersections as vectors with this ellipse.\n *\n * @method lineIntersections\n * @instance\n * @param {VertTuple ray - The line/ray to intersect this ellipse with.\n * @param {boolean} inVectorBoundsOnly - (default=false) Set to true if only intersections within the vector bounds are of interest.\n * @returns\n */\n VEllipse.prototype.lineIntersections = function (ray, inVectorBoundsOnly) {\n // Question: what happens to extreme versions when ellipse is a line (width or height is zero)?\n // This would result in a Division_by_Zero exception!\n if (inVectorBoundsOnly === void 0) { inVectorBoundsOnly = false; }\n // Step A: create clones for operations (keep originals unchanged)\n var ellipseCopy = this.clone(); // VEllipse\n var rayCopy = ray.clone(); // Vector\n // Step B: move both so ellipse's center is located at (0,0)\n var moveAmount = ellipseCopy.center.clone().inv();\n ellipseCopy.move(moveAmount);\n rayCopy.add(moveAmount);\n // Step C: rotate eclipse backwards it's rotation, so that rotation is zero (0.0).\n // Rotate together with ray!\n var rotationAmount = -ellipseCopy.rotation;\n ellipseCopy.rotate(rotationAmount); // Rotation around (0,0) = center of translated ellipse\n rayCopy.a.rotate(rotationAmount, ellipseCopy.center);\n rayCopy.b.rotate(rotationAmount, ellipseCopy.center);\n // Step D: find x/y factors to use for scaling to transform the ellipse to a circle.\n // Scale together with vector ray.\n var radiusH = ellipseCopy.radiusH();\n var radiusV = ellipseCopy.radiusV();\n var scalingFactors = radiusH > radiusV ? { x: radiusV / radiusH, y: 1.0 } : { x: 1.0, y: radiusH / radiusV };\n // Step E: scale ellipse AND ray by calculated factors.\n ellipseCopy.axis.scaleXY(scalingFactors);\n rayCopy.a.scaleXY(scalingFactors);\n rayCopy.b.scaleXY(scalingFactors);\n // Intermediate result: now the ellipse is transformed to a circle and we can calculate intersections :)\n // Step F: calculate circle+line intersecions\n var tmpCircle = new Circle_1.Circle(new Vertex_1.Vertex(), ellipseCopy.radiusH()); // radiusH() === radiusV()\n var intersections = tmpCircle.lineIntersections(rayCopy, inVectorBoundsOnly);\n // Step G: transform intersecions back to original configuration\n intersections.forEach(function (intersectionPoint) {\n // Reverse transformation from above.\n intersectionPoint.scaleXY({ x: 1 / scalingFactors.x, y: 1 / scalingFactors.y }, ellipseCopy.center);\n intersectionPoint.rotate(-rotationAmount, ellipseCopy.center);\n intersectionPoint.sub(moveAmount);\n });\n return intersections;\n };\n /**\n * Get all line intersections of this polygon and their tangents along the shape.\n *\n * This method returns all intersection tangents (as vectors) with this shape. The returned array of vectors is in no specific order.\n *\n * @param line\n * @param lineIntersectionTangents\n * @returns\n */\n VEllipse.prototype.lineIntersectionTangents = function (line, inVectorBoundsOnly) {\n var _this = this;\n if (inVectorBoundsOnly === void 0) { inVectorBoundsOnly = false; }\n // Find the intersections of all lines plus their tangents inside the circle bounds\n var interSectionPoints = this.lineIntersections(line, inVectorBoundsOnly);\n return interSectionPoints.map(function (vert) {\n // Calculate angle\n var lineFromCenter = new Line_1.Line(_this.center, vert);\n var angle = lineFromCenter.angle();\n // Calculate tangent at angle\n return _this.tangentAt(angle);\n });\n };\n //--- END --- Implement interface `Intersectable`\n /**\n * Convert this ellipse into cubic Bézier curves.\n *\n * @param {number=3} quarterSegmentCount - The number of segments per base elliptic quarter (default is 3, min is 1).\n * @param {number=0.666666} threshold - The Bézier threshold (default value 0.666666 approximates the ellipse with best results\n * but you might wish to use other values)\n * @return {Array} An array of cubic Bézier curves representing this ellipse.\n */\n VEllipse.prototype.toCubicBezier = function (quarterSegmentCount, threshold) {\n // Math by Luc Maisonobe\n // http://www.spaceroots.org/documents/ellipse/node22.html\n // Note that ellipses with radiusH=0 or radiusV=0 cannot be represented as Bézier curves.\n // Return a single line here (as a Bézier curve)?\n // if (Math.abs(this.radiusV()) < 0.00001) {\n // const radiusH = this.radiusH();\n // return [\n // new CubicBezierCurve(\n // this.center.clone().addX(radiusH),\n // this.center.clone().addX(-radiusH),\n // this.center.clone(),\n // this.center.clone()\n // )\n // ]; // TODO: test horizontal line ellipse\n // }\n // if (Math.abs(this.radiusH()) < 0.00001) {\n // const radiusV = this.radiusV();\n // return [\n // new CubicBezierCurve(\n // this.center.clone().addY(radiusV),\n // this.center.clone().addY(-radiusV),\n // this.center.clone(),\n // this.center.clone()\n // )\n // ]; // TODO: test vertical line ellipse\n // }\n // At least 4, but 16 seems to be a good value.\n var segmentCount = Math.max(1, quarterSegmentCount || 3) * 4;\n threshold = typeof threshold === \"undefined\" ? 0.666666 : threshold;\n var radiusH = this.radiusH();\n var radiusV = this.radiusV();\n var curves = [];\n var angles = VEllipse.utils.equidistantVertAngles(radiusH, radiusV, segmentCount);\n var curAngle = angles[0] + this.rotation;\n var startPoint = this.vertAt(curAngle);\n for (var i = 0; i < angles.length; i++) {\n var nextAngle = angles[(i + 1) % angles.length] + this.rotation;\n var endPoint = this.vertAt(nextAngle);\n if (Math.abs(radiusV) < 0.0001 || Math.abs(radiusH) < 0.0001) {\n // Distorted ellipses can only be approximated by linear Bézier segments\n var diff = startPoint.difference(endPoint);\n var curve = new CubicBezierCurve_1.CubicBezierCurve(startPoint.clone(), endPoint.clone(), startPoint.clone().addXY(diff.x * 0.333, diff.y * 0.333), endPoint.clone().addXY(-diff.x * 0.333, -diff.y * 0.333));\n curves.push(curve);\n }\n else {\n var startTangent = this.tangentAt(curAngle + this.rotation);\n var endTangent = this.tangentAt(nextAngle + this.rotation);\n // Find intersection (ignore that the result might be null in some extreme cases)\n var intersection = startTangent.intersection(endTangent);\n // What if intersection is undefined?\n // --> This *can* not happen if segmentCount > 2 and height and width of the ellipse are not zero.\n var startDiff = startPoint.difference(intersection);\n var endDiff = endPoint.difference(intersection);\n var curve = new CubicBezierCurve_1.CubicBezierCurve(startPoint.clone(), endPoint.clone(), startPoint.clone().add(startDiff.scale(threshold)), endPoint.clone().add(endDiff.scale(threshold)));\n curves.push(curve);\n }\n startPoint = endPoint;\n curAngle = nextAngle;\n }\n return curves;\n };\n /**\n * This function should invalidate any installed listeners and invalidate this object.\n * After calling this function the object might not hold valid data any more and\n * should not be used.\n */\n VEllipse.prototype.destroy = function () {\n this.center.destroy();\n this.axis.destroy();\n this.isDestroyed = true;\n };\n /**\n * A static collection of ellipse-related helper functions.\n * @static\n */\n VEllipse.utils = {\n /**\n * Calculate a particular point on the outline of the given ellipse (center plus two radii plus angle).\n *\n * @name polarToCartesian\n * @param {number} centerX - The x coordinate of the elliptic center.\n * @param {number} centerY - The y coordinate of the elliptic center.\n * @param {number} radiusH - The horizontal radius of the ellipse.\n * @param {number} radiusV - The vertical radius of the ellipse.\n * @param {number} angle - The angle (in radians) to get the desired outline point for.\n * @reutn {XYCoords} The outlont point in absolute x-y-coordinates.\n */\n polarToCartesian: function (centerX, centerY, radiusH, radiusV, angle) {\n // Tanks to Narasinham for the vertex-on-ellipse equations\n // https://math.stackexchange.com/questions/22064/calculating-a-point-that-lies-on-an-ellipse-given-an-angle\n var s = Math.sin(Math.PI / 2 - angle);\n var c = Math.cos(Math.PI / 2 - angle);\n return {\n x: centerX + (radiusH * radiusV * s) / Math.sqrt(Math.pow(radiusH * c, 2) + Math.pow(radiusV * s, 2)),\n y: centerY + (radiusH * radiusV * c) / Math.sqrt(Math.pow(radiusH * c, 2) + Math.pow(radiusV * s, 2))\n };\n },\n /**\n * Get the `theta` for a given `phi` (used to determine equidistant points on ellipse).\n *\n * @param radiusH\n * @param radiusV\n * @param phi\n * @returns {number} theta\n */\n phiToTheta: function (radiusH, radiusV, phi) {\n // See https://math.stackexchange.com/questions/172766/calculating-equidistant-points-around-an-ellipse-arc\n var tanPhi = Math.tan(phi);\n var tanPhi2 = tanPhi * tanPhi;\n var theta = -Math.PI / 2 + phi + Math.atan(((radiusH - radiusV) * tanPhi) / (radiusV + radiusH * tanPhi2));\n return theta;\n },\n /**\n * Get n equidistant points on the elliptic arc.\n *\n * @param pointCount\n * @returns\n */\n equidistantVertAngles: function (radiusH, radiusV, pointCount) {\n var angles = [];\n for (var i = 0; i < pointCount; i++) {\n var phi = Math.PI / 2.0 + ((Math.PI * 2) / pointCount) * i;\n var theta = VEllipse.utils.phiToTheta(radiusH, radiusV, phi);\n angles[i] = theta;\n }\n return angles;\n }\n }; // END utils\n return VEllipse;\n}());\nexports.VEllipse = VEllipse;\n//# sourceMappingURL=VEllipse.js.map","\"use strict\";\n/**\n * @author Ikaros Kappler\n * @date 2018-03-19\n * @modified 2018-04-28 Added the param 'wasDragged'.\n * @modified 2018-08-16 Added the param 'dragAmount'.\n * @modified 2018-08-27 Added the param 'element'.\n * @modified 2018-11-11 Changed the scope from a simple global var to a member of window/_context.\n * @modified 2018-11-19 Renamed the 'mousedown' function to 'down' and the 'mouseup' function to 'up'.\n * @modified 2018-11-28 Added the 'wheel' listener.\n * @modified 2018-12-09 Cleaned up some code.\n * @modified 2019-02-10 Cleaned up some more code.\n * @modified 2020-03-25 Ported this class from vanilla-JS to Typescript.\n * @modified 2020-04-08 Fixed the click event (internally fired a 'mouseup' event) (1.0.10)\n * @modified 2020-04-08 Added the optional 'name' property. (1.0.11)\n * @modified 2020-04-08 The new version always installs internal listenrs to track drag events even\n * if there is no external drag listener installed (1.1.0).\n * @modified 2020-10-04 Added extended JSDoc comments.\n * @modified 2020-11-25 Added the `isTouchEvent` param.\n * @modified 2021-01-10 The mouse handler is now also working with SVGElements.\n * @modified 2022-08-16 Fixed a bug in the mouse button detection.\n * @version 1.2.1\n *\n * @file MouseHandler\n * @public\n **/\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n if (typeof b !== \"function\" && b !== null)\n throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MouseHandler = exports.XWheelEvent = exports.XMouseEvent = void 0;\nvar XMouseEvent = /** @class */ (function (_super) {\n __extends(XMouseEvent, _super);\n function XMouseEvent() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n return XMouseEvent;\n}(MouseEvent));\nexports.XMouseEvent = XMouseEvent;\nvar XWheelEvent = /** @class */ (function (_super) {\n __extends(XWheelEvent, _super);\n function XWheelEvent() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n return XWheelEvent;\n}(WheelEvent));\nexports.XWheelEvent = XWheelEvent;\n/**\n * @classdesc A simple mouse handler for demos.\n * Use to avoid load massive libraries like jQuery.\n *\n * @requires XYCoords\n */\nvar MouseHandler = /** @class */ (function () {\n /**\n * The constructor.\n *\n * Pass the DOM element you want to receive mouse events from.\n *\n * Usage\n * =====\n * @example\n * // Javascript\n * new MouseHandler( document.getElementById('mycanvas') )\n *\t .drag( function(e) {\n *\t\tconsole.log( 'Mouse dragged: ' + JSON.stringify(e) );\n *\t\tif( e.params.leftMouse ) ;\n *\t\telse if( e.params.rightMouse ) ;\n *\t } )\n *\t .move( function(e) {\n *\t\tconsole.log( 'Mouse moved: ' + JSON.stringify(e.params) );\n *\t } )\n * .up( function(e) {\n * console.log( 'Mouse up. Was dragged?', e.params.wasDragged );\n * } )\n * .down( function(e) {\n * console.log( 'Mouse down.' );\n * } )\n * .click( function(e) {\n * console.log( 'Click.' );\n * } )\n * .wheel( function(e) {\n * console.log( 'Wheel. delta='+e.deltaY );\n * } )\n *\n * @example\n * // Typescript\n * new MouseHandler( document.getElementById('mycanvas') )\n *\t .drag( (e:XMouseEvent) => {\n *\t\tconsole.log( 'Mouse dragged: ' + JSON.stringify(e) );\n *\t\tif( e.params.leftMouse ) ;\n *\t\telse if( e.params.rightMouse ) ;\n *\t } )\n *\t .move( (e:XMouseEvent) => {\n *\t\tconsole.log( 'Mouse moved: ' + JSON.stringify(e.params) );\n *\t } )\n * .up( (e:XMouseEvent) => {\n * console.log( 'Mouse up. Was dragged?', e.params.wasDragged );\n * } )\n * .down( (e:XMouseEvent) => {\n * console.log( 'Mouse down.' );\n * } )\n * .click( (e:XMouseEvent) => {\n * console.log( 'Click.' );\n * } )\n * .wheel( (e:XWheelEvent) => {\n * console.log( 'Wheel. delta='+e.deltaY );\n * } )\n *\n * @constructor\n * @instance\n * @memberof MouseHandler\n * @param {HTMLElement} element\n **/\n function MouseHandler(element, name) {\n this.mouseDownPos = undefined;\n this.mouseDragPos = undefined;\n // TODO: cc\n // private mousePos : { x:number, y:number }|undefined = undefined;\n this.mouseButton = -1;\n this.listeners = {};\n this.installed = {};\n this.handlers = {};\n // +----------------------------------------------------------------------\n // | Some private vars to store the current mouse/position/button state.\n // +-------------------------------------------------\n this.name = name;\n this.element = element;\n this.mouseDownPos = undefined;\n this.mouseDragPos = undefined;\n // this.mousePos = null;\n this.mouseButton = -1;\n this.listeners = {};\n this.installed = {};\n this.handlers = {};\n // +----------------------------------------------------------------------\n // | Define the internal event handlers.\n // |\n // | They will dispatch the modified event (relative mouse position,\n // | drag offset, ...) to the callbacks.\n // +-------------------------------------------------\n var _self = this;\n this.handlers[\"mousemove\"] = function (e) {\n if (_self.listeners.mousemove)\n _self.listeners.mousemove(_self.mkParams(e, \"mousemove\"));\n if (_self.mouseDragPos && _self.listeners.drag)\n _self.listeners.drag(_self.mkParams(e, \"drag\"));\n if (_self.mouseDownPos)\n _self.mouseDragPos = _self.relPos(e);\n };\n this.handlers[\"mouseup\"] = function (e) {\n if (_self.listeners.mouseup)\n _self.listeners.mouseup(_self.mkParams(e, \"mouseup\"));\n _self.mouseDragPos = undefined;\n _self.mouseDownPos = undefined;\n _self.mouseButton = -1;\n };\n this.handlers[\"mousedown\"] = function (e) {\n _self.mouseDragPos = _self.relPos(e);\n _self.mouseDownPos = _self.relPos(e);\n _self.mouseButton = e.button;\n if (_self.listeners.mousedown)\n _self.listeners.mousedown(_self.mkParams(e, \"mousedown\"));\n };\n this.handlers[\"click\"] = function (e) {\n if (_self.listeners.click)\n _self.listeners.click(_self.mkParams(e, \"click\"));\n };\n this.handlers[\"wheel\"] = function (e) {\n if (_self.listeners.wheel)\n _self.listeners.wheel(_self.mkParams(e, \"wheel\"));\n };\n this.element.addEventListener(\"mousemove\", this.handlers[\"mousemove\"]);\n this.element.addEventListener(\"mouseup\", this.handlers[\"mouseup\"]);\n this.element.addEventListener(\"mousedown\", this.handlers[\"mousedown\"]);\n this.element.addEventListener(\"click\", this.handlers[\"click\"]);\n this.element.addEventListener(\"wheel\", this.handlers[\"wheel\"]);\n }\n /**\n * Get relative position from the given MouseEvent.\n *\n * @name relPos\n * @memberof MouseHandler\n * @instance\n * @private\n * @param {MouseEvent} e - The mouse event to get the relative position for.\n * @return {XYCoords} The relative mouse coordinates.\n */\n MouseHandler.prototype.relPos = function (e) {\n return { x: e.offsetX, y: e.offsetY };\n };\n /**\n * Build the extended event params.\n *\n * @name mkParams\n * @memberof MouseHandler\n * @instance\n * @private\n * @param {MouseEvent} event - The mouse event to get the relative position for.\n * @param {string} eventName - The name of the firing event.\n * @return {XMouseEvent}\n */\n MouseHandler.prototype.mkParams = function (event, eventName) {\n var _a, _b;\n var rel = this.relPos(event);\n var xEvent = event;\n xEvent.params = {\n element: this.element,\n name: eventName,\n isTouchEvent: false,\n pos: rel,\n button: event.button, // this.mouseButton,\n leftButton: event.button === 0, // this.mouseButton === 0,\n middleButton: event.button === 1, // this.mouseButton === 1,\n rightButton: event.button === 2, // this.mouseButton === 2,\n mouseDownPos: (_a = this.mouseDownPos) !== null && _a !== void 0 ? _a : { x: NaN, y: NaN },\n draggedFrom: (_b = this.mouseDragPos) !== null && _b !== void 0 ? _b : { x: NaN, y: NaN },\n wasDragged: this.mouseDownPos != null && (this.mouseDownPos.x != rel.x || this.mouseDownPos.y != rel.y),\n dragAmount: this.mouseDragPos != null ? { x: rel.x - this.mouseDragPos.x, y: rel.y - this.mouseDragPos.y } : { x: 0, y: 0 }\n };\n return xEvent;\n };\n /**\n * Install a new listener.\n * Please note that this mouse handler can only handle one listener per event type.\n *\n * @name listenFor\n * @memberof MouseHandler\n * @instance\n * @private\n * @param {string} eventName - The name of the firing event to listen for.\n * @return {void}\n */\n MouseHandler.prototype.listenFor = function (eventName) {\n if (this.installed[eventName])\n return;\n // In the new version 1.1.0 has all internal listeners installed by default.\n this.installed[eventName] = true;\n };\n /**\n * Un-install a new listener.\n *\n * @name listenFor\n * @memberof MouseHandler\n * @instance\n * @private\n * @param {string} eventName - The name of the firing event to unlisten for.\n * @return {void}\n */\n MouseHandler.prototype.unlistenFor = function (eventName) {\n if (!this.installed[eventName])\n return;\n // In the new version 1.1.0 has all internal listeners installed by default.\n delete this.installed[eventName];\n };\n /**\n * Installer function to listen for a specific event: mouse-drag.\n * Pass your callbacks here.\n *\n * Note: this support chaining.\n *\n * @name drag\n * @memberof MouseHandler\n * @instance\n * @param {XMouseCallback} callback - The drag-callback to listen for.\n * @return {MouseHandler} this\n */\n MouseHandler.prototype.drag = function (callback) {\n if (this.listeners.drag)\n this.throwAlreadyInstalled(\"drag\");\n this.listeners.drag = callback;\n this.listenFor(\"mousedown\");\n this.listenFor(\"mousemove\");\n this.listenFor(\"mouseup\");\n return this;\n };\n /**\n * Installer function to listen for a specific event: mouse-move.\n * Pass your callbacks here.\n *\n * Note: this support chaining.\n *\n * @name move\n * @memberof MouseHandler\n * @instance\n * @param {XMouseCallback} callback - The move-callback to listen for.\n * @return {MouseHandler} this\n */\n MouseHandler.prototype.move = function (callback) {\n if (this.listeners.mousemove)\n this.throwAlreadyInstalled(\"mousemove\");\n this.listenFor(\"mousemove\");\n this.listeners.mousemove = callback;\n return this;\n };\n /**\n * Installer function to listen for a specific event: mouse-up.\n * Pass your callbacks here.\n *\n * Note: this support chaining.\n *\n * @name up\n * @memberof MouseHandler\n * @instance\n * @param {XMouseCallback} callback - The up-callback to listen for.\n * @return {MouseHandler} this\n */\n MouseHandler.prototype.up = function (callback) {\n if (this.listeners.mouseup)\n this.throwAlreadyInstalled(\"mouseup\");\n this.listenFor(\"mouseup\");\n this.listeners.mouseup = callback;\n return this;\n };\n /**\n * Installer function to listen for a specific event: mouse-down.\n * Pass your callbacks here.\n *\n * Note: this support chaining.\n *\n * @name down\n * @memberof MouseHandler\n * @instance\n * @param {XMouseCallback} callback - The down-callback to listen for.\n * @return {MouseHandler} this\n */\n MouseHandler.prototype.down = function (callback) {\n if (this.listeners.mousedown)\n this.throwAlreadyInstalled(\"mousedown\");\n this.listenFor(\"mousedown\");\n this.listeners.mousedown = callback;\n return this;\n };\n /**\n * Installer function to listen for a specific event: mouse-click.\n * Pass your callbacks here.\n *\n * Note: this support chaining.\n *\n * @name click\n * @memberof MouseHandler\n * @instance\n * @param {XMouseCallback} callback - The click-callback to listen for.\n * @return {MouseHandler} this\n */\n MouseHandler.prototype.click = function (callback) {\n if (this.listeners.click)\n this.throwAlreadyInstalled(\"click\");\n this.listenFor(\"click\");\n this.listeners.click = callback;\n return this;\n };\n /**\n * Installer function to listen for a specific event: mouse-wheel.\n * Pass your callbacks here.\n *\n * Note: this support chaining.\n *\n * @name wheel\n * @memberof MouseHandler\n * @instance\n * @param {XWheelCallback} callback - The wheel-callback to listen for.\n * @return {MouseHandler} this\n */\n MouseHandler.prototype.wheel = function (callback) {\n if (this.listeners.wheel)\n this.throwAlreadyInstalled(\"wheel\");\n this.listenFor(\"wheel\");\n this.listeners.wheel = callback;\n return this;\n };\n /**\n * An internal function to throw events.\n *\n * @name throwAlreadyInstalled\n * @memberof MouseHandler\n * @instance\n * @private\n * @param {string} name - The name of the event.\n * @return {void}\n */\n MouseHandler.prototype.throwAlreadyInstalled = function (name) {\n throw \"This MouseHandler already has a '\".concat(name, \"' callback. To keep the code simple there is only room for one.\");\n };\n /**\n * Call this when your work is done.\n *\n * The function will un-install all event listeners.\n *\n * @name destroy\n * @memberof MouseHandler\n * @instance\n * @private\n * @return {void}\n */\n MouseHandler.prototype.destroy = function () {\n this.unlistenFor(\"mousedown\");\n this.unlistenFor(\"mousemove\");\n this.unlistenFor(\"moseup\");\n this.unlistenFor(\"click\");\n this.unlistenFor(\"wheel\");\n this.element.removeEventListener(\"mousemove\", this.handlers[\"mousemove\"]);\n this.element.removeEventListener(\"mouseup\", this.handlers[\"mousedown\"]);\n this.element.removeEventListener(\"mousedown\", this.handlers[\"mousedown\"]);\n this.element.removeEventListener(\"click\", this.handlers[\"click\"]);\n this.element.removeEventListener(\"wheel\", this.handlers[\"wheel\"]);\n };\n return MouseHandler;\n}());\nexports.MouseHandler = MouseHandler;\n//# sourceMappingURL=MouseHandler.js.map","\"use strict\";\n/**\n * @author Ikaros Kappler\n * @date 2018-08-27\n * @modified 2018-11-28 Added the vertex-param to the constructor and extended the event. Vertex events now have a 'params' attribute object.\n * @modified 2019-03-20 Added JSDoc tags.\n * @modified 2020-02-22 Added 'return this' to the add* functions (for chanining).\n * @modified 2020-03-23 Ported to Typescript from JS.\n * @modified 2020-11-17 Added the `click` handler.\n * @modified 2026-04-04 Adding null-listeners will now throw an error.\n * @version 1.2.0\n *\n * @file VertexListeners\n * @public\n **/\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.VertexListeners = void 0;\n/**\n * @classdesc An event listeners wrapper. This is just a set of three listener\n * queues (drag, dragStart, dragEnd) and their respective firing\n * functions.\n *\n */\nvar VertexListeners = /** @class */ (function () {\n /**\n * The constructor.\n *\n * @constructor\n * @name VertexListeners\n * @param {Vertex} vertex - The vertex to use these listeners on (just a backward reference).\n **/\n function VertexListeners(vertex) {\n this.click = [];\n this.drag = [];\n this.dragStart = [];\n this.dragEnd = [];\n this.vertex = vertex;\n }\n /**\n * Add a click listener.\n *\n * @method addClickListener\n * @param {VertexListeners~dragListener} listener - The click listener to add (a callback).\n * @return {VertexListeners} this (for chaining)\n * @instance\n * @memberof VertexListeners\n **/\n VertexListeners.prototype.addClickListener = function (listener) {\n VertexListeners._addListener(this.click, listener);\n return this;\n };\n /**\n * The click listener is a function with a single drag event param.\n * @callback VertexListeners~clickListener\n * @param {Event} e - The (extended) click event.\n */\n /**\n * Remove a drag listener.\n *\n * @method removeDragListener\n * @param {VertexListeners~dragListener} listener - The drag listener to remove (a callback).\n * @return {VertexListeners} this (for chaining)\n * @instance\n * @memberof VertexListeners\n **/\n VertexListeners.prototype.removeClickListener = function (listener) {\n this.click = VertexListeners._removeListener(this.click, listener);\n return this;\n };\n /**\n * The click listener is a function with a single drag event param.\n * @callback VertexListeners~clickListener\n * @param {Event} e - The (extended) click event.\n */\n /**\n * Add a drag listener.\n *\n * @method addDragListener\n * @param {VertexListeners~dragListener} listener - The drag listener to add (a callback).\n * @return {VertexListeners} this (for chaining)\n * @instance\n * @memberof VertexListeners\n **/\n VertexListeners.prototype.addDragListener = function (listener) {\n VertexListeners._addListener(this.drag, listener);\n return this;\n };\n /**\n * The drag listener is a function with a single drag event param.\n * @callback VertexListeners~dragListener\n * @param {Event} e - The (extended) drag event.\n */\n /**\n * Remove a drag listener.\n *\n * @method removeDragListener\n * @param {VertexListeners~dragListener} listener - The drag listener to remove (a callback).\n * @return {VertexListeners} this (for chaining)\n * @instance\n * @memberof VertexListeners\n **/\n VertexListeners.prototype.removeDragListener = function (listener) {\n this.drag = VertexListeners._removeListener(this.drag, listener);\n return this;\n };\n /**\n * Add a dragStart listener.\n *\n * @method addDragListener\n * @param {VertexListeners~dragStartListener} listener - The drag-start listener to add (a callback).\n * @return {VertexListeners} this (for chaining)\n * @instance\n * @memberof VertexListeners\n **/\n VertexListeners.prototype.addDragStartListener = function (listener) {\n VertexListeners._addListener(this.dragStart, listener);\n return this;\n };\n /**\n * The drag-start listener is a function with a single drag event param.\n * @callback VertexListeners~dragStartListener\n * @param {Event} e - The (extended) drag event.\n */\n /**\n * Remove a dragStart listener.\n *\n * @method addDragStartListener\n * @param {VertexListeners~dragListener} listener - The drag listener to remove (a callback).\n * @return {VertexListeners} this (for chaining)\n * @instance\n * @memberof VertexListeners\n **/\n VertexListeners.prototype.removeDragStartListener = function (listener) {\n this.dragStart = VertexListeners._removeListener(this.dragStart, listener);\n return this;\n };\n /**\n * Add a dragEnd listener.\n *\n * @method addDragListener\n * @param {VertexListeners~dragEndListener} listener - The drag-end listener to add (a callback).\n * @return {VertexListeners} this (for chaining)\n * @instance\n * @memberof VertexListeners\n **/\n VertexListeners.prototype.addDragEndListener = function (listener) {\n // this.dragEnd.push( listener );\n VertexListeners._addListener(this.dragEnd, listener);\n return this;\n };\n /**\n * The drag-end listener is a function with a single drag event param.\n * @callback VertexListeners~dragEndListener\n * @param {Event} e - The (extended) drag event.\n */\n /**\n * Remove a drag listener.\n *\n * @method removeDragEndListener\n * @param {VertexListeners~clickListener} listener - The drag listener to remove (a callback).\n * @return {VertexListeners} this (for chaining)\n * @instance\n * @memberof VertexListeners\n **/\n VertexListeners.prototype.removeDragEndListener = function (listener) {\n // this.drag.push( listener );\n this.dragEnd = VertexListeners._removeListener(this.dragEnd, listener);\n return this;\n };\n /**\n * Fire a click event with the given event instance to all\n * installed click listeners.\n *\n * @method fireClickEvent\n * @param {VertEvent|XMouseEvent} e - The click event itself to be fired to all installed drag listeners.\n * @return {void}\n * @instance\n * @memberof VertexListeners\n **/\n VertexListeners.prototype.fireClickEvent = function (e) {\n VertexListeners._fireEvent(this, this.click, e);\n };\n /**\n * Fire a drag event with the given event instance to all\n * installed drag listeners.\n *\n * @method fireDragEvent\n * @param {VertEvent|XMouseEvent} e - The drag event itself to be fired to all installed drag listeners.\n * @return {void}\n * @instance\n * @memberof VertexListeners\n **/\n VertexListeners.prototype.fireDragEvent = function (e) {\n VertexListeners._fireEvent(this, this.drag, e);\n };\n /**\n * Fire a dragStart event with the given event instance to all\n * installed drag-start listeners.\n *\n * @method fireDragStartEvent\n * @param {VertEvent|XMouseEvent} e - The drag-start event itself to be fired to all installed dragStart listeners.\n * @return {void}\n * @instance\n * @memberof VertexListeners\n **/\n VertexListeners.prototype.fireDragStartEvent = function (e) {\n VertexListeners._fireEvent(this, this.dragStart, e);\n };\n /**\n * Fire a dragEnd event with the given event instance to all\n * installed drag-end listeners.\n *\n * @method fireDragEndEvent\n * @param {VertEvent|XMouseEvent} e - The drag-end event itself to be fired to all installed dragEnd listeners.\n * @return {void}\n * @instance\n * @memberof VertexListeners\n **/\n VertexListeners.prototype.fireDragEndEvent = function (e) {\n VertexListeners._fireEvent(this, this.dragEnd, e);\n };\n /**\n * Removes all listeners from this listeners object.\n */\n VertexListeners.prototype.removeAllListeners = function () {\n this.click = [];\n this.drag = [];\n this.dragStart = [];\n this.dragEnd = [];\n };\n /**\n * @private\n **/\n VertexListeners._fireEvent = function (_self, listeners, e) {\n var ve = e;\n if (typeof ve.params == \"undefined\")\n ve.params = { vertex: _self.vertex };\n else\n ve.params.vertex = _self.vertex;\n for (var i in listeners) {\n listeners[i](ve);\n }\n };\n /**\n * @private\n */\n VertexListeners._addListener = function (listeners, newListener) {\n if (!newListener) {\n throw new Error(\"Cannot add null listener. This would lead to unpredictable errors during event handling.\");\n }\n for (var i in listeners) {\n if (listeners[i] == newListener)\n return false;\n }\n listeners.push(newListener);\n return true;\n };\n /**\n * @private\n */\n VertexListeners._removeListener = function (listeners, oldListener) {\n for (var i = 0; i < listeners.length; i++) {\n if (listeners[i] == oldListener)\n return listeners.splice(i, 1);\n }\n return listeners;\n };\n return VertexListeners;\n}());\nexports.VertexListeners = VertexListeners;\n//# sourceMappingURL=VertexListeners.js.map","\"use strict\";\n/**\n * @classdesc A static UIDGenerator.\n *\n * @author Ikaros Kappler\n * @date 2021-01-20\n * @version 1.0.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.UIDGenerator = void 0;\nvar UIDGenerator = /** @class */ (function () {\n function UIDGenerator() {\n }\n UIDGenerator.next = function () {\n return \"\".concat(UIDGenerator.current++);\n };\n UIDGenerator.current = 0;\n return UIDGenerator;\n}());\nexports.UIDGenerator = UIDGenerator;\n//# sourceMappingURL=UIDGenerator.js.map","\"use strict\";\n/**\n * @author Ikaros Kappler\n * @date 2016-03-12\n * @modified 2018-12-05 Refactored the code from the morley-triangle script.\n * @modified 2019-03-20 Added JSDoc tags.\n * @modified 2019-04-28 Fixed a bug in the Line.sub( Vertex ) function (was not working).\n * @modified 2019-09-02 Added the Line.add( Vertex ) function.\n * @modified 2019-09-02 Added the Line.denominator( Line ) function.\n * @modified 2019-09-02 Added the Line.colinear( Line ) function.\n * @modified 2019-09-02 Fixed an error in the Line.intersection( Line ) function (class Point was renamed to Vertex).\n * @modified 2019-12-15 Added the Line.moveTo(Vertex) function.\n * @modified 2020-03-16 The Line.angle(Line) parameter is now optional. The baseline (x-axis) will be used if not defined.\n * @modified 2020-03-23 Ported to Typescript from JS.\n * @modified 2020-12-04 The `intersection` function returns undefined if both lines are parallel.\n * @modified 2022-02-02 Added the `destroy` method.\n * @modified 2022-10-09 Changed the actual return value of the `intersection` function to null (was undefined before).\n * @modified 2022-10-17 Adding these methods from the `PathSegment` interface: getStartPoint, getEndPoint, revert.\n * @modified 2023-09-25 Changed param type of `intersection()` from Line to VertTuple.\n * @modified 2025-04-15 Class `Line` now implements interface `Intersectable`.\n * @modified 2025-04-16 Class `Line` now implements interface `IBounded`.\n * @version 2.4.0\n *\n * @file Line\n * @public\n **/\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n if (typeof b !== \"function\" && b !== null)\n throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Line = void 0;\nvar Bounds_1 = require(\"./Bounds\");\nvar Vector_1 = require(\"./Vector\");\nvar VertTuple_1 = require(\"./VertTuple\");\nvar Vertex_1 = require(\"./Vertex\");\n/**\n * @classdesc A line consists of two vertices a and b.
\n *
\n * This is some refactored code from my 'Morley Triangle' test
\n * https://github.com/IkarosKappler/morleys-trisector-theorem\n *\n * @requires Vertex\n */\nvar Line = /** @class */ (function (_super) {\n __extends(Line, _super);\n /**\n * Creates an instance of Line.\n *\n * @constructor\n * @name Line\n * @param {Vertex} a The line's first point.\n * @param {Vertex} b The line's second point.\n **/\n function Line(a, b) {\n var _this = _super.call(this, a, b, function (a, b) { return new Line(a, b); }) || this;\n /**\n * Required to generate proper CSS classes and other class related IDs.\n **/\n _this.className = \"Line\";\n return _this;\n }\n /**\n * Get the intersection if this line and the specified line.\n *\n * @method intersection\n * @param {Line} line The second line.\n * @return {Vertex|undefined} The intersection (may lie outside the end-points) or `undefined` if both lines are parallel.\n * @instance\n * @memberof Line\n **/\n // !!! DO NOT MOVE TO VertTuple\n Line.prototype.intersection = function (line) {\n var denominator = this.denominator(line);\n if (denominator == 0) {\n return null;\n }\n var a = this.a.y - line.a.y;\n var b = this.a.x - line.a.x;\n var numerator1 = (line.b.x - line.a.x) * a - (line.b.y - line.a.y) * b;\n var numerator2 = (this.b.x - this.a.x) * a - (this.b.y - this.a.y) * b;\n a = numerator1 / denominator; // NaN if parallel lines\n b = numerator2 / denominator;\n // Catch NaN?\n var x = this.a.x + a * (this.b.x - this.a.x);\n var y = this.a.y + a * (this.b.y - this.a.y);\n if (isNaN(a) || isNaN(x) || isNaN(y)) {\n return null;\n }\n // if we cast these lines infinitely in both directions, they intersect here:\n return new Vertex_1.Vertex(x, y);\n };\n //--- BEGIN --- Implement interface `IBounded`\n /**\n * Get the bounding box (bounds) of this Line.\n *\n * @method getBounds\n * @instance\n * @memberof Line\n * @return {Bounds} The rectangular bounds of this Line.\n **/\n Line.prototype.getBounds = function () {\n return Bounds_1.Bounds.computeFromVertices([this.a, this.b]);\n };\n //--- END --- Implement interface `IBounded`\n //--- Implement PathSegment ---\n /**\n * Get the start point of this path segment.\n *\n * @method getStartPoint\n * @memberof PathSegment\n * @return {Vertex} The start point of this path segment.\n */\n Line.prototype.getStartPoint = function () {\n return this.a;\n };\n /**\n * Get the end point of this path segment.\n *\n * @method getEndPoint\n * @memberof PathSegment\n * @return {Vertex} The end point of this path segment.\n */\n Line.prototype.getEndPoint = function () {\n return this.b;\n };\n /**\n * Get the tangent's end point at the start point of this segment.\n *\n * @method getStartTangent\n * @memberof PathSegment\n * @return {Vertex} The end point of the starting point's tangent.\n */\n Line.prototype.getStartTangent = function () {\n return this.b;\n };\n /**\n * Get the tangent's end point at the end point of this segment.\n *\n * @method getEndTangent\n * @memberof PathSegment\n * @return {Vertex} The end point of the ending point's tangent.\n */\n Line.prototype.getEndTangent = function () {\n return this.a;\n };\n /**\n * Inverse this path segment (in-place) and return this same instance (useful for chaining).\n *\n * @method reverse\n * @memberof PathSegment\n * @return {PathSegment} This path segment instance (for chaining).\n */\n Line.prototype.reverse = function () {\n var tmp = this.a;\n this.a = this.b;\n this.b = tmp;\n return this;\n };\n //--- END Implement PathSegment ---\n //--- BEGIN --- Implement interface `Intersectable`\n /**\n * Get all line intersections with this polygon.\n *\n * This method returns all intersections (as vertices) with this shape. The returned array of vertices is in no specific order.\n *\n * See demo `47-closest-vector-projection-on-polygon` for how it works.\n *\n * @param {VertTuple} line - The line to find intersections with.\n * @param {boolean} inVectorBoundsOnly - If set to true only intersecion points on the passed vector are returned (located strictly between start and end vertex).\n * @returns {Array} - An array of all intersections within the polygon bounds.\n */\n Line.prototype.lineIntersections = function (line, inVectorBoundsOnly) {\n if (inVectorBoundsOnly === void 0) { inVectorBoundsOnly = false; }\n // Find the intersections of all lines inside the edge bounds\n var intersection = this.intersection(line);\n if (!intersection) {\n return []; // Both lines parallel\n }\n if (this.hasPoint(intersection, true) && (!inVectorBoundsOnly || line.hasPoint(intersection, inVectorBoundsOnly))) {\n return [intersection];\n }\n else {\n return [];\n }\n };\n /**\n * Get all line intersections of this polygon and their tangents along the shape.\n *\n * This method returns all intersection tangents (as vectors) with this shape. The returned array of vectors is in no specific order.\n *\n * @param line\n * @param inVectorBoundsOnly\n * @returns\n */\n Line.prototype.lineIntersectionTangents = function (line, inVectorBoundsOnly) {\n if (inVectorBoundsOnly === void 0) { inVectorBoundsOnly = false; }\n // Find the intersection tangents of all lines inside the edge bounds\n var intersections = this.lineIntersections(line, inVectorBoundsOnly);\n if (intersections.length === 0) {\n return [];\n }\n var intrsctn = intersections[0];\n return [new Vector_1.Vector(this.a.clone(), this.b.clone()).moveTo(intrsctn)];\n };\n return Line;\n}(VertTuple_1.VertTuple));\nexports.Line = Line;\n//# sourceMappingURL=Line.js.map","\"use strict\";\n/**\n * @author Ikaros Kappler\n * @date 2013-08-15\n * @modified 2018-08-16 Added a closure. Removed the wrapper class 'IKRS'. Replaced class THREE.Vector2 by Vertex class.\n * @modified 2018-11-19 Added the fromArray(Array) function.\n * @modified 2018-11-28 Added the locateCurveByPoint(Vertex) function.\n * @modified 2018-12-04 Added the toSVGPathData() function.\n * @modified 2019-03-20 Added JSDoc tags.\n * @modified 2019-03-23 Changed the signatures of getPoint, getPointAt and getTangent (!version 2.0).\n * @modified 2019-12-02 Fixed the updateArcLength function. It used the wrong pointAt function (was renamed before).\n * @modified 2020-02-06 Added the getSubCurveAt(number,number) function.\n * @modified 2020-02-06 Fixed a serious bug in the arc lenght calculation (length was never reset, urgh).\n * @modified 2020-02-07 Added the isInstance(any) function.\n * @modified 2020-02-10 Added the reverse() function.\n * @modified 2020-02-10 Fixed the translate(...) function (returning 'this' was missing).\n * @modified 2020-03-24 Ported this class from vanilla JS to Typescript.\n * @modified 2020-06-03 Added the getBounds() function.\n * @modified 2020-07-14 Changed the moveCurvePoint(...,Vertex) to moveCurvePoint(...,XYCoords), which is more generic.\n * @modified 2020-07-24 Added the getClosestT function and the helper function locateIntervalByDistance(...).\n * @modified 2021-01-20 Added UID.\n * @modified 2022-02-02 Added the `destroy` method.\n * @modified 2022-02-02 Cleared the `toSVGPathData` function (deprecated). Use `drawutilssvg` instead.\n * @modified 2022-10-17 The `CubicBezierCurve` class now implements the new `PathSegment` interface.\n * @modified 2023-09-30 Added the function `CubicbezierCurve.getSubCurve(number,number)` – similar to `getSubCurveAt(...)` but with absolute position parameters.\n * @modified 2023-10-07 Added the `trimEnd`, `trimEndAt`, `trimStart`, `trimStartAt` methods.\n * @modified 2025-04-09 Added the `CubicBezierCurve.move` method to match the convention – which just calls `translate`.\n * @modified 2025-04-09 Modified the `CubicBezierCurve.translate` method: chaning parameter `Vertex` to more generalized `XYCoords`.\n * @modified 2025-04-13 Changed visibility of `CubicBezierCurve.utils` from 'private' to 'public'.\n * @modified 2025-04-13 Added helper function `CubicBezierCurve.utils.bezierCoeffs`.\n * @modified 2025-04-13 Added helper functopn `CubicBezierCurve.utils.sgn(number)` for division safe sign calculation.\n * @modified 2025-03-13 Class `CubicBezierCurve` is now implementing interface `Intersectable`.\n * @modified 2025-04-18 Added evaluation method for cubic Bézier curves `CubicBezierCurve.utils.evaluateT`.\n * @modified 2025-04-18 Refactored method `CubicBezierCurve.getPointAt` to use `evaluateT`.\n * @modified 2025-04-18 Fixed the `CubicBezierCurve.getBounds` method: now returning the real bounding box. Before it was an approximated one.\n * @modified 2025-ß4-18 Added helper methods for bounding box calculation `CubucBezierCurve.util.cubicPolyMinMax` and `cubicPoly`.\n * @version 2.9.0\n *\n * @file CubicBezierCurve\n * @public\n **/\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.CubicBezierCurve = void 0;\nvar Bounds_1 = require(\"./Bounds\");\nvar UIDGenerator_1 = require(\"./UIDGenerator\");\nvar Vertex_1 = require(\"./Vertex\");\nvar Vector_1 = require(\"./Vector\");\n/**\n * @classdesc A refactored cubic bezier curve class.\n *\n * @requires Bounds\n * @requires Vertex\n * @requires Vector\n * @requires XYCoords\n * @requires UID\n * @requires UIDGenerator\n */\nvar CubicBezierCurve = /** @class */ (function () {\n /**\n * The constructor.\n *\n * @constructor\n * @name CubicBezierCurve\n * @param {Vertex} startPoint - The Bézier curve's start point.\n * @param {Vertex} endPoint - The Bézier curve's end point.\n * @param {Vertex} startControlPoint - The Bézier curve's start control point.\n * @param {Vertex} endControlPoint - The Bézier curve's end control point.\n **/\n function CubicBezierCurve(startPoint, endPoint, startControlPoint, endControlPoint) {\n /** @constant {number} */\n this.START_POINT = CubicBezierCurve.START_POINT;\n /** @constant {number} */\n this.START_CONTROL_POINT = CubicBezierCurve.START_CONTROL_POINT;\n /** @constant {number} */\n this.END_CONTROL_POINT = CubicBezierCurve.END_CONTROL_POINT;\n /** @constant {number} */\n this.END_POINT = CubicBezierCurve.END_POINT;\n this.uid = UIDGenerator_1.UIDGenerator.next();\n this.startPoint = startPoint;\n this.startControlPoint = startControlPoint;\n this.endPoint = endPoint;\n this.endControlPoint = endControlPoint;\n this.curveIntervals = 30;\n // An array of vertices\n this.segmentCache = [];\n // An array of floats\n this.segmentLengths = [];\n // float\n // this.arcLength = null;\n this.updateArcLengths();\n }\n /**\n * Move the given curve point (the start point, end point or one of the two\n * control points).\n *\n * @method moveCurvePoint\n * @param {number} pointID - The numeric identicator of the point to move. Use one of the four eBezierPoint constants.\n * @param {XYCoords} moveAmount - The amount to move the specified point by.\n * @param {boolean} moveControlPoint - Move the control points along with their path point (if specified point is a path point).\n * @param {boolean} updateArcLengths - Specifiy if the internal arc segment buffer should be updated.\n * @instance\n * @memberof CubicBezierCurve\n * @return {void}\n **/\n CubicBezierCurve.prototype.moveCurvePoint = function (pointID, moveAmount, moveControlPoint, updateArcLengths) {\n if (pointID == this.START_POINT) {\n this.getStartPoint().add(moveAmount);\n if (moveControlPoint)\n this.getStartControlPoint().add(moveAmount);\n }\n else if (pointID == this.START_CONTROL_POINT) {\n this.getStartControlPoint().add(moveAmount);\n }\n else if (pointID == this.END_CONTROL_POINT) {\n this.getEndControlPoint().add(moveAmount);\n }\n else if (pointID == this.END_POINT) {\n this.getEndPoint().add(moveAmount);\n if (moveControlPoint)\n this.getEndControlPoint().add(moveAmount);\n }\n else {\n console.log(\"[CubicBezierCurve.moveCurvePoint] pointID '\".concat(pointID, \"' invalid.\"));\n }\n if (updateArcLengths)\n this.updateArcLengths();\n };\n /**\n * Translate the whole curve by the given {x,y} amount: moves all four points.\n *\n * @method translate\n * @param {XYCoords} amount - The amount to translate this curve by.\n * @instance\n * @memberof CubicBezierCurve\n * @return {CubicBezierCurve} this (for chaining).\n **/\n CubicBezierCurve.prototype.translate = function (amount) {\n this.startPoint.add(amount);\n this.startControlPoint.add(amount);\n this.endControlPoint.add(amount);\n this.endPoint.add(amount);\n return this;\n };\n /**\n * Translate the whole curve by the given {x,y} amount: moves all four points.\n *\n * @method translate\n * @param {XYCoords} amount - The amount to translate this curve by.\n * @instance\n * @memberof CubicBezierCurve\n * @return {CubicBezierCurve} this (for chaining).\n **/\n CubicBezierCurve.prototype.move = function (amount) {\n return this.translate(amount);\n };\n /**\n * Reverse this curve, means swapping start- and end-point and swapping\n * start-control- and end-control-point.\n *\n * @method reverse\n * @instance\n * @memberof CubicBezierCurve\n * @return {CubicBezierCurve} this (for chaining).\n **/\n CubicBezierCurve.prototype.reverse = function () {\n var tmp = this.startPoint;\n this.startPoint = this.endPoint;\n this.endPoint = tmp;\n tmp = this.startControlPoint;\n this.startControlPoint = this.endControlPoint;\n this.endControlPoint = tmp;\n return this;\n };\n /**\n * Get the total curve length.
\n *
\n * As not all Bézier curved have a closed formula to calculate their lengths, this\n * implementation uses a segment buffer (with a length of 30 segments). So the\n * returned length is taken from the arc segment buffer.
\n *
\n * Note that if the curve points were changed and the segment buffer was not\n * updated this function might return wrong (old) values.\n *\n * @method getLength\n * @instance\n * @memberof CubicBezierCurve\n * @return {number} >= 0\n **/\n CubicBezierCurve.prototype.getLength = function () {\n return this.arcLength;\n };\n /**\n * Uptate the internal arc segment buffer and their lengths.
\n *
\n * All class functions update the buffer automatically; if any\n * curve point is changed by other reasons you should call this\n * function to keep actual values in the buffer.\n *\n * @method updateArcLengths\n * @instance\n * @memberof CubicBezierCurve\n * @return {void}\n **/\n CubicBezierCurve.prototype.updateArcLengths = function () {\n var pointA = this.startPoint.clone();\n var pointB = new Vertex_1.Vertex(0, 0);\n var curveStep = 1.0 / this.curveIntervals;\n // Clear segment cache\n this.segmentCache = [];\n // Push start point into buffer\n this.segmentCache.push(this.startPoint);\n this.segmentLengths = [];\n var newLength = 0.0;\n var t = 0.0;\n var tmpLength;\n while (t <= 1.0) {\n pointB = this.getPointAt(t);\n // Store point into cache\n this.segmentCache.push(pointB);\n // Calculate segment length\n tmpLength = pointA.distance(pointB);\n this.segmentLengths.push(tmpLength);\n newLength += tmpLength;\n pointA = pointB;\n t += curveStep;\n }\n this.arcLength = newLength;\n };\n /**\n * Get a 't' (relative position on curve) with the closest distance to point 'p'.\n *\n * The returned number is 0.0 <= t <= 1.0. Use the getPointAt(t) function to retrieve the actual curve point.\n *\n * This function uses a recursive approach by cutting the curve into several linear segments.\n *\n * @method getClosestT\n * @instance\n * @memberof CubicBezierCurve\n * @param {Vertex} p - The point to find the closest position ('t' on the curve).\n * @return {number}\n **/\n CubicBezierCurve.prototype.getClosestT = function (p) {\n // We would like to have an error that's not larger than 1.0.\n var desiredEpsilon = 1.0;\n var result = { t: 0, tPrev: 0.0, tNext: 1.0 };\n var iteration = 0;\n do {\n result = this.locateIntervalByDistance(p, result.tPrev, result.tNext, this.curveIntervals);\n iteration++;\n // Be sure: stop after 4 iterations\n } while (iteration < 4 && this.getPointAt(result.tPrev).distance(this.getPointAt(result.tNext)) > desiredEpsilon);\n return result.t;\n };\n /**\n * This helper function locates the 't' on a fixed step interval with the minimal distance\n * between the curve (at 't') and the given point.\n *\n * Furthermore you must specify a sub curve (start 't' and end 't') you want to search on.\n * Using tStart=0.0 and tEnd=1.0 will search on the full curve.\n *\n * @param {Vertex} p - The point to find the closest curve point for.\n * @param {number} tStart - The start position (start 't' of the sub curve). Should be >= 0.0.\n * @param {number} tEnd - The end position (end 't' of the sub curve). Should be <= 1.0.\n * @param {number} stepCount - The number of steps to check within the interval.\n *\n * @return {object} - An object with t, tPrev and tNext (numbers).\n **/\n CubicBezierCurve.prototype.locateIntervalByDistance = function (p, tStart, tEnd, stepCount) {\n var minIndex = -1;\n var minDist = 0;\n var t = 0.0;\n var tDiff = tEnd - tStart;\n for (var i = 0; i <= stepCount; i++) {\n t = tStart + tDiff * (i / stepCount);\n var vert = this.getPointAt(t);\n var dist = vert.distance(p);\n if (minIndex == -1 || dist < minDist) {\n minIndex = i;\n minDist = dist;\n }\n }\n return {\n t: tStart + tDiff * (minIndex / stepCount),\n tPrev: tStart + tDiff * (Math.max(0, minIndex - 1) / stepCount),\n tNext: tStart + tDiff * (Math.min(stepCount, minIndex + 1) / stepCount)\n };\n };\n //--- BEGIN --- Implement interface `IBounded`\n /**\n * Get the bounds of this bezier curve.\n *\n * The bounds are approximated by the underlying segment buffer; the more segment there are,\n * the more accurate will be the returned bounds.\n *\n * @method getClosestT\n * @instance\n * @memberof CubicBezierCurve\n * @return {Bounds} The bounds of this ellipse.\n **/\n CubicBezierCurve.prototype.getBounds = function () {\n // Thanks to Richard \"RM\" for the Bézier bounds calculatin\n // https://jsfiddle.net/SalixAlba/QQnvm/4/\n var xMinMax = CubicBezierCurve.utils.cubicPolyMinMax(this.startPoint.x, this.startControlPoint.x, this.endControlPoint.x, this.endPoint.x);\n var xl = xMinMax.min;\n var xh = xMinMax.max;\n var yMinMax = CubicBezierCurve.utils.cubicPolyMinMax(this.startPoint.y, this.startControlPoint.y, this.endControlPoint.y, this.endPoint.y);\n var yl = yMinMax.min;\n var yh = yMinMax.max;\n return Bounds_1.Bounds.computeFromVertices([\n { x: xl, y: yl },\n { x: xl, y: yh },\n { x: xh, y: yh },\n { x: xh, y: yl }\n ]);\n };\n //--- END --- Implement interface `IBounded`\n /**\n * Get the start point of the curve.
\n *
\n * This function just returns this.startPoint.\n *\n * @method getStartPoint\n * @instance\n * @memberof CubicBezierCurve\n * @return {Vertex} this.startPoint\n **/\n CubicBezierCurve.prototype.getStartPoint = function () {\n return this.startPoint;\n };\n /**\n * Get the end point of the curve.
\n *
\n * This function just returns this.endPoint.\n *\n * @method getEndPoint\n * @instance\n * @memberof CubicBezierCurve\n * @return {Vertex} this.endPoint\n **/\n CubicBezierCurve.prototype.getEndPoint = function () {\n return this.endPoint;\n };\n /**\n * Get the start control point of the curve.
\n *
\n * This function just returns this.startControlPoint.\n *\n * @method getStartControlPoint\n * @instance\n * @memberof CubicBezierCurve\n * @return {Vertex} this.startControlPoint\n **/\n CubicBezierCurve.prototype.getStartControlPoint = function () {\n return this.startControlPoint;\n };\n /**\n * Get the end control point of the curve.
\n *
\n * This function just returns this.endControlPoint.\n *\n * @method getEndControlPoint\n * @instance\n * @memberof CubicBezierCurve\n * @return {Vertex} this.endControlPoint\n **/\n CubicBezierCurve.prototype.getEndControlPoint = function () {\n return this.endControlPoint;\n };\n /**\n * Get one of the four curve points specified by the passt point ID.\n *\n * @method getEndControlPoint\n * @param {number} id - One of START_POINT, START_CONTROL_POINT, END_CONTROL_POINT or END_POINT.\n * @instance\n * @memberof CubicBezierCurve\n * @return {Vertex}\n **/\n CubicBezierCurve.prototype.getPointByID = function (id) {\n if (id == this.START_POINT)\n return this.startPoint;\n if (id == this.END_POINT)\n return this.endPoint;\n if (id == this.START_CONTROL_POINT)\n return this.startControlPoint;\n if (id == this.END_CONTROL_POINT)\n return this.endControlPoint;\n throw new Error(\"Invalid point ID '\".concat(id, \"'.\"));\n };\n /**\n * Get the curve point at a given position t, where t is in [0,1].
\n *
\n * @see Line.pointAt\n *\n * @method getPointAt\n * @param {number} t - The position on the curve in [0,1] (0 means at\n * start point, 1 means at end point, other values address points in bertween).\n * @instance\n * @memberof CubicBezierCurve\n * @return {Vertex}\n **/\n CubicBezierCurve.prototype.getPointAt = function (t) {\n // Perform some powerful math magic\n // TODO: cleanup\n // const x: number =\n // this.startPoint.x * Math.pow(1.0 - t, 3) +\n // this.startControlPoint.x * 3 * t * Math.pow(1.0 - t, 2) +\n // this.endControlPoint.x * 3 * Math.pow(t, 2) * (1.0 - t) +\n // this.endPoint.x * Math.pow(t, 3);\n // const y: number =\n // this.startPoint.y * Math.pow(1.0 - t, 3) +\n // this.startControlPoint.y * 3 * t * Math.pow(1.0 - t, 2) +\n // this.endControlPoint.y * 3 * Math.pow(t, 2) * (1.0 - t) +\n // this.endPoint.y * Math.pow(t, 3);\n var x = CubicBezierCurve.utils.evaluateT(this.startPoint.x, this.startControlPoint.x, this.endControlPoint.x, this.endPoint.x, t);\n var y = CubicBezierCurve.utils.evaluateT(this.startPoint.y, this.startControlPoint.y, this.endControlPoint.y, this.endPoint.y, t);\n return new Vertex_1.Vertex(x, y);\n };\n /**\n * Get the curve point at a given position u, where u is in [0,arcLength].
\n *
\n * @see CubicBezierCurve.getPointAt\n *\n * @method getPoint\n * @param {number} u - The position on the curve in [0,arcLength] (0 means at\n * start point, arcLength means at end point, other values address points in bertween).\n * @instance\n * @memberof CubicBezierCurve\n * @return {Vertex}\n **/\n CubicBezierCurve.prototype.getPoint = function (u) {\n return this.getPointAt(u / this.arcLength);\n };\n /**\n * Get the curve tangent vector at a given absolute curve position t in [0,1].
\n *
\n * Note that the returned tangent vector (end point) is not normalized and relative to (0,0).\n *\n * @method getTangent\n * @param {number} t - The position on the curve in [0,1].\n * @instance\n * @memberof CubicBezierCurve\n * @return {Vertex}\n **/\n CubicBezierCurve.prototype.getTangentAt = function (t) {\n var a = this.getStartPoint();\n var b = this.getStartControlPoint();\n var c = this.getEndControlPoint();\n var d = this.getEndPoint();\n // This is the shortened one\n var t2 = t * t;\n // (1 - t)^2 = (1-t)*(1-t) = 1 - t - t + t^2 = 1 - 2*t + t^2\n var nt2 = 1 - 2 * t + t2;\n var tX = -3 * a.x * nt2 + b.x * (3 * nt2 - 6 * (t - t2)) + c.x * (6 * (t - t2) - 3 * t2) + 3 * d.x * t2;\n var tY = -3 * a.y * nt2 + b.y * (3 * nt2 - 6 * (t - t2)) + c.y * (6 * (t - t2) - 3 * t2) + 3 * d.y * t2;\n // Note: my implementation does NOT normalize tangent vectors!\n return new Vertex_1.Vertex(tX, tY);\n };\n /**\n * Trim off a start section of this curve. The position parameter `uValue` is the absolute position on the\n * curve in `[0...arcLength]`.\n * The remaining curve will be the one in the bounds `[uValue,1]` (so `[0.0,uValue]` is cut off).\n *\n * Note this function just converts the absolute parameter to a relative one and call `trimStartAt`.\n *\n * @method trimStart\n * @instance\n * @memberof CubicBezierCurve\n * @param {number} uValue - The absolute position parameter where to cut off the head curve.\n * @returns {CubicBezierCurve} `this` for chanining.\n */\n CubicBezierCurve.prototype.trimStart = function (uValue) {\n return this.trimStartAt(this.convertU2T(uValue));\n };\n /**\n * Trim off a start section of this curve. The position parameter `t` is the relative position in [0..1].\n * The remaining curve will be the one in the bounds `[uValue,1]` (so `[0.0,uValue]` is cut off).\n *\n * @method trimStartAt\n * @instance\n * @memberof CubicBezierCurve\n * @param {number} t - The relative position parameter where to cut off the head curve.\n * @returns {CubicBezierCurve} `this` for chanining.\n */\n CubicBezierCurve.prototype.trimStartAt = function (t) {\n var subCurbePoints = CubicBezierCurve.utils.getSubCurvePointsAt(this, t, 1.0);\n this.startPoint.set(subCurbePoints[0]);\n this.startControlPoint.set(subCurbePoints[2]);\n this.endPoint.set(subCurbePoints[1]);\n this.endControlPoint.set(subCurbePoints[3]);\n this.updateArcLengths();\n return this;\n };\n /**\n * Trim off the end of this curve. The position parameter `uValue` is the absolute position on the\n * curve in `[0...arcLength]`.\n * The remaining curve will be the one in the bounds `[0,uValue]` (so `[1.0-uValue,1.0]` is cut off).\n *\n * Note this function just converts the absolute parameter to a relative one and call `trimEndAt`.\n *\n * @method trimEnd\n * @instance\n * @memberof CubicBezierCurve\n * @param {number} uValue - The absolute position parameter where to cut off the tail curve.\n * @returns {CubicBezierCurve} `this` for chanining.\n */\n CubicBezierCurve.prototype.trimEnd = function (uValue) {\n return this.trimEndAt(this.convertU2T(uValue));\n };\n /**\n * Trim off the end of this curve. The position parameter `t` is the relative position in [0..1].\n * The remaining curve will be the one in the bounds `[0,t]` (so `[1.0-t,1.0]` is cut off).\n *\n * @method trimEndAt\n * @instance\n * @memberof CubicBezierCurve\n * @param {number} t - The relative position parameter where to cut off the tail curve.\n * @returns {CubicBezierCurve} `this` for chanining.\n */\n CubicBezierCurve.prototype.trimEndAt = function (t) {\n var subCurbePoints = CubicBezierCurve.utils.getSubCurvePointsAt(this, 0.0, t);\n this.startPoint.set(subCurbePoints[0]);\n this.startControlPoint.set(subCurbePoints[2]);\n this.endPoint.set(subCurbePoints[1]);\n this.endControlPoint.set(subCurbePoints[3]);\n this.updateArcLengths();\n return this;\n };\n /**\n * Get a sub curve at the given start end end positions (values on the curve's length, between 0 and curve.arcLength).\n *\n * tStart >= tEnd is allowed, you will get a reversed sub curve then.\n *\n * @method getSubCurve\n * @param {number} tStart – The start position of the desired sub curve (must be in [0..arcLength]).\n * @param {number} tEnd – The end position if the desired cub curve (must be in [0..arcLength]).\n * @instance\n * @memberof CubicBezierCurve\n * @return {CubicBezierCurve} The sub curve as a new curve.\n **/\n CubicBezierCurve.prototype.getSubCurve = function (uStart, uEnd) {\n return this.getSubCurveAt(this.convertU2T(uStart), this.convertU2T(uEnd));\n };\n /**\n * Get a sub curve at the given start end end offsets (values between 0.0 and 1.0).\n *\n * tStart >= tEnd is allowed, you will get a reversed sub curve then.\n *\n * @method getSubCurveAt\n * @param {number} tStart – The start offset of the desired sub curve (must be in [0..1]).\n * @param {number} tEnd – The end offset if the desired cub curve (must be in [0..1]).\n * @instance\n * @memberof CubicBezierCurve\n * @return {CubicBezierCurve} The sub curve as a new curve.\n **/\n CubicBezierCurve.prototype.getSubCurveAt = function (tStart, tEnd) {\n // This 'splits' the curve at the given point at t.\n var subCurbePoints = CubicBezierCurve.utils.getSubCurvePointsAt(this, tStart, tEnd);\n return new CubicBezierCurve(subCurbePoints[0], subCurbePoints[1], subCurbePoints[2], subCurbePoints[3]);\n };\n /**\n * Convert a relative curve position u to the absolute curve position t.\n *\n * @method convertU2t\n * @param {number} u - The relative position on the curve in [0,arcLength].\n * @instance\n * @memberof CubicBezierCurve\n * @return {number}\n **/\n CubicBezierCurve.prototype.convertU2T = function (u) {\n return Math.max(0.0, Math.min(1.0, u / this.arcLength));\n };\n /**\n * Get the curve tangent vector at a given relative position u in [0,arcLength].
\n *
\n * Note that the returned tangent vector (end point) is not normalized.\n *\n * @method getTangent\n * @param {number} u - The position on the curve in [0,arcLength].\n * @instance\n * @memberof CubicBezierCurve\n * @return {Vertex}\n **/\n CubicBezierCurve.prototype.getTangent = function (u) {\n return this.getTangentAt(this.convertU2T(u));\n };\n /**\n * Get the curve perpendicular at a given relative position u in [0,arcLength] as a vector.
\n *
\n * Note that the returned vector (end point) is not normalized.\n *\n * @method getPerpendicular\n * @param {number} u - The relative position on the curve in [0,arcLength].\n * @instance\n * @memberof CubicBezierCurve\n * @return {Vertex}\n **/\n CubicBezierCurve.prototype.getPerpendicular = function (u) {\n return this.getPerpendicularAt(this.convertU2T(u));\n };\n /**\n * Get the curve perpendicular at a given absolute position t in [0,1] as a vector.
\n *
\n * Note that the returned vector (end point) is not normalized.\n *\n * @method getPerpendicularAt\n * @param {number} u - The absolute position on the curve in [0,1].\n * @instance\n * @memberof CubicBezierCurve\n * @return {Vertex}\n **/\n CubicBezierCurve.prototype.getPerpendicularAt = function (t) {\n var tangentVector = this.getTangentAt(t);\n return new Vertex_1.Vertex(tangentVector.y, -tangentVector.x);\n };\n /**\n * Clone this Bézier curve (deep clone).\n *\n * @method clone\n * @instance\n * @memberof CubicBezierCurve\n * @return {CubicBezierCurve}\n **/\n CubicBezierCurve.prototype.clone = function () {\n return new CubicBezierCurve(this.getStartPoint().clone(), this.getEndPoint().clone(), this.getStartControlPoint().clone(), this.getEndControlPoint().clone());\n };\n //---BEGIN PathSegment-------------------------\n /**\n * Get the tangent's end point at the start point of this segment.\n *\n * @method getStartTangent\n * @memberof PathSegment\n * @return {Vertex} The end point of the starting point's tangent.\n */\n CubicBezierCurve.prototype.getStartTangent = function () {\n return this.startControlPoint;\n };\n /**\n * Get the tangent's end point at the end point of this segment.\n *\n * @method getEndTangent\n * @memberof PathSegment\n * @return {Vertex} The end point of the ending point's tangent.\n */\n CubicBezierCurve.prototype.getEndTangent = function () {\n return this.endControlPoint;\n };\n //---END PathSegment-------------------------\n //--- BEGIN --- Implement interface `Intersectable`\n /**\n * Get all line intersections with this shape.\n *\n * This method returns all intersections (as vertices) with this shape. The returned array of vertices is in no specific order.\n *\n * @param {VertTuple} line - The line to find intersections with.\n * @param {boolean} inVectorBoundsOnly - If set to true only intersecion points on the passed vector are returned (located strictly between start and end vertex).\n * @returns {Array} - An array of all intersections with the shape outline.\n */\n CubicBezierCurve.prototype.lineIntersections = function (line, inVectorBoundsOnly) {\n var _this = this;\n if (inVectorBoundsOnly === void 0) { inVectorBoundsOnly = false; }\n var intersectionTs = this.lineIntersectionTs(line);\n var intersectionPoints = intersectionTs.map(function (t) {\n return _this.getPointAt(t);\n });\n if (inVectorBoundsOnly) {\n // const maxDist = line.length();\n return intersectionPoints.filter(function (vert) { return line.hasPoint(vert, true); });\n }\n else {\n return intersectionPoints;\n }\n };\n /**\n * Get all line intersections of this polygon and their tangents along the shape.\n *\n * This method returns all intersection tangents (as vectors) with this shape. The returned array of vectors is in no specific order.\n *\n * @param line\n * @param lineIntersectionTangents\n * @returns\n */\n CubicBezierCurve.prototype.lineIntersectionTangents = function (line, inVectorBoundsOnly) {\n var _this = this;\n if (inVectorBoundsOnly === void 0) { inVectorBoundsOnly = false; }\n var intersectionTs = this.lineIntersectionTs(line);\n var intersectionTangents = intersectionTs.map(function (t) {\n var startPoint = _this.getPointAt(t);\n var endPoint = _this.getTangentAt(t);\n return new Vector_1.Vector(startPoint, endPoint.add(startPoint));\n });\n if (inVectorBoundsOnly) {\n return intersectionTangents.filter(function (vec) { return line.hasPoint(vec.a, true); });\n }\n else {\n return intersectionTangents;\n }\n };\n //--- END --- Implement interface `Intersectable`\n CubicBezierCurve.prototype.lineIntersectionTs = function (line) {\n var A = line.b.y - line.a.y; // A=y2-y1\n var B = line.a.x - line.b.x; // B=x1-x2\n var C = line.a.x * (line.a.y - line.b.y) + line.a.y * (line.b.x - line.a.x); //C=x1*(y1-y2)+y1*(x2-x1)\n // var bx = bezierCoeffs(px[0], px[1], px[2], px[3]);\n // var by = bezierCoeffs(py[0], py[1], py[2], py[3]);\n var bx = CubicBezierCurve.utils.bezierCoeffs(this.startPoint.x, this.startControlPoint.x, this.endControlPoint.x, this.endPoint.x);\n var by = CubicBezierCurve.utils.bezierCoeffs(this.startPoint.y, this.startControlPoint.y, this.endControlPoint.y, this.endPoint.y);\n var poly = Array(4);\n poly[0] = A * bx[0] + B * by[0]; /*t^3*/\n poly[1] = A * bx[1] + B * by[1]; /*t^2*/\n poly[2] = A * bx[2] + B * by[2]; /*t*/\n poly[3] = A * bx[3] + B * by[3] + C; /*1*/\n var roots = CubicBezierCurve.utils.cubicRoots(poly);\n return roots.filter(function (root) { return root != -1; });\n };\n /**\n * Check if this and the specified curve are equal.
\n *
\n * All four points need to be equal for this, the Vertex.equals function is used.
\n *
\n * Please note that this function is not type safe (comparison with any object will fail).\n *\n * @method clone\n * @param {CubicBezierCurve} curve - The curve to compare with.\n * @instance\n * @memberof CubicBezierCurve\n * @return {boolean}\n **/\n CubicBezierCurve.prototype.equals = function (curve) {\n // Note: in the earlier vanilla-JS version this was callable with plain objects.\n // Let's see if this restricted version works out.\n if (!curve)\n return false;\n if (!curve.startPoint || !curve.endPoint || !curve.startControlPoint || !curve.endControlPoint)\n return false;\n return (this.startPoint.equals(curve.startPoint) &&\n this.endPoint.equals(curve.endPoint) &&\n this.startControlPoint.equals(curve.startControlPoint) &&\n this.endControlPoint.equals(curve.endControlPoint));\n };\n /**\n * This function should invalidate any installed listeners and invalidate this object.\n * After calling this function the object might not hold valid data any more and\n * should not be used.\n */\n CubicBezierCurve.prototype.destroy = function () {\n this.startPoint.destroy();\n this.endPoint.destroy();\n this.startControlPoint.destroy();\n this.endControlPoint.destroy();\n this.isDestroyed = true;\n };\n /**\n * Quick check for class instance.\n * Is there a better way?\n *\n * @method isInstance\n * @param {any} obj - Check if the passed object/value is an instance of CubicBezierCurve.\n * @instance\n * @memberof CubicBezierCurve\n * @return {boolean}\n **/\n CubicBezierCurve.isInstance = function (obj) {\n // Note: check this again\n /* OLD VANILLA JS IMPLEMENTATION */\n /* if( typeof obj != \"object\" )\n return false;\n function hasXY(v) {\n return typeof v != \"undefined\" && typeof v.x == \"number\" && typeof v.y == \"number\";\n }\n return typeof obj.startPoint == \"object\" && hasXY(obj.startPoint)\n && typeof obj.endPoint == \"object\" && hasXY(obj.endPoint)\n && typeof obj.startControlPoint == \"object\" && hasXY(obj.startControlPoint)\n && typeof obj.endControlPoint == \"object\" && hasXY(obj.endControlPoint);\n */\n return obj instanceof CubicBezierCurve;\n };\n /**\n * Convert this curve to a JSON string.\n *\n * @method toJSON\n * @param {boolean=} [prettyFormat=false] - If set to true the function will add line breaks.\n * @instance\n * @memberof CubicBezierCurve\n * @return {string} The JSON data.\n **/\n CubicBezierCurve.prototype.toJSON = function (prettyFormat) {\n var jsonString = \"{ \" + // begin object\n (prettyFormat ? \"\\n\\t\" : \"\") +\n '\"startPoint\" : [' +\n this.getStartPoint().x +\n \",\" +\n this.getStartPoint().y +\n \"], \" +\n (prettyFormat ? \"\\n\\t\" : \"\") +\n '\"endPoint\" : [' +\n this.getEndPoint().x +\n \",\" +\n this.getEndPoint().y +\n \"], \" +\n (prettyFormat ? \"\\n\\t\" : \"\") +\n '\"startControlPoint\": [' +\n this.getStartControlPoint().x +\n \",\" +\n this.getStartControlPoint().y +\n \"], \" +\n (prettyFormat ? \"\\n\\t\" : \"\") +\n '\"endControlPoint\" : [' +\n this.getEndControlPoint().x +\n \",\" +\n this.getEndControlPoint().y +\n \"]\" +\n (prettyFormat ? \"\\n\\t\" : \"\") +\n \" }\"; // end object\n return jsonString;\n };\n /**\n * Parse a Bézier curve from the given JSON string.\n *\n * @method fromJSON\n * @param {string} jsonString - The JSON data to parse.\n * @memberof CubicBezierCurve\n * @static\n * @throws An exception if the JSON string is malformed.\n * @return {CubicBezierCurve}\n **/\n CubicBezierCurve.fromJSON = function (jsonString) {\n var obj = JSON.parse(jsonString);\n return CubicBezierCurve.fromObject(obj);\n };\n /**\n * Try to convert the passed object to a CubicBezierCurve.\n *\n * @method fromObject\n * @param {object} obj - The object to convert.\n * @memberof CubicBezierCurve\n * @static\n * @throws An exception if the passed object is malformed.\n * @return {CubicBezierCurve}\n **/\n CubicBezierCurve.fromObject = function (obj) {\n if (typeof obj !== \"object\")\n throw \"Can only build from object.\";\n if (!obj.startPoint)\n throw 'Object member \"startPoint\" missing.';\n if (!obj.endPoint)\n throw 'Object member \"endPoint\" missing.';\n if (!obj.startControlPoint)\n throw 'Object member \"startControlPoint\" missing.';\n if (!obj.endControlPoint)\n throw 'Object member \"endControlPoint\" missing.';\n return new CubicBezierCurve(new Vertex_1.Vertex(obj.startPoint[0], obj.startPoint[1]), new Vertex_1.Vertex(obj.endPoint[0], obj.endPoint[1]), new Vertex_1.Vertex(obj.startControlPoint[0], obj.startControlPoint[1]), new Vertex_1.Vertex(obj.endControlPoint[0], obj.endControlPoint[1]));\n };\n /**\n * Convert a 4-element array of vertices to a cubic bézier curve.\n *\n * @method fromArray\n * @param {Vertex[]} arr - [ startVertex, endVertex, startControlVertex, endControlVertex ]\n * @memberof CubicBezierCurve\n * @throws An exception if the passed array is malformed.\n * @return {CubicBezierCurve}\n **/\n CubicBezierCurve.fromArray = function (arr) {\n if (!Array.isArray(arr))\n throw \"Can only build from object.\";\n if (arr.length != 4)\n throw \"Can only build from array with four elements.\";\n return new CubicBezierCurve(arr[0], arr[1], arr[2], arr[3]);\n };\n /** @constant {number} */\n CubicBezierCurve.START_POINT = 0;\n /** @constant {number} */\n CubicBezierCurve.START_CONTROL_POINT = 1;\n /** @constant {number} */\n CubicBezierCurve.END_CONTROL_POINT = 2;\n /** @constant {number} */\n CubicBezierCurve.END_POINT = 3;\n /**\n * Helper utils.\n */\n CubicBezierCurve.utils = {\n evaluateT: function (p0, p1, p2, p3, t) {\n return p0 * Math.pow(1.0 - t, 3) +\n p1 * 3 * t * Math.pow(1.0 - t, 2) +\n p2 * 3 * Math.pow(t, 2) * (1.0 - t) +\n p3 * Math.pow(t, 3);\n },\n cubicPolyMinMax: function (p0, p1, p2, p3) {\n // var polyX = CubicBezierCurve.utils.cubicPoly2(\n // p0, // P[0].X, // bezierCurve.startPoint.x,\n // p1, // P[1].X, // bezierCurve.startControlPoint.x,\n // p2, // P[2].X, // bezierCurve.endControlPoint.x,\n // p3 // P[3].X // bezierCurve.endPoint.x\n // );\n // var a = polyX.a;\n // var b = polyX.b;\n // var c = polyX.c;\n // var disc = polyX.b * polyX.b - 4 * polyX.a * polyX.c;\n var polyX = CubicBezierCurve.utils.cubicPoly(p0, // P[0].X, // bezierCurve.startPoint.x,\n p1, // P[1].X, // bezierCurve.startControlPoint.x,\n p2, // P[2].X, // bezierCurve.endControlPoint.x,\n p3 // P[3].X // bezierCurve.endPoint.x\n );\n var a = polyX[0]; // .a;\n var b = polyX[1]; // .b;\n var c = polyX[2]; // .c;\n //alert(\"a \"+a+\" \"+b+\" \"+c);\n // var disc = b * b - 4 * a * c;\n var disc = polyX[1] * polyX[1] - 4 * polyX[0] * polyX[2];\n // var polyX = CubicBezierCurve.utils.bezierCoeffs(p3,p2,p1,p0);\n // var a = polyX[0]; //polyX.a;\n // var b = polyX[1]; // .b;\n // var c = polyX[2]; //.c;\n // var disc = polyX[1] * polyX[1] - 4 * polyX[0] * polyX[2];\n // var xl = Math.min(bCurve.endPoint.x, bCurve.startPoint.x); // P[0].X;\n // var xh = Math.max(bCurve.endPoint.x, bCurve.startPoint.x); // P[0].X;\n var xl = Math.min(p3, p0); // P[0].X;\n var xh = Math.max(p3, p0); // P[0].X;\n // if (P[3].X < xl) xl = P[3].X;\n // if (P[3].X > xh) xh = P[3].X;\n if (disc >= 0) {\n var t1 = (-b + Math.sqrt(disc)) / (2 * a);\n // alert(\"t1 \" + t1);\n if (t1 > 0 && t1 < 1) {\n // var x1 = evalBez(PX, t1);\n // var x1 = bCurve.getPointAt(t1).x;\n var x1 = CubicBezierCurve.utils.evaluateT(p0, p1, p2, p3, t1); // bCurve.getPointAt(t1).x;\n if (x1 < xl)\n xl = x1;\n if (x1 > xh)\n xh = x1;\n }\n var t2 = (-b - Math.sqrt(disc)) / (2 * a);\n // alert(\"t2 \" + t2);\n if (t2 > 0 && t2 < 1) {\n // var x2 = evalBez(PX, t2);\n // var x2 = bCurve.getPointAt(t2).x;\n var x2 = CubicBezierCurve.utils.evaluateT(p0, p1, p2, p3, t2); //\n if (x2 < xl)\n xl = x2;\n if (x2 > xh)\n xh = x2;\n }\n }\n return { min: xl, max: xh };\n },\n /**\n * Get the points of a sub curve at the given start end end offsets (values between 0.0 and 1.0).\n *\n * tStart >= tEnd is allowed, you will get a reversed sub curve then.\n *\n * @method getSubCurvePointsAt\n * @param {CubicBezierCurve} curve – The curve to get the sub curve points from.\n * @param {number} tStart – The start offset of the desired sub curve (must be in [0..1]).\n * @param {number} tEnd – The end offset if the desired cub curve (must be in [0..1]).\n * @instance\n * @memberof CubicBezierCurve\n * @return {CubicBezierCurve} The sub curve as a new curve.\n **/\n getSubCurvePointsAt: function (curve, tStart, tEnd) {\n var startVec = new Vector_1.Vector(curve.getPointAt(tStart), curve.getTangentAt(tStart));\n var endVec = new Vector_1.Vector(curve.getPointAt(tEnd), curve.getTangentAt(tEnd).inv());\n // Tangents are relative. Make absolute.\n startVec.b.add(startVec.a);\n endVec.b.add(endVec.a);\n // This 'splits' the curve at the given point at t.\n startVec.scale(0.33333333 * (tEnd - tStart));\n endVec.scale(0.33333333 * (tEnd - tStart));\n return [startVec.a, endVec.a, startVec.b, endVec.b];\n },\n /**\n * Compute the cubic roots for the given cubic polynomial coefficients.\n *\n * Based on\n * http://mysite.verizon.net/res148h4j/javascript/script_exact_cubic.html#the%20source%20code\n * Inspired by\n * https://www.particleincell.com/2013/cubic-line-intersection/\n * Thanks to Stephan Schmitt and Particle-In-Cell!\n *\n * @param poly\n * @returns\n */\n cubicRoots: function (poly) {\n var a = poly[0];\n var b = poly[1];\n var c = poly[2];\n var d = poly[3];\n var A = b / a;\n var B = c / a;\n var C = d / a;\n var S, T, Im;\n var Q = (3 * B - Math.pow(A, 2)) / 9;\n var R = (9 * A * B - 27 * C - 2 * Math.pow(A, 3)) / 54;\n var D = Math.pow(Q, 3) + Math.pow(R, 2); // polynomial discriminant\n var ts = []; // Array();\n if (D >= 0) {\n // complex or duplicate roots\n S = CubicBezierCurve.utils.sgn(R + Math.sqrt(D)) * Math.pow(Math.abs(R + Math.sqrt(D)), 1 / 3);\n T = CubicBezierCurve.utils.sgn(R - Math.sqrt(D)) * Math.pow(Math.abs(R - Math.sqrt(D)), 1 / 3);\n ts[0] = -A / 3 + (S + T); // real root\n ts[1] = -A / 3 - (S + T) / 2; // real part of complex root\n ts[2] = -A / 3 - (S + T) / 2; // real part of complex root\n Im = Math.abs((Math.sqrt(3) * (S - T)) / 2); // complex part of root pair\n // Mark complex roots to be discarded\n if (Im != 0) {\n ts[1] = -1;\n ts[2] = -1;\n }\n } // distinct real roots\n else {\n var th = Math.acos(R / Math.sqrt(-Math.pow(Q, 3)));\n ts[0] = 2 * Math.sqrt(-Q) * Math.cos(th / 3) - A / 3;\n ts[1] = 2 * Math.sqrt(-Q) * Math.cos((th + 2 * Math.PI) / 3) - A / 3;\n ts[2] = 2 * Math.sqrt(-Q) * Math.cos((th + 4 * Math.PI) / 3) - A / 3;\n Im = 0.0;\n }\n // Discard all t's out of spec and sort the rest\n return ts.filter(function (t) { return t >= 0 && t <= 1.0; }).sort();\n },\n /**\n * Compute the Bézier coefficients from the given Bézier point coordinates.\n *\n * @param {number} p0 - The start point coordinate.\n * @param {number} p1 - The start control point coordinate.\n * @param {number} p2 - The end control point coordinate.\n * @param {number} p3 - The end point coordinate.\n * @returns {[number,number,number,number]}\n */\n bezierCoeffs: function (p0, p1, p2, p3) {\n var coeffs = [NaN, NaN, NaN, NaN]; //Array(4);\n coeffs[0] = -p0 + 3 * p1 + -3 * p2 + p3;\n coeffs[1] = 3 * p0 - 6 * p1 + 3 * p2;\n coeffs[2] = -3 * p0 + 3 * p1;\n coeffs[3] = p0;\n return coeffs;\n },\n /**\n * Calculate the cubic polynomial coefficients used to find the bounding box.\n *\n * @param {number} p0 - The start point coordinate.\n * @param {number} p1 - The start control point coordinate.\n * @param {number} p2 - The end control point coordinate.\n * @param {number} p3 - The end point coordinate.\n * @returns {[number,number,number]}\n */\n cubicPoly: function (p0, p1, p2, p3) {\n return [\n 3 * p3 - 9 * p2 + 9 * p1 - 3 * p0,\n 6 * p0 - 12 * p1 + 6 * p2,\n 3 * p1 - 3 * p0\n ];\n },\n /**\n * sign of number, but is division safe: no zero returned :)\n */\n sgn: function (x) {\n return x < 0.0 ? -1 : 1;\n }\n };\n return CubicBezierCurve;\n}());\nexports.CubicBezierCurve = CubicBezierCurve;\n//# sourceMappingURL=CubicBezierCurve.js.map","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","\"use strict\";\n/* Imports for webpack */\n\nglobalThis.UIDGenerator = require(\"./UIDGenerator.js\").UIDGenerator;\nglobalThis.VertexAttr = require(\"./VertexAttr.js\").VertexAttr;\nglobalThis.VertexListeners = require(\"./VertexListeners.js\").VertexListeners;\nglobalThis.Vertex = require(\"./Vertex.js\").Vertex;\n\nglobalThis.Bounds = require(\"./Bounds.js\").Bounds;\nglobalThis.Grid = require(\"./Grid.js\").Grid;\nglobalThis.Line = require(\"./Line.js\").Line;\nglobalThis.Vector = require(\"./Vector.js\").Vector;\nglobalThis.CubicBezierCurve = require(\"./CubicBezierCurve.js\").CubicBezierCurve;\nglobalThis.BezierPath = require(\"./BezierPath.js\").BezierPath;\nglobalThis.Polygon = require(\"./Polygon.js\").Polygon;\nglobalThis.Triangle = require(\"./Triangle.js\").Triangle;\nglobalThis.VEllipse = require(\"./VEllipse.js\").VEllipse;\nglobalThis.VEllipseSector = require(\"./VEllipseSector.js\").VEllipseSector;\nglobalThis.Circle = require(\"./Circle.js\").Circle;\nglobalThis.CircleSector = require(\"./CircleSector.js\").CircleSector;\nglobalThis.PBImage = require(\"./PBImage.js\").PBImage;\nglobalThis.PBText = require(\"./PBText.js\").PBText;\nglobalThis.MouseHandler = require(\"./MouseHandler.js\").MouseHandler;\nglobalThis.KeyHandler = require(\"./KeyHandler.js\").KeyHandler;\nglobalThis.drawutils = require(\"./draw.js\").drawutils;\n// globalThis.drawutilsgl = require(\"./drawgl.js\").drawutilsgl; // Unfinished\nglobalThis.drawutilssvg = require(\"./drawutilssvg.js\").drawutilssvg;\nglobalThis.geomutils = require(\"./geomutils.js\").geomutils;\nglobalThis.PlotBoilerplate = require(\"./PlotBoilerplate.js\").PlotBoilerplate;\n"],"names":["extendStatics","__extends","this","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","TypeError","String","__","constructor","create","defineProperty","exports","value","Vector","VertTuple_1","Vertex_1","_super","vertA","vertB","_this","a","className","perp","v","clone","sub","Vertex","y","x","add","inverse","tmp","inv","intersection","line","denominator","numerator1","numerator2","getOrthogonal","linePoint","startPoint","rotate","angle","utils","buildArrowHead","zA","zB","headlen","scaleX","scaleY","Math","atan2","vertices","push","cos","sin","PI","VertTuple","drawutils","CubicBezierCurve_1","drawutilssvg_1","Vector_1","context","fillShapes","ctx","offset","scale","applyStrokeOpts","strokeOptions","_a","_b","_c","_d","setLineDash","dashArray","map","dashArrayElem","lineDashOffset","dashOffset","lineJoin","lineCap","_fillOrDraw","color","fillStyle","fill","strokeStyle","stroke","beginDrawCycle","renderTime","endDrawCycle","setConfiguration","configuration","globalCompositeOperation","blendMode","setCurrentId","uid","setCurrentClassName","lineWidth","save","beginPath","moveTo","lineTo","restore","arrow","headLength","arrowHeadBasePosition","arrowHead","undefined","cubicBezierArrow","endPoint","startControlPoint","endControlPoint","diff","difference","cubicBezier","arrowHeadBasePositionBuffer","i","length","image","position","size","alpha","complete","naturalWidth","globalAlpha","drawImage","naturalHeight","texturedPoly","textureImage","textureSize","polygon","polygonPosition","rotation","basePolygonBounds","getBounds","targetTextureSize","getCenter","width","height","targetTextureOffset","min","translate","helpers","clipPoly","rect","closePath","bounds","max","CubicBezierCurve","bezierCurveTo","quadraticBezier","controlPoint","quadraticCurveTo","cubicBezierPath","path","isOpen","handle","point","square","handleLine","dot","round","arc","circle","center","radius","ellipse","circleArc","startAngle","endAngle","options","asSegment","radiusX","radiusY","grid","sizeX","sizeY","yMin","ceil","yMax","xMin","xMax","raster","diamondHandle","squareHandle","circleHandle","crosshair","cross","polyline","text","relX","relY","fontSize","fontFamily","font","fontWeight","fontStyle","indexOf","concat","textAlign","lineHeight","fillText","strokeText","label","pathData","inplace","drawutilssvg","copyPathData","transformPathData","Path2D","join","clear","clearRect","canvas","fillRect","vert","clip","Bounds","Polygon_1","containsVert","getWidth","getHeight","getScaled","scaleFactor","getMoved","moveAmount","move","getNorthPoint","getSouthPoint","getWestPoint","getEastPoint","getNorthWestPoint","getNorthEastPoint","getSouthEastPoint","getSouthWestPoint","toPolygon","Polygon","getMinDimension","getMaxDimension","randomPoint","horizontalSafeArea","verticalSafeArea","absHorizontalSafeArea","absVerticalSafeArea","random","toString","computeFromVertices","computeFromBoundsSet","boundingBoxes","fromDimension","origin","Circle","Bounds_1","Line_1","UIDGenerator_1","geomutils_1","UIDGenerator","next","setRadius","amount","containsPoint","circleUtils","containsCircle","epsilon","Number","isNaN","distance","abs","lineDistance","getClosestPoint","vertAt","tangentAt","pointA","subXY","addXY","circleIntersection","p0","p1","h","sqrt","p2","x3","y3","x4","y4","Line","lineIntersection","interA","interB","transA","transB","dist","det","distSquared","belowSqrt","sign","lineIntersections","inVectorBoundsOnly","intersectioLine","filter","hasPoint","lineIntersectionTangents","radicalAxis","circleB","helperCircle","createRadicalAxisHelperCircle","intersectionLineA","intersectionLineB","console","error","lineA","lineB","firstRadicalAxisPoint","secondRadicalAxisPoint_mirrored","closestPoint","tangentsFromPoint","centerDistance","tangentLength","log","fromICircle","obj","destroy","isDestroyed","circleCenter","circleRadius","geomutils","dist4","circleA","circleConnectLine","set","bisector","bisectorLength","setLength","circleDistance","CircleSector","Circle_1","_self","circleBounds","candidates","containsAngle","getStartPoint","getEndPoint","wrappedAngle","mapAngleTo2PI","wrappedStart","wrappedEnd","angleAt","t","circleSectorIntersection","sector","radicalLine","thisIntersectionAngleA","thisIntersectionAngleB","thatIntersectionAngleA","thatIntersectionAngleB","centerOfOriginalGap","resultSector","ray","ellipseIntersections","tmpLine","intersectionPoint","lineAngle","wrapMinMax","describeSVGPath","circleSectorUtils","describeSVGArc","polarToCartesian","centerX","centerY","moveToStart","end","start","firstHalf","secondHalf","largeArcFlag","sweepFlag","drawutilsgl","gl","_zindex","glutils","GLU","_vertShader","compileShader","vertCode","VERTEX_SHADER","_fragShader","fragCode","FRAGMENT_SHADER","_program","makeProgram","vertex_buffer","createBuffer","_x2rel","_y2rel","copyInstance","copy","curId","Float32Array","bindBuffer","ARRAY_BUFFER","bufferData","STATIC_DRAW","coord","getAttribLocation","vertexAttribPointer","FLOAT","enableVertexAttribArray","viewport","uRotationVector","getUniformLocation","uniform2fv","drawArrays","LINES","TRIANGLE_FAN","clearColor","enable","DEPTH_TEST","COLOR_BUFFER_BIT","DEPTH_BUFFER_BIT","verts","vbuffer","shaderCode","shaderType","shader","createShader","shaderSource","getShaderParameter","COMPILE_STATUS","warn","getShaderInfoLog","deleteShader","vertShader","fragShader","program","createProgram","attachShader","linkProgram","useProgram","detachShader","Grid","baseLog","base","num","mapRasterScale","adjustFactor","gf","floor","pow","Triangle_1","new_angle","asin","x1","y1","x2","y2","dotProduct","nsectAngle","pA","pB","pC","n","triangle","Triangle","lineAB","lineAC","insideAngle","clockwise","determinant","result","wrapMax","CircleSector_1","RAD_TO_DEG","svgNode","canvasSize","drawConfig","isSecondary","gNode","bufferGNode","nodeDefs","bufferNodeDefs","nodeStyle","Boolean","drawlibConfiguration","cache","Map","setSize","bufferedNodeDefs","addStyleDefs","addDefsNode","createSVGNode","appendChild","rebuildStyleDefs","keys","rules","k","drawSettings","customStyleDefs","forEach","key","innerHTML","addCustomStyleDefs","defs","findElement","nodeName","node","get","toUpperCase","delete","document","createElementNS","makeNode","style","_bindFillDraw","_configureNode","_bindNode","bindingParent","parentNode","_addCSSClasses","curClassName","setAttribute","fillMode","childNodes","child","getAttribute","removeAllChildNodes","replaceChild","tmpGNode","tmpDefsNode","nodeSupportsLineDash","tagName","dashArayElem","nodeSupportsLineJoin","nodeSupportsLineCap","_x","_y","makeLineNode","group","makeArrowHeadNode","bezier","makeCubicBezierNode","setImageSize","ratioX","ratioY","addEventListener","event","src","rotatedScalingOrigin","clipPathNode","clipPathId","imageNode","pathNode","clipNode","arcData","transformOrigin","textNode","lastChild","removeChild","createSvg","data","slice","_stx","index","_sty","_sx","_sy","lastPoint","NaN","_slp","includes","classNameOverride","makePathNode","pathString","HEAD_XML","VertexAttr","draggable","selectable","isSelected","visible","model","KeyHandler","downListeners","pressListeners","upListeners","keyStates","element","globalThis","trackAllKeys","trackAll","installListeners","fireEvent","listeners","hasListener","lis","keyCode","listener","fireDownEvent","e","handler","firePressEvent","fireUpEvent","key2code","KEY_CODES","_keyDownListener","_keyPressListener","_keyUpListener","releaseListeners","removeEventListener","down","press","up","isDown","__setFunctionName","f","name","prefix","description","configurable","PlotBoilerplate","alloyfinger_typescript_1","draw_1","drawgl_1","BezierPath_1","Grid_1","KeyHandler_1","MouseHandler_1","PBImage_1","VEllipse_1","VEllipseSector_1","VertexAttr_1","PBText_1","config","contentChangeListeners","_gui","bezierAutoAdjust","fetch","fullSize","val","fitToParent","bool","offsetX","offsetY","rasterGrid","drawRaster","rasterScaleX","rasterScaleY","rasterAdjustFactor","drawOrigin","autoAdjustOffset","offsetAdjustXPercent","offsetAdjustYPercent","backgroundColor","redrawOnResize","defaultCanvasWidth","DEFAULT_CANVAS_WIDTH","defaultCanvasHeight","DEFAULT_CANVAS_HEIGHT","canvasWidthFactor","canvasHeightFactor","cssScaleX","cssScaleY","cssUniformScale","saveFile","hooks","setToRetina","_setToRetina","autoDetectRetina","enableSVGExport","preClear","func","preDraw","postDraw","enableMouse","enableTouch","enableKeys","enableMouseWheel","enableZoom","enablePan","enableGL","isBackdropFiltersEnabled","drawVertices","drawBezierHandleLines","drawBezierHandlePoints","drawHandleLines","drawHandlePoints","drawGrid","pathVertex","controlVertex","ellipseSector","circleSector","vertex","selectedVertex","vector","anchor","canvasElement","querySelector","toLowerCase","eventCatcher","getContext","draw","parentElement","createElement","left","top","cursor","body","title","selectPolygon","draggedElements","drawables","_saveFile","resizeCanvas","installInputListeners","updateCSSscale","redraw","focus","pb","tosvgDraw","tosvgFill","drawAll","svgCode","XMLSerializer","serializeToString","blob","Blob","type","_saveAs","pixelRatio","devicePixelRatio","isPanning","isInPanningMode","fitToView","canvasCenter","canvasRatio","ratio","setOffset","newUniformZoom","setZoom","setConsole","con","_e","setCSSscale","addContentChangeListener","removeContentChangeListener","splice","_fireContentChanged","addedDrawables","removedDrawables","drawable","doNotFireEvent","isArray","arr","addDragListener","params","dragAmount","VEllipse","axis","VEllipseSector","c","BezierPath","bezierPath","bezierCurves","adjustCircular","attr","enableBezierPathAutoAdjust","PBImage","upperLeft","lowerRight","PBText","remove","removeWithVertices","removedDrawables_1","wasRemoved_1","removeVertex","wasRemoved","removeAll","keepVertices","triggerRedraw","getVertexNear","pixelPosition","pixelTolerance","locatePointNear","transformMousePosition","typeName","vindex","gScale","gSize","cs","_handleColor","drawDrawables","drawDrawable","curveIndex","df","signedRadiusV","signedRadiusH","radiusH","radiusV","ellipseSectorUtils","drawSelectPolygon","clearSelection","getFProp","elem","propName","parseFloat","getComputedStyle","getPropertyValue","getAvailableContainerSpace","container","display","padding","border","pl","pr","pt","bl","br","bt","bb","w","clientWidth","clientHeight","_f","_g","_setSize","HTMLCanvasElement","SVGElement","adjustOffset","innerWidth","documentElement","innerHeight","space","selectVerticesInPolygon","tolerance","Draggable","VERTEX","setVIndex","handleClick","pos","DEFAULT_CLICK_TOLERANCE","fireClickEvent","keyHandler","paths","pindex","cindex","getPointByID","pid","revertMousePosition","getDraggedElementCount","mouseDownHandler","button","draggablePoint","fireDragStartEvent","mouseDragHandler","oldDragAmount","moveCurvePoint","fireDragEvent","mouseUpHandler","wasDragged","fireDragEndEvent","mouseWheelHandler","zoomStep","we","deltaY","preventDefault","newOffset","zoomFactorX","zoomFactorY","interactionPos","oldPos","newPos","newOffsetX","newOffsetY","MouseHandler","drag","wheel","relPos_1","getBoundingClientRect","touchMovePos","touchDownPos","draggedElement","multiTouchStartScale","clearTouch_1","afProps","touchStart","evt","touches","clientX","clientY","DEFAULT_TOUCH_TOLERANCE","draggingVertex","fakeEvent","isTouchEvent","mouseDownPos","mouseDragPos","touchMove","stopPropagation","rel","trans","deltaX","touchEnd","touchCancel","multipointStart","multipointEnd","pinch","touchItem0","item","touchItem1","fingerA","fingerB","zoom","window","createAlloyFinger","default","createGUI","props","getGUI","class_1","isVertex","safeMergeByKeys","extension","typ","extVal","JSON","parse","removeProperty","transform","fallback","locateCurveByStartPoint","START_POINT","updateArcLengths","locateCurveByStartControlPoint","adjustPredecessorControlPoint","locateCurveByEndControlPoint","adjustSuccessorControlPoint","locateCurveByEndPoint","END_CONTROL_POINT","factory","revert","normalize","factor","newA","v0","v1","colinear","EPSILON","getClosestT","l2","vtutils","dist2","insideBoundsOnly","pointDistance","calcCircumcircle","p1x","p1y","cx","cy","getLen","HandlerAdmin","el","handlers","del","dispatch","_args","len","apply","arguments","wrapFunc","handlerAdmin","AlloyFinger","option","bind","cancel","preV","pinchStartLen","isDoubleTap","noop","swipe","tap","doubleTap","longTap","singleTap","pressMove","twoFingerPressMove","_cancelAllHandler","cancelAll","delta","last","now","tapTimeout","singleTapTimeout","longTapTimeout","swipeTimeout","preTapPosition","Date","pageX","pageY","clearTimeout","_cancelLongTap","_cancelSingleTap","_preventTap","setTimeout","afEvent","currentX","currentY","sCurrentX","sCurrentY","v2","mr","r","acos","getAngle","sx2","sy2","movedX","movedY","changedTouches","self","direction","_swipeDirection","on","off","addVertex","addVertexAt","getEdgeAt","vertIndex","getVertexAt","getEdges","lines","getInnerAngleAt","p3","isAcute","isAngleAcute","zero","p2mp1","p3mp2","p2mp1_len","p3mp2_len","lengthProduct","A","B","C","inside","j","xi","yi","xj","yj","containsVerts","every","containsPolygon","lineSegment","area","signedArea","isClockwise","perimeter","getMeanCenter","getCentroid","cur","locateLineIntersecion","intersectionTuple","polyLine","edgeIndex","lineIntersectionTangentsIndices","closestLineIntersection","closestInterSectionIndex","closestLineIntersectionIndex","allIntersections","closestIntersection","MAX_VALUE","curDist","curVert","getInterpolationPolygon","interpolationCount","nextVert","lerpAmount","lerp","getEvenDistributionPolygon","pointCount","Error","polygonPoint","stepSize","polygonIndex","nextPolygonPoint","segmentLength","loopMax","curSegmentU","newPoint","lerpAbs","elimitateColinearEdges","eps","areColinear","vertC","toQuadraticBezierData","qbezier","cc0","cc1","edgeCenter","limit","toQuadraticBezierSVGString","qdata","buffer","toCubicBezierData","threshold","cbezier","aCenter","bCenter","a2","b0","toCubicBezierSVGString","toCubicBezierPath","pathdata","fromArray","total","l","sum","intersectionPoints","sAngle","eAngle","getExtremePoints","toCubicBezier","quarterSegmentCount","segmentCount","normalizeAngle","angles","equidistantVertAngles","curves","curAngle","nextAngle","startTangent","endTangent","curve","startDiff","endDiff","r2d","fullEllipsePointCount","ellipseAngles","startIndex","findClosestToStartAngle","ea","endpointToCenterParameters","rx","ry","phi","fa","fs","sinphi","cosphi","px","py","prx","pry","L","M","_cx","_cy","START_CONTROL_POINT","END_POINT","totalArcLength","addCurve","getLength","equals","getCurveCount","getCurveAt","getStartControlPoint","getEndControlPoint","scaleXY","scaleFactors","minIndex","minDist","curveT","uMin","u","getPointAt","getPoint","uTemp","relativeU","getTangentAt","getTangent","getPerpendicularAt","getPerpendicular","uResult","_locateUIndex","bCurve","uPart","reduce","accu","curCurve","uBefore","getSubPathAt","startT","endT","startU","endU","uStartResult","uEndResult","firstT","lastT","firstCurve","getSubCurveAt","reverse","pointID","obtainHandleLength","mainCurve","neighbourCurve","adjustNeighbourControlPoint","_mainCurve","mainPoint","mainControlPoint","neighbourPoint","neighbourControlPoint","obtainHandleLengths","_updateArcLengths","mainHandleBounds","neighbourHandleBounds","mainHandleLength","neighbourHandleLength","POSITIVE_INFINITY","NEGATIVE_INFINITY","getEvenDistributionVertices","arcLength","toPathPoints","toJSON","prettyFormat","fromJSON","jsonString","fromCurve","bPath","lastCurve","isInstance","fromObject","toReducedListRepresentation","digits","toFixed","fromReducedListRepresentation","listJSON","pointArray","fromReducedList","getArea","scaleToCentroid","centroid","getCircumcircle","getMinimumEnclosingCircle","circleAB","circleBC","circleCA","circumCircle","isAdjacent","tri","getThirdVertex","vert1","vert2","getVertices","tmpCircle","radius_squared","inCircumcircle","dx","dy","modIndex","pointIsInTriangle","getIncircularTriangle","lineC","bisector1","bisector2","getIncircle","getIncenter","max3","min3","p0x","p0y","p2x","p2y","s","D","E","F","G","VertexListeners_1","tuple","VertexListeners","setX","setY","invX","invY","amountX","amountY","addX","addY","subX","subY","eqX","eqY","target","step","factors","ZERO","multiplyScalar","scalar","findClosestPoint","pointB","findFarestPoint","precision","removeAllListeners","randomVertex","viewPort","arrayToJSON","stringify","x_max","x_min","t_x1","t_x2","x_x1","y_x1","x_x2","y_x2","y_max","y_min","t_y1","t_y2","x_y1","y_y1","x_y2","y_y2","r1","r2","ux","uy","vx","vy","bbox_halfwidth","bbox_halfheight","normalAt","foci","getFoci","angleA","centerAngle","endPointA","endPointB","resultVector","rh","rv","sdiff","getEquidistantVertices","ellipseCopy","rayCopy","rotationAmount","scalingFactors","intersections","phiToTheta","tanPhi","tan","tanPhi2","atan","theta","XWheelEvent","XMouseEvent","MouseEvent","WheelEvent","mouseButton","installed","mousemove","mkParams","relPos","mouseup","mousedown","click","eventName","xEvent","leftButton","middleButton","rightButton","draggedFrom","listenFor","unlistenFor","callback","throwAlreadyInstalled","dragStart","dragEnd","addClickListener","_addListener","removeClickListener","_removeListener","removeDragListener","addDragStartListener","removeDragStartListener","addDragEndListener","removeDragEndListener","_fireEvent","ve","newListener","oldListener","current","getStartTangent","getEndTangent","intrsctn","curveIntervals","segmentCache","segmentLengths","moveControlPoint","curveStep","tmpLength","newLength","tPrev","tNext","iteration","locateIntervalByDistance","tStart","tEnd","stepCount","tDiff","xMinMax","cubicPolyMinMax","xl","xh","yMinMax","yl","yh","id","evaluateT","t2","nt2","tX","tY","trimStart","uValue","trimStartAt","convertU2T","subCurbePoints","getSubCurvePointsAt","trimEnd","trimEndAt","getSubCurve","uStart","uEnd","tangentVector","lineIntersectionTs","intersectionTangents","vec","bx","bezierCoeffs","by","poly","cubicRoots","root","polyX","cubicPoly","disc","t1","startVec","endVec","S","T","Q","R","ts","sgn","th","sort","coeffs","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","module","__webpack_modules__","definition","o","enumerable","prop","Symbol","toStringTag"],"sourceRoot":""}