js-draw 0.23.1 → 0.24.1

package/dist/cjs/math/lib.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vec2 = exports.Vec3 = exports.Rect2 = exports.Path = exports.Mat33 = exports.LineSegment2 = void 0;
+var LineSegment2_1 = require("./shapes/LineSegment2");
+exports.LineSegment2 = LineSegment2_1.default;
+var Mat33_1 = require("./Mat33");
+exports.Mat33 = Mat33_1.default;
+var Path_1 = require("./shapes/Path");
+exports.Path = Path_1.default;
+var Rect2_1 = require("./shapes/Rect2");
+exports.Rect2 = Rect2_1.default;
+var Vec2_1 = require("./Vec2");
+Object.defineProperty(exports, "Vec2", { enumerable: true, get: function () { return Vec2_1.Vec2; } });
+var Vec3_1 = require("./Vec3");
+exports.Vec3 = Vec3_1.default;

package/dist/cjs/math/polynomial/solveQuadratic.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Solves an equation of the form ax² + bx + c = 0.
+ * The larger solution is returned first.
+ *
+ * If there are no solutions, returns `[NaN, NaN]`. If there is one solution,
+ * repeats the solution twice in the result.
+ */
+declare const solveQuadratic: (a: number, b: number, c: number) => [number, number];
+export default solveQuadratic;

package/dist/cjs/math/polynomial/solveQuadratic.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Solves an equation of the form ax² + bx + c = 0.
+ * The larger solution is returned first.
+ *
+ * If there are no solutions, returns `[NaN, NaN]`. If there is one solution,
+ * repeats the solution twice in the result.
+ */
+var solveQuadratic = function (a, b, c) {
+    // See also https://en.wikipedia.org/wiki/Quadratic_formula
+    if (a === 0) {
+        var solution = void 0;
+        if (b === 0) {
+            solution = c === 0 ? 0 : NaN;
+        }
+        else {
+            // Then we have bx + c = 0
+            // which implies bx = -c.
+            // Thus, x = -c/b
+            solution = -c / b;
+        }
+        return [solution, solution];
+    }
+    var discriminant = b * b - 4 * a * c;
+    if (discriminant < 0) {
+        return [NaN, NaN];
+    }
+    var rootDiscriminant = Math.sqrt(discriminant);
+    var solution1 = (-b + rootDiscriminant) / (2 * a);
+    var solution2 = (-b - rootDiscriminant) / (2 * a);
+    if (solution1 > solution2) {
+        return [solution1, solution2];
+    }
+    else {
+        return [solution2, solution1];
+    }
+};
+exports.default = solveQuadratic;

package/dist/cjs/math/polynomial/solveQuadratic.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/math/rounding.js

