js-draw 0.20.0 → 0.21.0

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

@@ -10,6 +10,7 @@ const LineSegment2_1 = __importDefault(require("./LineSegment2"));
 const Mat33_1 = __importDefault(require("./Mat33"));
 const Rect2_1 = __importDefault(require("./Rect2"));
 const Vec2_1 = require("./Vec2");
+const Vec3_1 = __importDefault(require("./Vec3"));
 var PathCommandType;
 (function (PathCommandType) {
     PathCommandType[PathCommandType["LineTo"] = 0] = "LineTo";
@@ -17,6 +18,23 @@ var PathCommandType;
     PathCommandType[PathCommandType["CubicBezierTo"] = 2] = "CubicBezierTo";
     PathCommandType[PathCommandType["QuadraticBezierTo"] = 3] = "QuadraticBezierTo";
 })(PathCommandType = exports.PathCommandType || (exports.PathCommandType = {}));
+// Returns the bounding box of one path segment.
+const getPartBBox = (part) => {
+    let partBBox;
+    if (part instanceof LineSegment2_1.default) {
+        partBBox = part.bbox;
+    }
+    else if (part instanceof bezier_js_1.Bezier) {
+        const bbox = part.bbox();
+        const width = bbox.x.max - bbox.x.min;
+        const height = bbox.y.max - bbox.y.min;
+        partBBox = new Rect2_1.default(bbox.x.min, bbox.y.min, width, height);
+    }
+    else {
+        partBBox = new Rect2_1.default(part.x, part.y, 0, 0);
+    }
+    return partBBox;
+};
 class Path {
     constructor(startPoint, parts) {
         this.startPoint = startPoint;
@@ -32,6 +50,13 @@ class Path {
             this.bbox = this.bbox.union(Path.computeBBoxForSegment(startPoint, part));
         }
     }
+    getExactBBox() {
+        const bboxes = [];
+        for (const part of this.geometry) {
+            bboxes.push(getPartBBox(part));
+        }
+        return Rect2_1.default.union(...bboxes);
+    }
     // Lazy-loads and returns this path's geometry
     get geometry() {
         if (this.cachedGeometry) {
@@ -54,6 +79,7 @@ class Path {
                     startPoint = part.point;
                     break;
                 case PathCommandType.MoveTo:
+                    geometry.push(part.point);
                     startPoint = part.point;
                     break;
             }
@@ -109,11 +135,197 @@ class Path {
         }
         return Rect2_1.default.bboxOf(points);
     }
-    intersection(line) {
-        if (!line.bbox.intersects(this.bbox)) {
+    /**
+     * Let `S` be a closed path a distance `strokeRadius` from this path.
+     *
+     * @returns Approximate intersections of `line` with `S` using ray marching, starting from
+     * 	        both end points of `line` and each point in `additionalRaymarchStartPoints`.
+     */
+    raymarchIntersectionWith(line, strokeRadius, additionalRaymarchStartPoints = []) {
+        var _a, _b;
+        // No intersection between bounding boxes: No possible intersection
+        // of the interior.
+        if (!line.bbox.intersects(this.bbox.grownBy(strokeRadius))) {
+            return [];
+        }
+        const lineLength = line.length;
+        const partDistFunctionRecords = [];
+        // Determine distance functions for all parts that the given line could possibly intersect with
+        for (const part of this.geometry) {
+            const bbox = getPartBBox(part).grownBy(strokeRadius);
+            if (!bbox.intersects(line.bbox)) {
+                continue;
+            }
+            // Signed distance function
+            let partDist;
+            if (part instanceof LineSegment2_1.default) {
+                partDist = (point) => part.distance(point);
+            }
+            else if (part instanceof Vec3_1.default) {
+                partDist = (point) => part.minus(point).magnitude();
+            }
+            else {
+                partDist = (point) => {
+                    return part.project(point).d;
+                };
+            }
+            // Part signed distance function (negative result implies `point` is
+            // inside the shape).
+            const partSdf = (point) => partDist(point) - strokeRadius;
+            // If the line can't possibly intersect the part,
+            if (partSdf(line.p1) > lineLength && partSdf(line.p2) > lineLength) {
+                continue;
+            }
+            partDistFunctionRecords.push({
+                part,
+                distFn: partDist,
+                bbox,
+            });
+        }
+        // If no distance functions, there are no intersections.
+        if (partDistFunctionRecords.length === 0) {
             return [];
         }
+        // Returns the minimum distance to a part in this stroke, where only parts that the given
+        // line could intersect are considered.
+        const sdf = (point) => {
+            let minDist = Infinity;
+            let minDistPart = null;
+            const uncheckedDistFunctions = [];
+            // First pass: only curves for which the current point is inside
+            // the bounding box.
+            for (const distFnRecord of partDistFunctionRecords) {
+                const { part, distFn, bbox } = distFnRecord;
+                // Check later if the current point isn't in the bounding box.
+                if (!bbox.containsPoint(point)) {
+                    uncheckedDistFunctions.push(distFnRecord);
+                    continue;
+                }
+                const currentDist = distFn(point);
+                if (currentDist <= minDist) {
+                    minDist = currentDist;
+                    minDistPart = part;
+                }
+            }
+            // Second pass: Everything else
+            for (const { part, distFn, bbox } of uncheckedDistFunctions) {
+                // Skip if impossible for the distance to the target to be lesser than
+                // the current minimum.
+                if (!bbox.grownBy(minDist).containsPoint(point)) {
+                    continue;
+                }
+                const currentDist = distFn(point);
+                if (currentDist <= minDist) {
+                    minDist = currentDist;
+                    minDistPart = part;
+                }
+            }
+            return [minDistPart, minDist - strokeRadius];
+        };
+        // Raymarch:
+        const maxRaymarchSteps = 7;
+        // Start raymarching from each of these points. This allows detection of multiple
+        // intersections.
+        const startPoints = [
+            line.p1, ...additionalRaymarchStartPoints, line.p2
+        ];
+        // Converts a point ON THE LINE to a parameter
+        const pointToParameter = (point) => {
+            // Because line.direction is a unit vector, this computes the length
+            // of the projection of the vector(line.p1->point) onto line.direction.
+            //
+            // Note that this can be negative if the given point is outside of the given
+            // line segment.
+            return point.minus(line.p1).dot(line.direction);
+        };
+        // Sort start points by parameter on the line.
+        // This allows us to determine whether the current value of a parameter
+        // drops down to a value already tested.
+        startPoints.sort((a, b) => {
+            const t_a = pointToParameter(a);
+            const t_b = pointToParameter(b);
+            // Sort in increasing order
+            return t_a - t_b;
+        });
         const result = [];
+        const stoppingThreshold = strokeRadius / 1000;
+        // Returns the maximum x value explored
+        const raymarchFrom = (startPoint, 
+        // Direction to march in (multiplies line.direction)
+        directionMultiplier, 
+        // Terminate if the current point corresponds to a parameter
+        // below this.
+        minimumLineParameter) => {
+            let currentPoint = startPoint;
+            let [lastPart, lastDist] = sdf(currentPoint);
+            let lastParameter = pointToParameter(currentPoint);
+            if (lastDist > lineLength) {
+                return lastParameter;
+            }
+            const direction = line.direction.times(directionMultiplier);
+            for (let i = 0; i < maxRaymarchSteps; i++) {
+                // Step in the direction of the edge of the shape.
+                const step = lastDist;
+                currentPoint = currentPoint.plus(direction.times(step));
+                lastParameter = pointToParameter(currentPoint);
+                // If we're below the minimum parameter, stop. We've already tried
+                // this.
+                if (lastParameter <= minimumLineParameter) {
+                    return lastParameter;
+                }
+                const [currentPart, signedDist] = sdf(currentPoint);
+                // Ensure we're stepping in the correct direction.
+                // Note that because we could start with a negative distance and work towards a
+                // positive distance, we need absolute values here.
+                if (Math.abs(signedDist) > Math.abs(lastDist)) {
+                    // If not, stop.
+                    return null;
+                }
+                lastDist = signedDist;
+                lastPart = currentPart;
+                // Is the distance close enough that we can stop early?
+                if (Math.abs(lastDist) < stoppingThreshold) {
+                    break;
+                }
+            }
+            // Ensure that the point we ended with is on the line.
+            const isOnLineSegment = lastParameter >= 0 && lastParameter <= lineLength;
+            if (lastPart && isOnLineSegment && Math.abs(lastDist) < stoppingThreshold) {
+                result.push({
+                    point: currentPoint,
+                    parameterValue: NaN,
+                    curve: lastPart,
+                });
+            }
+            return lastParameter;
+        };
+        // The maximum value of the line's parameter explored so far (0 corresponds to
+        // line.p1)
+        let maxLineT = 0;
+        // Raymarch for each start point.
+        //
+        // Use a for (i from 0 to length) loop because startPoints may be added
+        // during iteration.
+        for (let i = 0; i < startPoints.length; i++) {
+            const startPoint = startPoints[i];
+            // Try raymarching in both directions.
+            maxLineT = Math.max(maxLineT, (_a = raymarchFrom(startPoint, 1, maxLineT)) !== null && _a !== void 0 ? _a : maxLineT);
+            maxLineT = Math.max(maxLineT, (_b = raymarchFrom(startPoint, -1, maxLineT)) !== null && _b !== void 0 ? _b : maxLineT);
+        }
+        return result;
+    }
+    /**
+     * Returns a list of intersections with this path. If `strokeRadius` is given,
+     * intersections are approximated with the surface `strokeRadius` away from this.
+     *
+     * If `strokeRadius > 0`, the resultant `parameterValue` has no defined value.
+     */
+    intersection(line, strokeRadius) {
+        let result = [];
+        // Is any intersection between shapes within the bounding boxes impossible?
+        if (!line.bbox.intersects(this.bbox.grownBy(strokeRadius !== null && strokeRadius !== void 0 ? strokeRadius : 0))) {
+            return [];
+        }
         for (const part of this.geometry) {
             if (part instanceof LineSegment2_1.default) {
                 const intersection = part.intersection(line);
@@ -125,7 +337,7 @@ class Path {
                     });
                 }
             }
-            else {
+            else if (part instanceof bezier_js_1.Bezier) {
                 const intersectionPoints = part.intersects(line).map(t => {
                     // We're using the .intersects(line) function, which is documented
                     // to always return numbers. However, to satisfy the type checker (and
@@ -148,6 +360,15 @@ class Path {
                 result.push(...intersectionPoints);
             }
         }
+        // If given a non-zero strokeWidth, attempt to raymarch.
+        // Even if raymarching, we need to collect starting points.
+        // We use the above-calculated intersections for this.
+        const doRaymarching = strokeRadius && strokeRadius > 1e-8;
+        if (doRaymarching) {
+            // Starting points for raymarching (in addition to the end points of the line).
+            const startPoints = result.map(intersection => intersection.point);
+            result = this.raymarchIntersectionWith(line, strokeRadius, startPoints);
+        }
         return result;
     }
     static mapPathCommand(part, mapping) {

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

@@ -73,9 +73,7 @@ class Rect2 {
     }
     // Returns a new rectangle containing both [this] and [other].
     union(other) {
-        const topLeft = this.topLeft.zip(other.topLeft, Math.min);
-        const bottomRight = this.bottomRight.zip(other.bottomRight, Math.max);
-        return Rect2.fromCorners(topLeft, bottomRight);
+        return Rect2.union(this, other);
     }
     // Returns a the subdivision of this into [columns] columns
     // and [rows] rows. For example,
@@ -113,6 +111,9 @@ class Rect2 {
     }
     // Returns this grown by [margin] in both the x and y directions.
     grownBy(margin) {
+        if (margin === 0) {
+            return this;
+        }
         return new Rect2(this.x - margin, this.y - margin, this.w + margin * 2, this.h + margin * 2);
     }
     getClosestPointOnBoundaryTo(target) {

package/dist/cjs/src/math/polynomial/QuadraticBezier.d.ts

@@ -21,7 +21,7 @@ export default class QuadraticBezier {
      */
     approximateDistance(point: Point2): number;
     /**
-     * @returns the exact distance from `point` to this.
+     * @returns the (more) exact distance from `point` to this.
      */
     distance(point: Point2): number;
     normal(t: number): Vec2;

package/dist/cjs/src/math/polynomial/QuadraticBezier.js

@@ -97,15 +97,14 @@ class QuadraticBezier {
         return Math.sqrt(Math.min(sqrDist1, sqrDist2, sqrDist3, sqrDist4));
     }
     /**
-     * @returns the exact distance from `point` to this.
+     * @returns the (more) exact distance from `point` to this.
      */
     distance(point) {
         if (!this.bezierJs) {
             this.bezierJs = new bezier_js_1.Bezier([this.p0.xy, this.p1.xy, this.p2.xy]);
         }
-        const proj = Vec2_1.Vec2.ofXY(this.bezierJs.project(point.xy));
-        const dist = proj.minus(point).magnitude();
-        return dist;
+        // .d: Distance
+        return this.bezierJs.project(point.xy).d;
     }
     normal(t) {
         const tangent = this.derivativeAt(t);

package/dist/cjs/src/toolbar/HTMLToolbar.js

@@ -66,6 +66,13 @@ class HTMLToolbar {
         const closePickerOverlay = document.createElement('div');
         closePickerOverlay.className = `${exports.toolbarCSSPrefix}closeColorPickerOverlay`;
         this.editor.createHTMLOverlay(closePickerOverlay);
+        // Hide the color picker when attempting to draw on the overlay.
+        this.listeners.push(this.editor.handlePointerEventsFrom(closePickerOverlay, (eventName) => {
+            if (eventName === 'pointerdown') {
+                (0, coloris_1.close)();
+            }
+            return true;
+        }));
         const maxSwatchLen = 12;
         const swatches = [
             Color4_1.default.red.toHexString(),

package/dist/mjs/src/Editor.d.ts

@@ -191,7 +191,10 @@ export declare class Editor {
      * });
      * ```
      */
-    handlePointerEventsFrom(elem: HTMLElement, filter?: HTMLPointerEventFilter): void;
+    handlePointerEventsFrom(elem: HTMLElement, filter?: HTMLPointerEventFilter): {
+        /** Remove all event listeners registered by this function. */
+        remove: () => void;
+    };
     /** Adds event listners for keypresses to `elem` and forwards those events to the editor. */
     handleKeyEventsFrom(elem: HTMLElement): void;
     /** `apply` a command. `command` will be announced for accessibility. */

package/dist/mjs/src/Editor.mjs

@@ -455,20 +455,38 @@ export class Editor {
     handlePointerEventsFrom(elem, filter) {
         // May be required to prevent text selection on iOS/Safari:
         // See https://stackoverflow.com/a/70992717/17055750
-        elem.addEventListener('touchstart', evt => evt.preventDefault());
-        elem.addEventListener('contextmenu', evt => {
+        const touchstartListener = (evt) => evt.preventDefault();
+        const contextmenuListener = (evt) => {
             // Don't show a context menu
             evt.preventDefault();
-        });
+        };
+        const listeners = {
+            'touchstart': touchstartListener,
+            'contextmenu': contextmenuListener,
+        };
         const eventNames = ['pointerdown', 'pointermove', 'pointerup', 'pointercancel'];
         for (const eventName of eventNames) {
-            elem.addEventListener(eventName, evt => {
-                if (filter && !filter(eventName, evt)) {
+            listeners[eventName] = (evt) => {
+                // This listener will only be called in the context of PointerEvents.
+                const event = evt;
+                if (filter && !filter(eventName, event)) {
                     return true;
                 }
-                return this.handleHTMLPointerEvent(eventName, evt);
-            });
+                return this.handleHTMLPointerEvent(eventName, event);
+            };
         }
+        // Add all listeners.
+        for (const eventName in listeners) {
+            elem.addEventListener(eventName, listeners[eventName]);
+        }
+        return {
+            /** Remove all event listeners registered by this function. */
+            remove: () => {
+                for (const eventName in listeners) {
+                    elem.removeEventListener(eventName, listeners[eventName]);
+                }
+            },
+        };
     }
     /** Adds event listners for keypresses to `elem` and forwards those events to the editor. */
     handleKeyEventsFrom(elem) {

package/dist/mjs/src/components/AbstractComponent.d.ts

@@ -32,8 +32,15 @@ export default abstract class AbstractComponent {
     /** See {@link attachLoadSaveData} */
     getLoadSaveData(): LoadSaveDataTable;
     getZIndex(): number;
-    /** @returns the bounding box of this. */
+    /**
+     * @returns the bounding box of this. This can be a slight overestimate if doing so
+     * 			significantly improves performance.
+     */
     getBBox(): Rect2;
+    /**
+     * @returns the bounding box of this. Unlike `getBBox`, this should **not** be a rough estimate.
+     */
+    getExactBBox(): Rect2;
     /** Called when this component is added to the given image. */
     onAddToImage(_image: EditorImage): void;
     onRemoveFromImage(): void;
@@ -43,6 +50,11 @@ export default abstract class AbstractComponent {
     /**
      * @returns true if this component intersects `rect` -- it is entirely contained
      *  within the rectangle or one of the rectangle's edges intersects this component.
+     *
+     * The default implementation assumes that `this.getExactBBox()` returns a tight bounding box
+     * -- that any horiziontal/vertical line that intersects this' boounding box also
+     * intersects a point in this component. If this is not the case, components must override
+     * this function.
      */
     intersectsRect(rect: Rect2): boolean;
     protected abstract serializeToJSON(): any[] | Record<string, any> | number | string | null;

package/dist/mjs/src/components/AbstractComponent.mjs

@@ -55,30 +55,40 @@ export default class AbstractComponent {
     getZIndex() {
         return this.zIndex;
     }
-    /** @returns the bounding box of this. */
+    /**
+     * @returns the bounding box of this. This can be a slight overestimate if doing so
+     * 			significantly improves performance.
+     */
     getBBox() {
         return this.contentBBox;
     }
+    /**
+     * @returns the bounding box of this. Unlike `getBBox`, this should **not** be a rough estimate.
+     */
+    getExactBBox() {
+        return this.getBBox();
+    }
     /** Called when this component is added to the given image. */
     onAddToImage(_image) { }
     onRemoveFromImage() { }
     /**
      * @returns true if this component intersects `rect` -- it is entirely contained
      *  within the rectangle or one of the rectangle's edges intersects this component.
+     *
+     * The default implementation assumes that `this.getExactBBox()` returns a tight bounding box
+     * -- that any horiziontal/vertical line that intersects this' boounding box also
+     * intersects a point in this component. If this is not the case, components must override
+     * this function.
      */
     intersectsRect(rect) {
-        // If this component intersects rect,
+        // If this component intersects the given rectangle,
         // it is either contained entirely within rect or intersects one of rect's edges.
         // If contained within,
-        if (rect.containsRect(this.getBBox())) {
+        if (rect.containsRect(this.getExactBBox())) {
             return true;
         }
-        // Calculated bounding boxes can be slightly larger than their actual contents' bounding box.
-        // As such, test with more lines than just the rect's edges.
-        const testLines = [];
-        for (const subregion of rect.divideIntoGrid(2, 2)) {
-            testLines.push(...subregion.getEdges());
-        }
+        // Otherwise check if it intersects one of the rectangle's edges.
+        const testLines = rect.getEdges();
         return testLines.some(edge => this.intersects(edge));
     }
     // Returns a command that, when applied, transforms this by [affineTransfm] and

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

@@ -53,6 +53,7 @@ export default class Stroke extends AbstractComponent implements RestyleableComp
     render(canvas: AbstractRenderer, visibleRect?: Rect2): void;
     getProportionalRenderingTime(): number;
     private bboxForPart;
+    getExactBBox(): Rect2;
     protected applyTransformation(affineTransfm: Mat33): void;
     /**
      * @returns the {@link Path.union} of all paths that make up this stroke.

package/dist/mjs/src/components/Stroke.mjs

@@ -109,8 +109,11 @@ export default class Stroke extends AbstractComponent {
         }
     }
     intersects(line) {
+        var _a;
         for (const part of this.parts) {
-            if (part.path.intersection(line).length > 0) {
+            const strokeWidth = (_a = part.style.stroke) === null || _a === void 0 ? void 0 : _a.width;
+            const strokeRadius = strokeWidth ? strokeWidth / 2 : undefined;
+            if (part.path.intersection(line, strokeRadius).length > 0) {
                 return true;
             }
         }
@@ -144,6 +147,16 @@ export default class Stroke extends AbstractComponent {
         }
         return origBBox.grownBy(style.stroke.width / 2);
     }
+    getExactBBox() {
+        let bbox = null;
+        for (const { path, style } of this.parts) {
+            // Paths' default .bbox can be
+            const partBBox = this.bboxForPart(path.getExactBBox(), style);
+            bbox !== null && bbox !== void 0 ? bbox : (bbox = partBBox);
+            bbox = bbox.union(partBBox);
+        }
+        return bbox !== null && bbox !== void 0 ? bbox : Rect2.empty;
+    }
     applyTransformation(affineTransfm) {
         this.contentBBox = Rect2.empty;
         let isFirstPart = true;

package/dist/mjs/src/components/util/StrokeSmoother.mjs

@@ -146,7 +146,7 @@ export class StrokeSmoother {
         }
         let exitingVec = this.computeExitingVec();
         // Find the intersection between the entering vector and the exiting vector
-        const maxRelativeLength = 2.2;
+        const maxRelativeLength = 2;
         const segmentStart = this.buffer[0];
         const segmentEnd = newPoint.pos;
         const startEndDist = segmentEnd.minus(segmentStart).magnitude();
@@ -184,22 +184,20 @@ export class StrokeSmoother {
         // Should we start making a new curve? Check whether all buffer points are within
         // ±strokeWidth of the curve.
         const curveMatchesPoints = (curve) => {
-            let nonMatching = 0;
-            const maxNonMatching = 2;
-            const minFit = Math.max(Math.min(this.curveStartWidth, this.curveEndWidth) / 3, this.minFitAllowed);
+            const minFit = Math.min(Math.max(Math.min(this.curveStartWidth, this.curveEndWidth) / 4, this.minFitAllowed), this.maxFitAllowed);
+            // The sum of distances greater than minFit must not exceed this:
+            const maxNonMatchingDistSum = minFit;
+            // Sum of distances greater than minFit.
+            let nonMatchingDistSum = 0;
             for (const point of this.buffer) {
                 let dist = curve.approximateDistance(point);
-                if (dist > minFit || dist > this.maxFitAllowed) {
-                    // Avoid using the slower .distance
-                    if (nonMatching >= maxNonMatching - 1) {
-                        dist = curve.distance(point);
+                if (dist > minFit) {
+                    // Use the more accurate distance function
+                    dist = curve.distance(point);
+                    nonMatchingDistSum += Math.max(0, dist - minFit);
+                    if (nonMatchingDistSum > maxNonMatchingDistSum) {
+                        return false; // false: Curve doesn't match points well enough.
                     }
-                    if (dist > minFit || dist > this.maxFitAllowed) {
-                        nonMatching++;
-                    }
-                }
-                if (nonMatching >= maxNonMatching) {
-                    return false;
                 }
             }
             return true;

package/dist/mjs/src/math/LineSegment2.d.ts

@@ -18,6 +18,8 @@ export default class LineSegment2 {
     intersection(other: LineSegment2): IntersectionResult | null;
     intersects(other: LineSegment2): boolean;
     closestPointTo(target: Point2): import("./Vec3").default;
+    /** Returns the distance from this line segment to `target`. */
+    distance(target: Point2): number;
     transformedBy(affineTransfm: Mat33): LineSegment2;
     toString(): string;
 }

package/dist/mjs/src/math/LineSegment2.mjs

@@ -116,6 +116,10 @@ export default class LineSegment2 {
             return this.p1;
         }
     }
+    /** Returns the distance from this line segment to `target`. */
+    distance(target) {
+        return this.closestPointTo(target).minus(target).magnitude();
+    }
     transformedBy(affineTransfm) {
         return new LineSegment2(affineTransfm.transformVec2(this.p1), affineTransfm.transformVec2(this.p2));
     }

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

@@ -32,21 +32,42 @@ export interface MoveToPathCommand {
 }
 export type PathCommand = CubicBezierPathCommand | LinePathCommand | QuadraticBezierPathCommand | MoveToPathCommand;
 interface IntersectionResult {
-    curve: LineSegment2 | Bezier;
+    curve: LineSegment2 | Bezier | Point2;
     parameterValue: number;
     point: Point2;
 }
+type GeometryType = LineSegment2 | Bezier | Point2;
+type GeometryArrayType = Array<GeometryType>;
 export default class Path {
     readonly startPoint: Point2;
     readonly parts: PathCommand[];
+    /**
+     * A rough estimate of the bounding box of the path.
+     * A slight overestimate.
+     * See {@link getExactBBox}
+     */
     readonly bbox: Rect2;
     constructor(startPoint: Point2, parts: PathCommand[]);
+    getExactBBox(): Rect2;
     private cachedGeometry;
-    get geometry(): Array<LineSegment2 | Bezier>;
+    get geometry(): GeometryArrayType;
     private cachedPolylineApproximation;
     polylineApproximation(): LineSegment2[];
     static computeBBoxForSegment(startPoint: Point2, part: PathCommand): Rect2;
-    intersection(line: LineSegment2): IntersectionResult[];
+    /**
+     * Let `S` be a closed path a distance `strokeRadius` from this path.
+     *
+     * @returns Approximate intersections of `line` with `S` using ray marching, starting from
+     * 	        both end points of `line` and each point in `additionalRaymarchStartPoints`.
+     */
+    private raymarchIntersectionWith;
+    /**
+     * Returns a list of intersections with this path. If `strokeRadius` is given,
+     * intersections are approximated with the surface `strokeRadius` away from this.
+     *
+     * If `strokeRadius > 0`, the resultant `parameterValue` has no defined value.
+     */
+    intersection(line: LineSegment2, strokeRadius?: number): IntersectionResult[];
     private static mapPathCommand;
     mapPoints(mapping: (point: Point2) => Point2): Path;
     transformedBy(affineTransfm: Mat33): Path;