js-draw 0.0.1

package/dist/src/components/AbstractComponent.js

@@ -0,0 +1,46 @@
+import EditorImage from '../EditorImage';
+export default class AbstractComponent {
+    constructor() {
+        this.lastChangedTime = (new Date()).getTime();
+        this.zIndex = AbstractComponent.zIndexCounter++;
+    }
+    getBBox() {
+        return this.contentBBox;
+    }
+    // Returns a command that, when applied, transforms this by [affineTransfm] and
+    // updates the editor.
+    transformBy(affineTransfm) {
+        const updateTransform = (editor, newTransfm) => {
+            // Any parent should have only one direct child.
+            const parent = editor.image.findParent(this);
+            let hadParent = false;
+            if (parent) {
+                parent.remove();
+                hadParent = true;
+            }
+            this.applyTransformation(newTransfm);
+            // Add the element back to the document.
+            if (hadParent) {
+                new EditorImage.AddElementCommand(this).apply(editor);
+            }
+        };
+        const origZIndex = this.zIndex;
+        return {
+            apply: (editor) => {
+                this.zIndex = AbstractComponent.zIndexCounter++;
+                updateTransform(editor, affineTransfm);
+                editor.queueRerender();
+            },
+            unapply: (editor) => {
+                this.zIndex = origZIndex;
+                updateTransform(editor, affineTransfm.inverse());
+                editor.queueRerender();
+            },
+            description(localizationTable) {
+                return localizationTable.transformedElements(1);
+            },
+        };
+    }
+}
+// Topmost z-index
+AbstractComponent.zIndexCounter = 0;

package/dist/src/components/Stroke.d.ts

@@ -0,0 +1,16 @@
+import LineSegment2 from '../geometry/LineSegment2';
+import Mat33 from '../geometry/Mat33';
+import Rect2 from '../geometry/Rect2';
+import AbstractRenderer, { RenderablePathSpec } from '../rendering/AbstractRenderer';
+import AbstractComponent from './AbstractComponent';
+import { ImageComponentLocalization } from './localization';
+export default class Stroke extends AbstractComponent {
+    private parts;
+    protected contentBBox: Rect2;
+    constructor(parts: RenderablePathSpec[]);
+    intersects(line: LineSegment2): boolean;
+    render(canvas: AbstractRenderer, visibleRect: Rect2): void;
+    private bboxForPart;
+    protected applyTransformation(affineTransfm: Mat33): void;
+    description(localization: ImageComponentLocalization): string;
+}

package/dist/src/components/Stroke.js