@@ -0,0 +1,140 @@
+"use strict";
+// @packageDocumentation @internal
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toStringOfSamePrecision = exports.getLenAfterDecimal = exports.toRoundedString = exports.cleanUpNumber = void 0;
+// Clean up stringified numbers
+var cleanUpNumber = function (text) {
+    // Regular expression substitions can be somewhat expensive. Only do them
+    // if necessary.
+    if (text.indexOf('e') > 0) {
+        // Round to zero.
+        if (text.match(/[eE][-]\d{2,}$/)) {
+            return '0';
+        }
+    }
+    var lastChar = text.charAt(text.length - 1);
+    if (lastChar === '0' || lastChar === '.') {
+        // Remove trailing zeroes
+        text = text.replace(/([.]\d*[^0]+)0+$/, '$1');
+        text = text.replace(/[.]0+$/, '.');
+        // Remove trailing period
+        text = text.replace(/[.]$/, '');
+    }
+    var firstChar = text.charAt(0);
+    if (firstChar === '0' || firstChar === '-') {
+        // Remove unnecessary leading zeroes.
+        text = text.replace(/^(0+)[.]/, '.');
+        text = text.replace(/^-(0+)[.]/, '-.');
+        text = text.replace(/^(-?)0+$/, '$10');
+    }
+    if (text === '-0') {
+        return '0';
+    }
+    return text;
+};
+exports.cleanUpNumber = cleanUpNumber;
+var toRoundedString = function (num) {
+    // Try to remove rounding errors. If the number ends in at least three/four zeroes
+    // (or nines) just one or two digits, it's probably a rounding error.
+    var fixRoundingUpExp = /^([-]?\d*\.\d{3,})0{4,}\d{1,4}$/;
+    var hasRoundingDownExp = /^([-]?)(\d*)\.(\d{3,}9{4,})\d{1,4}$/;
+    var text = num.toString(10);
+    if (text.indexOf('.') === -1) {
+        return text;
+    }
+    var roundingDownMatch = hasRoundingDownExp.exec(text);
+    if (roundingDownMatch) {
+        var negativeSign = roundingDownMatch[1];
+        var postDecimalString = roundingDownMatch[3];
+        var lastDigit = parseInt(postDecimalString.charAt(postDecimalString.length - 1), 10);
+        var postDecimal = parseInt(postDecimalString, 10);
+        var preDecimal = parseInt(roundingDownMatch[2], 10);
+        var origPostDecimalString = roundingDownMatch[3];
+        var newPostDecimal = (postDecimal + 10 - lastDigit).toString();
+        var carry = 0;
+        if (newPostDecimal.length > postDecimal.toString().length) {
+            // Left-shift
+            newPostDecimal = newPostDecimal.substring(1);
+            carry = 1;
+        }
+        // parseInt(...).toString() removes leading zeroes. Add them back.
+        while (newPostDecimal.length < origPostDecimalString.length) {
+            newPostDecimal = carry.toString(10) + newPostDecimal;
+            carry = 0;
+        }
+        text = "".concat(negativeSign + (preDecimal + carry).toString(), ".").concat(newPostDecimal);
+    }
+    text = text.replace(fixRoundingUpExp, '$1');
+    return (0, exports.cleanUpNumber)(text);
+};
+exports.toRoundedString = toRoundedString;
+var numberExp = /^([-]?)(\d*)[.](\d+)$/;
+var getLenAfterDecimal = function (numberAsString) {
+    var numberMatch = numberExp.exec(numberAsString);
+    if (!numberMatch) {
+        // If not a match, either the number is exponential notation (or is something
+        // like NaN or Infinity)
+        if (numberAsString.search(/[eE]/) !== -1 || /^[a-zA-Z]+$/.exec(numberAsString)) {
+            return -1;
+            // Or it has no decimal point
+        }
+        else {
+            return 0;
+        }
+    }
+    var afterDecimalLen = numberMatch[3].length;
+    return afterDecimalLen;
+};
+exports.getLenAfterDecimal = getLenAfterDecimal;
+// [reference] should be a string representation of a base-10 number (no exponential (e.g. 10e10))
+var toStringOfSamePrecision = function (num) {
+    var references = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        references[_i - 1] = arguments[_i];
+    }
+    var text = num.toString(10);
+    var textMatch = numberExp.exec(text);
+    if (!textMatch) {
+        return text;
+    }
+    var decimalPlaces = -1;
+    for (var _a = 0, references_1 = references; _a < references_1.length; _a++) {
+        var reference = references_1[_a];
+        decimalPlaces = Math.max((0, exports.getLenAfterDecimal)(reference), decimalPlaces);
+    }
+    if (decimalPlaces === -1) {
+        return (0, exports.toRoundedString)(num);
+    }
+    // Make text's after decimal length match [afterDecimalLen].
+    var postDecimal = textMatch[3].substring(0, decimalPlaces);
+    var preDecimal = textMatch[2];
+    var nextDigit = textMatch[3].charAt(decimalPlaces);
+    if (nextDigit !== '') {
+        var asNumber = parseInt(nextDigit, 10);
+        if (asNumber >= 5) {
+            // Don't attempt to parseInt() an empty string.
+            if (postDecimal.length > 0) {
+                var leadingZeroMatch = /^(0+)(\d*)$/.exec(postDecimal);
+                var leadingZeroes = '';
+                var postLeading = postDecimal;
+                if (leadingZeroMatch) {
+                    leadingZeroes = leadingZeroMatch[1];
+                    postLeading = leadingZeroMatch[2];
+                }
+                postDecimal = (parseInt(postDecimal) + 1).toString();
+                // If postDecimal got longer, remove leading zeroes if possible
+                if (postDecimal.length > postLeading.length && leadingZeroes.length > 0) {
+                    leadingZeroes = leadingZeroes.substring(1);
+                }
+                postDecimal = leadingZeroes + postDecimal;
+            }
+            if (postDecimal.length === 0 || postDecimal.length > decimalPlaces) {
+                preDecimal = (parseInt(preDecimal) + 1).toString();
+                postDecimal = postDecimal.substring(1);
+            }
+        }
+    }
+    var negativeSign = textMatch[1];
+    return (0, exports.cleanUpNumber)("".concat(negativeSign).concat(preDecimal, ".").concat(postDecimal));
+};
+exports.toStringOfSamePrecision = toStringOfSamePrecision;

package/dist/cjs/math/rounding.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/math/shapes/Abstract2DShape.d.ts

