js-draw 0.18.1 → 0.18.2

package/dist/cjs/src/math/LineSegment2.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Rect2_1 = __importDefault(require("./Rect2"));
+const Vec2_1 = require("./Vec2");
+class LineSegment2 {
+    constructor(point1, point2) {
+        this.point1 = point1;
+        this.point2 = point2;
+        this.bbox = Rect2_1.default.bboxOf([point1, point2]);
+        this.direction = point2.minus(point1);
+        this.length = this.direction.magnitude();
+        // Normalize
+        if (this.length > 0) {
+            this.direction = this.direction.times(1 / this.length);
+        }
+    }
+    // Accessors to make LineSegment2 compatible with bezier-js's
+    // interface
+    get p1() {
+        return this.point1;
+    }
+    get p2() {
+        return this.point2;
+    }
+    get(t) {
+        return this.point1.plus(this.direction.times(t));
+    }
+    intersection(other) {
+        // We want x₁(t) = x₂(t) and y₁(t) = y₂(t)
+        // Observe that
+        // x = this.point1.x + this.direction.x · t₁
+        //   = other.point1.x + other.direction.x · t₂
+        // Thus,
+        //  t₁ = (x - this.point1.x) / this.direction.x
+        //     = (y - this.point1.y) / this.direction.y
+        // and
+        //  t₂ = (x - other.point1.x) / other.direction.x
+        // (and similarly for y)
+        //
+        // Letting o₁ₓ = this.point1.x, o₂ₓ = other.point1.x,
+        //         d₁ᵧ = this.direction.y, ...
+        //
+        // We can substitute these into the equations for y:
+        // y = o₁ᵧ + d₁ᵧ · (x - o₁ₓ) / d₁ₓ
+        //   = o₂ᵧ + d₂ᵧ · (x - o₂ₓ) / d₂ₓ
+        // ⇒ o₁ᵧ - o₂ᵧ = d₂ᵧ · (x - o₂ₓ) / d₂ₓ - d₁ᵧ · (x - o₁ₓ) / d₁ₓ
+        //            = (d₂ᵧ/d₂ₓ)(x) - (d₂ᵧ/d₂ₓ)(o₂ₓ) - (d₁ᵧ/d₁ₓ)(x) + (d₁ᵧ/d₁ₓ)(o₁ₓ)
+        //            = (x)(d₂ᵧ/d₂ₓ - d₁ᵧ/d₁ₓ) - (d₂ᵧ/d₂ₓ)(o₂ₓ) + (d₁ᵧ/d₁ₓ)(o₁ₓ)
+        // ⇒ (x)(d₂ᵧ/d₂ₓ - d₁ᵧ/d₁ₓ) = o₁ᵧ - o₂ᵧ + (d₂ᵧ/d₂ₓ)(o₂ₓ) - (d₁ᵧ/d₁ₓ)(o₁ₓ)
+        // ⇒ x = (o₁ᵧ - o₂ᵧ + (d₂ᵧ/d₂ₓ)(o₂ₓ) - (d₁ᵧ/d₁ₓ)(o₁ₓ))/(d₂ᵧ/d₂ₓ - d₁ᵧ/d₁ₓ)
+        //     = (d₁ₓd₂ₓ)(o₁ᵧ - o₂ᵧ + (d₂ᵧ/d₂ₓ)(o₂ₓ) - (d₁ᵧ/d₁ₓ)(o₁ₓ))/(d₂ᵧd₁ₓ - d₁ᵧd₂ₓ)
+        //     = ((o₁ᵧ - o₂ᵧ)((d₁ₓd₂ₓ)) + (d₂ᵧd₁ₓ)(o₂ₓ) - (d₁ᵧd₂ₓ)(o₁ₓ))/(d₂ᵧd₁ₓ - d₁ᵧd₂ₓ)
+        // ⇒ y = o₁ᵧ + d₁ᵧ · (x - o₁ₓ) / d₁ₓ = ...
+        let resultPoint, resultT;
+        if (this.direction.x === 0) {
+            // Vertical line: Where does the other have x = this.point1.x?
+            // x = o₁ₓ = o₂ₓ + d₂ₓ · (y - o₂ᵧ) / d₂ᵧ
+            // ⇒ (o₁ₓ - o₂ₓ)(d₂ᵧ/d₂ₓ) + o₂ᵧ = y
+            // Avoid division by zero
+            if (other.direction.x === 0 || this.direction.y === 0) {
+                return null;
+            }
+            const xIntersect = this.point1.x;
+            const yIntersect = (this.point1.x - other.point1.x) * other.direction.y / other.direction.x + other.point1.y;
+            resultPoint = Vec2_1.Vec2.of(xIntersect, yIntersect);
+            resultT = (yIntersect - this.point1.y) / this.direction.y;
+        }
+        else {
+            // From above,
+            // x = ((o₁ᵧ - o₂ᵧ)(d₁ₓd₂ₓ) + (d₂ᵧd₁ₓ)(o₂ₓ) - (d₁ᵧd₂ₓ)(o₁ₓ))/(d₂ᵧd₁ₓ - d₁ᵧd₂ₓ)
+            const numerator = ((this.point1.y - other.point1.y) * this.direction.x * other.direction.x
+                + this.direction.x * other.direction.y * other.point1.x
+                - this.direction.y * other.direction.x * this.point1.x);
+            const denominator = (other.direction.y * this.direction.x
+                - this.direction.y * other.direction.x);
+            // Avoid dividing by zero. It means there is no intersection
+            if (denominator === 0) {
+                return null;
+            }
+            const xIntersect = numerator / denominator;
+            const t1 = (xIntersect - this.point1.x) / this.direction.x;
+            const yIntersect = this.point1.y + this.direction.y * t1;
+            resultPoint = Vec2_1.Vec2.of(xIntersect, yIntersect);
+            resultT = (xIntersect - this.point1.x) / this.direction.x;
+        }
+        // Ensure the result is in this/the other segment.
+        const resultToP1 = resultPoint.minus(this.point1).magnitude();
+        const resultToP2 = resultPoint.minus(this.point2).magnitude();
+        const resultToP3 = resultPoint.minus(other.point1).magnitude();
+        const resultToP4 = resultPoint.minus(other.point2).magnitude();
+        if (resultToP1 > this.length
+            || resultToP2 > this.length
+            || resultToP3 > other.length
+            || resultToP4 > other.length) {
+            return null;
+        }
+        return {
+            point: resultPoint,
+            t: resultT,
+        };
+    }
+    intersects(other) {
+        return this.intersection(other) !== null;
+    }
+    // Returns the closest point on this to [target]
+    closestPointTo(target) {
+        // Distance from P1 along this' direction.
+        const projectedDistFromP1 = target.minus(this.p1).dot(this.direction);
+        const projectedDistFromP2 = this.length - projectedDistFromP1;
+        const projection = this.p1.plus(this.direction.times(projectedDistFromP1));
+        if (projectedDistFromP1 > 0 && projectedDistFromP1 < this.length) {
+            return projection;
+        }
+        if (Math.abs(projectedDistFromP2) < Math.abs(projectedDistFromP1)) {
+            return this.p2;
+        }
+        else {
+            return this.p1;
+        }
+    }
+    transformedBy(affineTransfm) {
+        return new LineSegment2(affineTransfm.transformVec2(this.p1), affineTransfm.transformVec2(this.p2));
+    }
+    toString() {
+        return `LineSegment(${this.p1.toString()}, ${this.p2.toString()})`;
+    }
+}
+exports.default = LineSegment2;