@@ -0,0 +1,79 @@
+import Path from '../geometry/Path';
+import Rect2 from '../geometry/Rect2';
+import AbstractComponent from './AbstractComponent';
+export default class Stroke extends AbstractComponent {
+    constructor(parts) {
+        var _a;
+        super();
+        this.parts = parts.map(section => {
+            const path = Path.fromRenderable(section);
+            const pathBBox = this.bboxForPart(path.bbox, section.style);
+            if (!this.contentBBox) {
+                this.contentBBox = pathBBox;
+            }
+            else {
+                this.contentBBox = this.contentBBox.union(pathBBox);
+            }
+            return {
+                path,
+                bbox: pathBBox,
+                // To implement RenderablePathSpec
+                startPoint: path.startPoint,
+                style: section.style,
+                commands: path.parts,
+            };
+        });
+        (_a = this.contentBBox) !== null && _a !== void 0 ? _a : (this.contentBBox = Rect2.empty);
+    }
+    intersects(line) {
+        for (const part of this.parts) {
+            if (part.path.intersection(line).length > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    render(canvas, visibleRect) {
+        canvas.startObject(this.getBBox());
+        for (const part of this.parts) {
+            const bbox = part.bbox;
+            if (bbox.intersects(visibleRect)) {
+                canvas.drawPath(part);
+            }
+        }
+        canvas.endObject();
+    }
+    // Grows the bounding box for a given stroke part based on that part's style.
+    bboxForPart(origBBox, style) {
+        if (!style.stroke) {
+            return origBBox;
+        }
+        return origBBox.grownBy(style.stroke.width / 2);
+    }
+    applyTransformation(affineTransfm) {
+        this.contentBBox = Rect2.empty;
+        let isFirstPart = true;
+        // Update each part
+        this.parts = this.parts.map((part) => {
+            const newPath = part.path.transformedBy(affineTransfm);
+            const newBBox = this.bboxForPart(newPath.bbox, part.style);
+            if (isFirstPart) {
+                this.contentBBox = newBBox;
+                isFirstPart = false;
+            }
+            else {
+                this.contentBBox = this.contentBBox.union(newBBox);
+            }
+            return {
+                path: newPath,
+                bbox: newBBox,
+                startPoint: newPath.startPoint,
+                commands: newPath.parts,
+                style: part.style,
+            };
+        });
+    }
+    description(localization) {
+        return localization.stroke;
+    }
+}

package/dist/src/components/UnknownSVGObject.d.ts

@@ -0,0 +1,15 @@
+import LineSegment2 from '../geometry/LineSegment2';
+import Mat33 from '../geometry/Mat33';
+import Rect2 from '../geometry/Rect2';
+import AbstractRenderer from '../rendering/AbstractRenderer';
+import AbstractComponent from './AbstractComponent';
+import { ImageComponentLocalization } from './localization';
+export default class UnknownSVGObject extends AbstractComponent {
+    private svgObject;
+    protected contentBBox: Rect2;
+    constructor(svgObject: SVGElement);
+    render(canvas: AbstractRenderer, _visibleRect: Rect2): void;
+    intersects(lineSegment: LineSegment2): boolean;
+    protected applyTransformation(_affineTransfm: Mat33): void;
+    description(localization: ImageComponentLocalization): string;
+}

package/dist/src/components/UnknownSVGObject.js

@@ -0,0 +1,25 @@
+import Rect2 from '../geometry/Rect2';
+import SVGRenderer from '../rendering/SVGRenderer';
+import AbstractComponent from './AbstractComponent';
+export default class UnknownSVGObject extends AbstractComponent {
+    constructor(svgObject) {
+        super();
+        this.svgObject = svgObject;
+        this.contentBBox = Rect2.of(svgObject.getBoundingClientRect());
+    }
+    render(canvas, _visibleRect) {
+        if (!(canvas instanceof SVGRenderer)) {
+            // Don't draw unrenderable objects if we can't
+            return;
+        }
+        canvas.drawSVGElem(this.svgObject);
+    }
+    intersects(lineSegment) {
+        return this.contentBBox.getEdges().some(edge => edge.intersection(lineSegment) !== null);
+    }
+    applyTransformation(_affineTransfm) {
+    }
+    description(localization) {
+        return localization.svgObject;
+    }
+}

package/dist/src/components/localization.d.ts

@@ -0,0 +1,5 @@
+export interface ImageComponentLocalization {
+    stroke: string;
+    svgObject: string;
+}
+export declare const defaultComponentLocalization: ImageComponentLocalization;

package/dist/src/components/localization.js

@@ -0,0 +1,4 @@
+export const defaultComponentLocalization = {
+    stroke: 'Stroke',
+    svgObject: 'SVG Object',
+};

package/dist/src/geometry/LineSegment2.d.ts

@@ -0,0 +1,19 @@
+import Rect2 from './Rect2';
+import { Vec2, Point2 } from './Vec2';
+interface IntersectionResult {
+    point: Point2;
+    t: number;
+}
+export default class LineSegment2 {
+    private readonly point1;
+    private readonly point2;
+    readonly direction: Vec2;
+    readonly length: number;
+    readonly bbox: Rect2;
+    constructor(point1: Point2, point2: Point2);
+    get p1(): Point2;
+    get p2(): Point2;
+    get(t: number): Point2;
+    intersection(other: LineSegment2): IntersectionResult | null;
+}
+export {};

package/dist/src/geometry/LineSegment2.js

@@ -0,0 +1,100 @@
+import Rect2 from './Rect2';
+import { Vec2 } from './Vec2';
+export default class LineSegment2 {
+    constructor(point1, point2) {
+        this.point1 = point1;
+        this.point2 = point2;
+        this.bbox = Rect2.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.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.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,
+        };
+    }
+}

package/dist/src/geometry/Mat33.d.ts

@@ -0,0 +1,31 @@
+import { Point2, Vec2 } from './Vec2';
+import Vec3 from './Vec3';
+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;
+    constructor(a1: number, a2: number, a3: number, b1: number, b2: number, b3: number, c1: number, c2: number, c3: number);
+    static ofRows(r1: Vec3, r2: Vec3, r3: Vec3): Mat33;
+    static identity: Mat33;
+    inverse(): Mat33;
+    invertable(): boolean;
+    private cachedInverse;
+    private computeInverse;
+    transposed(): Mat33;
+    rightMul(other: Mat33): Mat33;
+    transformVec2(other: Vec3): Vec2;
+    transformVec3(other: Vec3): Vec3;
+    eq(other: Mat33, fuzz?: number): boolean;
+    toString(): string;
+    toArray(): number[];
+    static translation(amount: Vec2): Mat33;
+    static zRotation(radians: number, center?: Point2): Mat33;
+    static scaling2D(amount: number | Vec2, center?: Point2): Mat33;
+}

package/dist/src/geometry/Mat33.js

@@ -0,0 +1,187 @@
+import { Vec2 } from './Vec2';
+import Vec3 from './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).
+export default class Mat33 {
+    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.of(a1, a2, a3),
+            Vec3.of(b1, b2, b3),
+            Vec3.of(c1, c2, c3),
+        ];
+    }
+    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.
+    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.unitX,
+            Vec3.unitY,
+            Vec3.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.of(other.x, other.y, 1);
+        intermediate = this.transformVec3(intermediate);
+        // Drop the z=1 to allow magnitude to work as expected
+        return 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.of(this.rows[0].dot(other), this.rows[1].dot(other), this.rows[2].dot(other));
+    }
+    // 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() {
+        return `
+⎡ ${this.a1},\t ${this.a2},\t ${this.a3}\t ⎤
+⎢ ${this.b1},\t ${this.b2},\t ${this.b3}\t ⎥
+⎣ ${this.c1},\t ${this.c2},\t ${this.c3}\t ⎦
+		`.trimRight();
+    }
+    // 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,
+        ];
+    }
+    // Constructs a 3x3 translation matrix (for translating Vec2s)
+    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.zero) {
+        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.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)));
+    }
+}
+Mat33.identity = new Mat33(1, 0, 0, 0, 1, 0, 0, 0, 1);

package/dist/src/geometry/Path.d.ts

@@ -0,0 +1,55 @@
+import { Bezier } from 'bezier-js';
+import { RenderingStyle, RenderablePathSpec } from '../rendering/AbstractRenderer';
+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 declare 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[];
+    private cachedGeometry;
+    readonly bbox: Rect2;
+    constructor(startPoint: Point2, parts: PathCommand[]);
+    get geometry(): Array<LineSegment2 | Bezier>;
+    static computeBBoxForSegment(startPoint: Point2, part: PathCommand): Rect2;
+    intersection(line: LineSegment2): IntersectionResult[];
+    transformedBy(affineTransfm: Mat33): Path;
+    union(other: Path | null): Path;
+    static fromRenderable(renderable: RenderablePathSpec): Path;
+    toRenderable(fill: RenderingStyle): RenderablePathSpec;
+    toString(): string;
+    static toString(startPoint: Point2, parts: PathCommand[]): string;
+    static fromString(pathString: string): Path;
+}
+export {};