@@ -0,0 +1,49 @@
+import LineSegment2 from './LineSegment2';
+import { Point2 } from '../Vec2';
+import Rect2 from './Rect2';
+declare abstract class Abstract2DShape {
+    protected static readonly smallValue = 1e-12;
+    /**
+     * @returns the distance from `point` to this shape. If `point` is within this shape,
+     * this returns the distance from `point` to the edge of this shape.
+     *
+     * @see {@link signedDistance}
+     */
+    distance(point: Point2): number;
+    /**
+     * Computes the [signed distance function](https://en.wikipedia.org/wiki/Signed_distance_function)
+     * for this shape.
+     */
+    abstract signedDistance(point: Point2): number;
+    /**
+     * @returns points at which this shape intersects the given `lineSegment`.
+     *
+     * If this is a closed shape, returns points where the given `lineSegment` intersects
+     * the **boundary** of this.
+     */
+    abstract intersectsLineSegment(lineSegment: LineSegment2): Point2[];
+    /**
+     * Returns `true` if and only if the given `point` is contained within this shape.
+     *
+     * `epsilon` is a small number used to counteract floating point error. Thus, if
+     * `point` is within `epsilon` of the inside of this shape, `containsPoint` may also
+     * return `true`.
+     *
+     * The default implementation relies on `signedDistance`.
+     * Subclasses may override this method to provide a more efficient implementation.
+     */
+    containsPoint(point: Point2, epsilon?: number): boolean;
+    /**
+     * Returns a bounding box that precisely fits the content of this shape.
+     */
+    abstract getTightBoundingBox(): Rect2;
+    /**
+     * Returns a bounding box that **loosely** fits the content of this shape.
+     *
+     * The result of this call can be larger than the result of {@link getTightBoundingBox},
+     * **but should not be smaller**. Thus, a call to `getLooseBoundingBox` can be significantly
+     * faster than a call to {@link getTightBoundingBox} for some shapes.
+     */
+    getLooseBoundingBox(): Rect2;
+}
+export default Abstract2DShape;

package/dist/cjs/math/shapes/Abstract2DShape.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Abstract2DShape = /** @class */ (function () {
+    function Abstract2DShape() {
+    }
+    /**
+     * @returns the distance from `point` to this shape. If `point` is within this shape,
+     * this returns the distance from `point` to the edge of this shape.
+     *
+     * @see {@link signedDistance}
+     */
+    Abstract2DShape.prototype.distance = function (point) {
+        return Math.abs(this.signedDistance(point));
+    };
+    /**
+     * Returns `true` if and only if the given `point` is contained within this shape.
+     *
+     * `epsilon` is a small number used to counteract floating point error. Thus, if
+     * `point` is within `epsilon` of the inside of this shape, `containsPoint` may also
+     * return `true`.
+     *
+     * The default implementation relies on `signedDistance`.
+     * Subclasses may override this method to provide a more efficient implementation.
+     */
+    Abstract2DShape.prototype.containsPoint = function (point, epsilon) {
+        if (epsilon === void 0) { epsilon = Abstract2DShape.smallValue; }
+        return this.signedDistance(point) < epsilon;
+    };
+    /**
+     * Returns a bounding box that **loosely** fits the content of this shape.
+     *
+     * The result of this call can be larger than the result of {@link getTightBoundingBox},
+     * **but should not be smaller**. Thus, a call to `getLooseBoundingBox` can be significantly
+     * faster than a call to {@link getTightBoundingBox} for some shapes.
+     */
+    Abstract2DShape.prototype.getLooseBoundingBox = function () {
+        return this.getTightBoundingBox();
+    };
+    Abstract2DShape.smallValue = 1e-12;
+    return Abstract2DShape;
+}());
+exports.default = Abstract2DShape;

package/dist/cjs/math/shapes/BezierJSWrapper.d.ts

@@ -0,0 +1,36 @@
+import { Bezier } from 'bezier-js';
+import { Point2, Vec2 } from '../Vec2';
+import Abstract2DShape from './Abstract2DShape';
+import LineSegment2 from './LineSegment2';
+import Rect2 from './Rect2';
+/**
+ * A lazy-initializing wrapper around Bezier-js.
+ *
+ * Subclasses may override `at`, `derivativeAt`, and `normal` with functions
+ * that do not initialize a `bezier-js` `Bezier`.
+ *
+ * Do not use this class directly. It may be removed/replaced in a future release.
+ * @internal
+ */
+declare abstract class BezierJSWrapper extends Abstract2DShape {
+    #private;
+    /** Returns the start, control points, and end point of this Bézier. */
+    abstract getPoints(): Point2[];
+    protected getBezier(): Bezier;
+    signedDistance(point: Point2): number;
+    /**
+     * @returns the (more) exact distance from `point` to this.
+     *
+     * @see {@link approximateDistance}
+     */
+    distance(point: Point2): number;
+    /**
+     * @returns the curve evaluated at `t`.
+     */
+    at(t: number): Point2;
+    derivativeAt(t: number): Point2;
+    normal(t: number): Vec2;
+    getTightBoundingBox(): Rect2;
+    intersectsLineSegment(line: LineSegment2): Point2[];
+}
+export default BezierJSWrapper;