package/dist/cjs/src/math/Mat33.d.ts

@@ -0,0 +1,118 @@
+import { Point2, Vec2 } from './Vec2';
+import Vec3 from './Vec3';
+export type Mat33Array = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+/**
+ * Represents a three dimensional linear transformation or
+ * a two-dimensional affine transformation. (An affine transformation scales/rotates/shears
+ * **and** translates while a linear transformation just scales/rotates/shears).
+ */
+export default class Mat33 {
+    readonly a1: number;
+    readonly a2: number;
+    readonly a3: number;
+    readonly b1: number;
+    readonly b2: number;
+    readonly b3: number;
+    readonly c1: number;
+    readonly c2: number;
+    readonly c3: number;
+    private readonly rows;
+    /**
+     * Creates a matrix from inputs in the form,
+     * ```
+     * ⎡ a1 a2 a3 ⎤
+     * ⎢ b1 b2 b3 ⎥
+     * ⎣ c1 c2 c3 ⎦
+     * ```
+     */
+    constructor(a1: number, a2: number, a3: number, b1: number, b2: number, b3: number, c1: number, c2: number, c3: number);
+    /**
+     * Creates a matrix from the given rows:
+     * ```
+     *  ⎡ r1.x r1.y r1.z ⎤
+     *  ⎢ r2.x r2.y r2.z ⎥
+     *  ⎣ r3.x r3.y r3.z ⎦
+     * ```
+     */
+    static ofRows(r1: Vec3, r2: Vec3, r3: Vec3): Mat33;
+    static identity: Mat33;
+    /**
+     * Either returns the inverse of this, or, if this matrix is singular/uninvertable,
+     * returns Mat33.identity.
+     *
+     * This may cache the computed inverse and return the cached version instead of recomputing
+     * it.
+     */
+    inverse(): Mat33;
+    invertable(): boolean;
+    private cachedInverse;
+    private computeInverse;
+    transposed(): Mat33;
+    rightMul(other: Mat33): Mat33;
+    /**
+     * Applies this as an affine transformation to the given vector.
+     * Returns a transformed version of `other`.
+     */
+    transformVec2(other: Vec2): Vec2;
+    /**
+     * Applies this as a linear transformation to the given vector (doesn't translate).
+     * This is the standard way of transforming vectors in ℝ³.
+     */
+    transformVec3(other: Vec3): Vec3;
+    /** @returns true iff this is the identity matrix. */
+    isIdentity(): boolean;
+    /** Returns true iff this = other ± fuzz */
+    eq(other: Mat33, fuzz?: number): boolean;
+    toString(): string;
+    /**
+     * ```
+     * result[0] = top left element
+     * result[1] = element at row zero, column 1
+     * ...
+     * ```
+     */
+    toArray(): Mat33Array;
+    /**
+     * @example
+     * ```
+     * new Mat33(
+     *  1, 2, 3,
+     *  4, 5, 6,
+     *  7, 8, 9,
+     * ).mapEntries(component => component - 1);
+     * // → ⎡ 0, 1, 2 ⎤
+     * //   ⎢ 3, 4, 5 ⎥
+     * //   ⎣ 6, 7, 8 ⎦
+     * ```
+     */
+    mapEntries(mapping: (component: number) => number): Mat33;
+    /** Estimate the scale factor of this matrix (based on the first row). */
+    getScaleFactor(): number;
+    /** Constructs a 3x3 translation matrix (for translating `Vec2`s) */
+    static translation(amount: Vec2): Mat33;
+    static zRotation(radians: number, center?: Point2): Mat33;
+    static scaling2D(amount: number | Vec2, center?: Point2): Mat33;
+    /** @see {@link fromCSSMatrix} */
+    toCSSMatrix(): string;
+    /**
+     * Converts a CSS-form `matrix(a, b, c, d, e, f)` to a Mat33.
+     *
+     * Note that such a matrix has the form,
+     * ```
+     * ⎡ a c e ⎤
+     * ⎢ b d f ⎥
+     * ⎣ 0 0 1 ⎦
+     * ```
+     */
+    static fromCSSMatrix(cssString: string): Mat33;
+}