package/dist/cjs/math/shapes/BezierJSWrapper.js

@@ -0,0 +1,109 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _BezierJSWrapper_bezierJs;
+Object.defineProperty(exports, "__esModule", { value: true });
+var bezier_js_1 = require("bezier-js");
+var Vec2_1 = require("../Vec2");
+var Abstract2DShape_1 = require("./Abstract2DShape");
+var Rect2_1 = require("./Rect2");
+/**
+ * A lazy-initializing wrapper around Bezier-js.
+ *
+ * Subclasses may override `at`, `derivativeAt`, and `normal` with functions
+ * that do not initialize a `bezier-js` `Bezier`.
+ *
+ * Do not use this class directly. It may be removed/replaced in a future release.
+ * @internal
+ */
+var BezierJSWrapper = /** @class */ (function (_super) {
+    __extends(BezierJSWrapper, _super);
+    function BezierJSWrapper() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _BezierJSWrapper_bezierJs.set(_this, null);
+        return _this;
+    }
+    BezierJSWrapper.prototype.getBezier = function () {
+        if (!__classPrivateFieldGet(this, _BezierJSWrapper_bezierJs, "f")) {
+            __classPrivateFieldSet(this, _BezierJSWrapper_bezierJs, new bezier_js_1.Bezier(this.getPoints().map(function (p) { return p.xy; })), "f");
+        }
+        return __classPrivateFieldGet(this, _BezierJSWrapper_bezierJs, "f");
+    };
+    BezierJSWrapper.prototype.signedDistance = function (point) {
+        // .d: Distance
+        return this.getBezier().project(point.xy).d;
+    };
+    /**
+     * @returns the (more) exact distance from `point` to this.
+     *
+     * @see {@link approximateDistance}
+     */
+    BezierJSWrapper.prototype.distance = function (point) {
+        // A Bézier curve has no interior, thus, signed distance is the same as distance.
+        return this.signedDistance(point);
+    };
+    /**
+     * @returns the curve evaluated at `t`.
+     */
+    BezierJSWrapper.prototype.at = function (t) {
+        return Vec2_1.Vec2.ofXY(this.getBezier().get(t));
+    };
+    BezierJSWrapper.prototype.derivativeAt = function (t) {
+        return Vec2_1.Vec2.ofXY(this.getBezier().derivative(t));
+    };
+    BezierJSWrapper.prototype.normal = function (t) {
+        return Vec2_1.Vec2.ofXY(this.getBezier().normal(t));
+    };
+    BezierJSWrapper.prototype.getTightBoundingBox = function () {
+        var bbox = this.getBezier().bbox();
+        var width = bbox.x.max - bbox.x.min;
+        var height = bbox.y.max - bbox.y.min;
+        return new Rect2_1.default(bbox.x.min, bbox.y.min, width, height);
+    };
+    BezierJSWrapper.prototype.intersectsLineSegment = function (line) {
+        var bezier = this.getBezier();
+        var intersectionPoints = bezier.intersects(line).map(function (t) {
+            // We're using the .intersects(line) function, which is documented
+            // to always return numbers. However, to satisfy the type checker (and
+            // possibly improperly-defined types),
+            if (typeof t === 'string') {
+                t = parseFloat(t);
+            }
+            var point = Vec2_1.Vec2.ofXY(bezier.get(t));
+            // Ensure that the intersection is on the line segment
+            if (point.minus(line.p1).magnitude() > line.length
+                || point.minus(line.p2).magnitude() > line.length) {
+                return null;
+            }
+            return point;
+        }).filter(function (entry) { return entry !== null; });
+        return intersectionPoints;
+    };
+    return BezierJSWrapper;
+}(Abstract2DShape_1.default));
+_BezierJSWrapper_bezierJs = new WeakMap();
+exports.default = BezierJSWrapper;

package/dist/cjs/math/shapes/CubicBezier.d.ts

@@ -0,0 +1,17 @@
+import { Point2 } from '../Vec2';
+import BezierJSWrapper from './BezierJSWrapper';
+import Rect2 from './Rect2';
+/**
+ * A wrapper around [`bezier-js`](https://github.com/Pomax/bezierjs)'s cubic Bezier.
+ */
+declare class CubicBezier extends BezierJSWrapper {
+    readonly p0: Point2;
+    readonly p1: Point2;
+    readonly p2: Point2;
+    readonly p3: Point2;
+    constructor(p0: Point2, p1: Point2, p2: Point2, p3: Point2);
+    getPoints(): import("../Vec3").default[];
+    /** Returns an overestimate of this shape's bounding box. */
+    getLooseBoundingBox(): Rect2;
+}
+export default CubicBezier;

package/dist/cjs/math/shapes/CubicBezier.js

@@ -0,0 +1,50 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var BezierJSWrapper_1 = require("./BezierJSWrapper");
+var Rect2_1 = require("./Rect2");
+/**
+ * A wrapper around [`bezier-js`](https://github.com/Pomax/bezierjs)'s cubic Bezier.
+ */
+var CubicBezier = /** @class */ (function (_super) {
+    __extends(CubicBezier, _super);
+    function CubicBezier(
+    // Start point
+    p0, 
+    // Control point 1
+    p1, 
+    // Control point 2
+    p2, 
+    // End point
+    p3) {
+        var _this = _super.call(this) || this;
+        _this.p0 = p0;
+        _this.p1 = p1;
+        _this.p2 = p2;
+        _this.p3 = p3;
+        return _this;
+    }
+    CubicBezier.prototype.getPoints = function () {
+        return [this.p0, this.p1, this.p2, this.p3];
+    };
+    /** Returns an overestimate of this shape's bounding box. */
+    CubicBezier.prototype.getLooseBoundingBox = function () {
+        return Rect2_1.default.bboxOf([this.p0, this.p1, this.p2, this.p3]);
+    };
+    return CubicBezier;
+}(BezierJSWrapper_1.default));
+exports.default = CubicBezier;

package/dist/cjs/math/shapes/LineSegment2.d.ts

@@ -0,0 +1,70 @@
+import Mat33 from '../Mat33';
+import Rect2 from './Rect2';
+import { Vec2, Point2 } from '../Vec2';
+import Abstract2DShape from './Abstract2DShape';
+interface IntersectionResult {
+    point: Point2;
+    t: number;
+}
+/** Represents a line segment. A `LineSegment2` is immutable. */
+export default class LineSegment2 extends Abstract2DShape {
+    private readonly point1;
+    private readonly point2;
+    /**
+     * The **unit** direction vector of this line segment, from
+     * `point1` to `point2`.
+     *
+     * In other words, `direction` is `point2.minus(point1).normalized()`
+     * (perhaps except when `point1` is equal to `point2`).
+     */
+    readonly direction: Vec2;
+    /** The distance between `point1` and `point2`. */
+    readonly length: number;
+    /** The bounding box of this line segment. */
+    readonly bbox: any;
+    /** Creates a new `LineSegment2` from its endpoints. */
+    constructor(point1: Point2, point2: Point2);
+    /** Alias for `point1`. */
+    get p1(): Point2;
+    /** Alias for `point2`. */
+    get p2(): Point2;
+    /**
+     * Gets a point a distance `t` along this line.
+     *
+     * @deprecated
+     */
+    get(t: number): Point2;
+    /**
+     * Returns a point a fraction, `t`, along this line segment.
+     * Thus, `segment.at(0)` returns `segment.p1` and `segment.at(1)` returns
+     * `segment.p2`.
+     *
+     * `t` should be in `[0, 1]`.
+     */
+    at(t: number): Point2;
+    intersection(other: LineSegment2): IntersectionResult | null;
+    intersects(other: LineSegment2): boolean;
+    /**
+     * Returns the points at which this line segment intersects the
+     * given line segment.
+     *
+     * Note that {@link intersects} returns *whether* this line segment intersects another
+     * line segment. This method, by contrast, returns **the point** at which the intersection
+     * occurs, if such a point exists.
+     */
+    intersectsLineSegment(lineSegment: LineSegment2): import("../Vec3").default[];
+    closestPointTo(target: Point2): import("../Vec3").default;
+    /**
+     * Returns the distance from this line segment to `target`.
+     *
+     * Because a line segment has no interior, this signed distance is equivalent to
+     * the full distance between `target` and this line segment.
+     */
+    signedDistance(target: Point2): number;
+    /** Returns a copy of this line segment transformed by the given `affineTransfm`. */
+    transformedBy(affineTransfm: Mat33): LineSegment2;
+    /** @inheritdoc */
+    getTightBoundingBox(): Rect2;
+    toString(): string;
+}
+export {};