package/dist/cjs/src/math/Mat33.js

@@ -0,0 +1,332 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Vec2_1 = require("./Vec2");
+const Vec3_1 = __importDefault(require("./Vec3"));
+/**
+ * Represents a three dimensional linear transformation or
+ * a two-dimensional affine transformation. (An affine transformation scales/rotates/shears
+ * **and** translates while a linear transformation just scales/rotates/shears).
+ */
+class Mat33 {
+    /**
+     * Creates a matrix from inputs in the form,
+     * ```
+     * ⎡ a1 a2 a3 ⎤
+     * ⎢ b1 b2 b3 ⎥
+     * ⎣ c1 c2 c3 ⎦
+     * ```
+     */
+    constructor(a1, a2, a3, b1, b2, b3, c1, c2, c3) {
+        this.a1 = a1;
+        this.a2 = a2;
+        this.a3 = a3;
+        this.b1 = b1;
+        this.b2 = b2;
+        this.b3 = b3;
+        this.c1 = c1;
+        this.c2 = c2;
+        this.c3 = c3;
+        this.cachedInverse = undefined;
+        this.rows = [
+            Vec3_1.default.of(a1, a2, a3),
+            Vec3_1.default.of(b1, b2, b3),
+            Vec3_1.default.of(c1, c2, c3),
+        ];
+    }
+    /**
+     * Creates a matrix from the given rows:
+     * ```
+     *  ⎡ r1.x r1.y r1.z ⎤
+     *  ⎢ r2.x r2.y r2.z ⎥
+     *  ⎣ r3.x r3.y r3.z ⎦
+     * ```
+     */
+    static ofRows(r1, r2, r3) {
+        return new Mat33(r1.x, r1.y, r1.z, r2.x, r2.y, r2.z, r3.x, r3.y, r3.z);
+    }
+    /**
+     * Either returns the inverse of this, or, if this matrix is singular/uninvertable,
+     * returns Mat33.identity.
+     *
+     * This may cache the computed inverse and return the cached version instead of recomputing
+     * it.
+     */
+    inverse() {
+        var _a;
+        return (_a = this.computeInverse()) !== null && _a !== void 0 ? _a : Mat33.identity;
+    }
+    invertable() {
+        return this.computeInverse() !== null;
+    }
+    computeInverse() {
+        if (this.cachedInverse !== undefined) {
+            return this.cachedInverse;
+        }
+        const toIdentity = [
+            this.rows[0],
+            this.rows[1],
+            this.rows[2],
+        ];
+        const toResult = [
+            Vec3_1.default.unitX,
+            Vec3_1.default.unitY,
+            Vec3_1.default.unitZ,
+        ];
+        // Convert toIdentity to the identity matrix and
+        // toResult to the inverse through elementary row operations
+        for (let cursor = 0; cursor < 3; cursor++) {
+            // Select the [cursor]th diagonal entry
+            let pivot = toIdentity[cursor].at(cursor);
+            // Don't divide by zero (treat very small numbers as zero).
+            const minDivideBy = 1e-10;
+            if (Math.abs(pivot) < minDivideBy) {
+                let swapIndex = -1;
+                // For all other rows,
+                for (let i = 1; i <= 2; i++) {
+                    const otherRowIdx = (cursor + i) % 3;
+                    if (Math.abs(toIdentity[otherRowIdx].at(cursor)) >= minDivideBy) {
+                        swapIndex = otherRowIdx;
+                        break;
+                    }
+                }
+                // Can't swap with another row?
+                if (swapIndex === -1) {
+                    this.cachedInverse = null;
+                    return null;
+                }
+                const tmpIdentityRow = toIdentity[cursor];
+                const tmpResultRow = toResult[cursor];
+                // Swap!
+                toIdentity[cursor] = toIdentity[swapIndex];
+                toResult[cursor] = toResult[swapIndex];
+                toIdentity[swapIndex] = tmpIdentityRow;
+                toResult[swapIndex] = tmpResultRow;
+                pivot = toIdentity[cursor].at(cursor);
+            }
+            // Make toIdentity[k = cursor] = 1
+            let scale = 1.0 / pivot;
+            toIdentity[cursor] = toIdentity[cursor].times(scale);
+            toResult[cursor] = toResult[cursor].times(scale);
+            const cursorToIdentityRow = toIdentity[cursor];
+            const cursorToResultRow = toResult[cursor];
+            // Make toIdentity[k ≠ cursor] = 0
+            for (let i = 1; i <= 2; i++) {
+                const otherRowIdx = (cursor + i) % 3;
+                scale = -toIdentity[otherRowIdx].at(cursor);
+                toIdentity[otherRowIdx] = toIdentity[otherRowIdx].plus(cursorToIdentityRow.times(scale));
+                toResult[otherRowIdx] = toResult[otherRowIdx].plus(cursorToResultRow.times(scale));
+            }
+        }
+        const inverse = Mat33.ofRows(toResult[0], toResult[1], toResult[2]);
+        this.cachedInverse = inverse;
+        return inverse;
+    }
+    transposed() {
+        return new Mat33(this.a1, this.b1, this.c1, this.a2, this.b2, this.c2, this.a3, this.b3, this.c3);
+    }
+    rightMul(other) {
+        other = other.transposed();
+        const at = (row, col) => {
+            return this.rows[row].dot(other.rows[col]);
+        };
+        return new Mat33(at(0, 0), at(0, 1), at(0, 2), at(1, 0), at(1, 1), at(1, 2), at(2, 0), at(2, 1), at(2, 2));
+    }
+    /**
+     * Applies this as an affine transformation to the given vector.
+     * Returns a transformed version of `other`.
+     */
+    transformVec2(other) {
+        // When transforming a Vec2, we want to use the z transformation
+        // components of this for translation:
+        //  ⎡ . . tX ⎤
+        //  ⎢ . . tY ⎥
+        //  ⎣ 0 0 1  ⎦
+        // For this, we need other's z component to be 1 (so that tX and tY
+        // are scaled by 1):
+        let intermediate = Vec3_1.default.of(other.x, other.y, 1);
+        intermediate = this.transformVec3(intermediate);
+        // Drop the z=1 to allow magnitude to work as expected
+        return Vec2_1.Vec2.of(intermediate.x, intermediate.y);
+    }
+    /**
+     * Applies this as a linear transformation to the given vector (doesn't translate).
+     * This is the standard way of transforming vectors in ℝ³.
+     */
+    transformVec3(other) {
+        return Vec3_1.default.of(this.rows[0].dot(other), this.rows[1].dot(other), this.rows[2].dot(other));
+    }
+    /** @returns true iff this is the identity matrix. */
+    isIdentity() {
+        if (this === Mat33.identity) {
+            return true;
+        }
+        return this.eq(Mat33.identity);
+    }
+    /** Returns true iff this = other ± fuzz */
+    eq(other, fuzz = 0) {
+        for (let i = 0; i < 3; i++) {
+            if (!this.rows[i].eq(other.rows[i], fuzz)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    toString() {
+        let result = '';
+        const maxColumnLens = [0, 0, 0];
+        // Determine the longest item in each column so we can pad the others to that
+        // length.
+        for (const row of this.rows) {
+            for (let i = 0; i < 3; i++) {
+                maxColumnLens[i] = Math.max(maxColumnLens[0], `${row.at(i)}`.length);
+            }
+        }
+        for (let i = 0; i < 3; i++) {
+            if (i === 0) {
+                result += '⎡ ';
+            }
+            else if (i === 1) {
+                result += '⎢ ';
+            }
+            else {
+                result += '⎣ ';
+            }
+            // Add each component of the ith row (after padding it)
+            for (let j = 0; j < 3; j++) {
+                const val = this.rows[i].at(j).toString();
+                let padding = '';
+                for (let i = val.length; i < maxColumnLens[j]; i++) {
+                    padding += ' ';
+                }
+                result += val + ', ' + padding;
+            }
+            if (i === 0) {
+                result += ' ⎤';
+            }
+            else if (i === 1) {
+                result += ' ⎥';
+            }
+            else {
+                result += ' ⎦';
+            }
+            result += '\n';
+        }
+        return result.trimEnd();
+    }
+    /**
+     * ```
+     * result[0] = top left element
+     * result[1] = element at row zero, column 1
+     * ...
+     * ```
+     */
+    toArray() {
+        return [
+            this.a1, this.a2, this.a3,
+            this.b1, this.b2, this.b3,
+            this.c1, this.c2, this.c3,
+        ];
+    }
+    /**
+     * @example
+     * ```
+     * new Mat33(
+     *  1, 2, 3,
+     *  4, 5, 6,
+     *  7, 8, 9,
+     * ).mapEntries(component => component - 1);
+     * // → ⎡ 0, 1, 2 ⎤
+     * //   ⎢ 3, 4, 5 ⎥
+     * //   ⎣ 6, 7, 8 ⎦
+     * ```
+     */
+    mapEntries(mapping) {
+        return new Mat33(mapping(this.a1), mapping(this.a2), mapping(this.a3), mapping(this.b1), mapping(this.b2), mapping(this.b3), mapping(this.c1), mapping(this.c2), mapping(this.c3));
+    }
+    /** Estimate the scale factor of this matrix (based on the first row). */
+    getScaleFactor() {
+        return Math.hypot(this.a1, this.a2);
+    }
+    /** Constructs a 3x3 translation matrix (for translating `Vec2`s) */
+    static translation(amount) {
+        // When transforming Vec2s by a 3x3 matrix, we give the input
+        // Vec2s z = 1. As such,
+        //   outVec2.x = inVec2.x * 1 + inVec2.y * 0 + 1 * amount.x
+        //   ...
+        return new Mat33(1, 0, amount.x, 0, 1, amount.y, 0, 0, 1);
+    }
+    static zRotation(radians, center = Vec2_1.Vec2.zero) {
+        if (radians === 0) {
+            return Mat33.identity;
+        }
+        const cos = Math.cos(radians);
+        const sin = Math.sin(radians);
+        // Translate everything so that rotation is about the origin
+        let result = Mat33.translation(center);
+        result = result.rightMul(new Mat33(cos, -sin, 0, sin, cos, 0, 0, 0, 1));
+        return result.rightMul(Mat33.translation(center.times(-1)));
+    }
+    static scaling2D(amount, center = Vec2_1.Vec2.zero) {
+        let result = Mat33.translation(center);
+        let xAmount, yAmount;
+        if (typeof amount === 'number') {
+            xAmount = amount;
+            yAmount = amount;
+        }
+        else {
+            xAmount = amount.x;
+            yAmount = amount.y;
+        }
+        result = result.rightMul(new Mat33(xAmount, 0, 0, 0, yAmount, 0, 0, 0, 1));
+        // Translate such that [center] goes to (0, 0)
+        return result.rightMul(Mat33.translation(center.times(-1)));
+    }
+    /** @see {@link fromCSSMatrix} */
+    toCSSMatrix() {
+        return `matrix(${this.a1},${this.b1},${this.a2},${this.b2},${this.a3},${this.b3})`;
+    }
+    /**
+     * Converts a CSS-form `matrix(a, b, c, d, e, f)` to a Mat33.
+     *
+     * Note that such a matrix has the form,
+     * ```
+     * ⎡ a c e ⎤
+     * ⎢ b d f ⎥
+     * ⎣ 0 0 1 ⎦
+     * ```
+     */
+    static fromCSSMatrix(cssString) {
+        if (cssString === '' || cssString === 'none') {
+            return Mat33.identity;
+        }
+        const numberExp = '([-]?\\d*(?:\\.\\d*)?(?:[eE][-]?\\d+)?)';
+        const numberSepExp = '[, \\t\\n]';
+        const regExpSource = `^\\s*matrix\\s*\\(${[
+            // According to MDN, matrix(a,b,c,d,e,f) has form:
+            // 		⎡ a c e ⎤
+            // 		⎢ b d f ⎥
+            // 		⎣ 0 0 1 ⎦
+            numberExp, numberExp, numberExp,
+            numberExp, numberExp, numberExp, // b, d, f
+        ].join(`${numberSepExp}+`)}${numberSepExp}*\\)\\s*$`;
+        const matrixExp = new RegExp(regExpSource, 'i');
+        const match = matrixExp.exec(cssString);
+        if (!match) {
+            throw new Error(`Unsupported transformation: ${cssString}`);
+        }
+        const matrixData = match.slice(1).map(entry => parseFloat(entry));
+        const a = matrixData[0];
+        const b = matrixData[1];
+        const c = matrixData[2];
+        const d = matrixData[3];
+        const e = matrixData[4];
+        const f = matrixData[5];
+        const transform = new Mat33(a, c, e, b, d, f, 0, 0, 1);
+        return transform;
+    }
+}
+exports.default = Mat33;
+Mat33.identity = new Mat33(1, 0, 0, 0, 1, 0, 0, 0, 1);

package/dist/cjs/src/math/Path.d.ts

@@ -0,0 +1,71 @@
+import { Bezier } from 'bezier-js';
+import { RenderablePathSpec } from '../rendering/renderers/AbstractRenderer';
+import RenderingStyle from '../rendering/RenderingStyle';
+import LineSegment2 from './LineSegment2';
+import Mat33 from './Mat33';
+import Rect2 from './Rect2';
+import { Point2 } from './Vec2';
+export declare enum PathCommandType {
+    LineTo = 0,
+    MoveTo = 1,
+    CubicBezierTo = 2,
+    QuadraticBezierTo = 3
+}
+export interface CubicBezierPathCommand {
+    kind: PathCommandType.CubicBezierTo;
+    controlPoint1: Point2;
+    controlPoint2: Point2;
+    endPoint: Point2;
+}
+export interface QuadraticBezierPathCommand {
+    kind: PathCommandType.QuadraticBezierTo;
+    controlPoint: Point2;
+    endPoint: Point2;
+}
+export interface LinePathCommand {
+    kind: PathCommandType.LineTo;
+    point: Point2;
+}
+export interface MoveToPathCommand {
+    kind: PathCommandType.MoveTo;
+    point: Point2;
+}
+export type PathCommand = CubicBezierPathCommand | LinePathCommand | QuadraticBezierPathCommand | MoveToPathCommand;
+interface IntersectionResult {
+    curve: LineSegment2 | Bezier;
+    parameterValue: number;
+    point: Point2;
+}
+export default class Path {
+    readonly startPoint: Point2;
+    readonly parts: PathCommand[];
+    readonly bbox: Rect2;
+    constructor(startPoint: Point2, parts: PathCommand[]);
+    private cachedGeometry;
+    get geometry(): Array<LineSegment2 | Bezier>;
+    private cachedPolylineApproximation;
+    polylineApproximation(): LineSegment2[];
+    static computeBBoxForSegment(startPoint: Point2, part: PathCommand): Rect2;
+    intersection(line: LineSegment2): IntersectionResult[];
+    private static mapPathCommand;
+    mapPoints(mapping: (point: Point2) => Point2): Path;
+    transformedBy(affineTransfm: Mat33): Path;
+    union(other: Path | null): Path;
+    private getEndPoint;
+    roughlyIntersects(rect: Rect2, strokeWidth?: number): boolean;
+    closedRoughlyIntersects(rect: Rect2): boolean;
+    static fromRect(rect: Rect2, lineWidth?: number | null): Path;
+    static fromRenderable(renderable: RenderablePathSpec): Path;
+    toRenderable(fill: RenderingStyle): RenderablePathSpec;
+    /**
+     * @returns a Path that, when rendered, looks roughly equivalent to the given path.
+     */
+    static visualEquivalent(renderablePath: RenderablePathSpec, visibleRect: Rect2): RenderablePathSpec;
+    private cachedStringVersion;
+    toString(useNonAbsCommands?: boolean): string;
+    serialize(): string;
+    static toString(startPoint: Point2, parts: PathCommand[], onlyAbsCommands?: boolean): string;
+    static fromString(pathString: string): Path;
+    static empty: Path;
+}
+export {};