js-draw 0.23.1 → 0.24.1

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

@@ -0,0 +1,865 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathCommandType = void 0;
+var rounding_1 = require("../rounding");
+var LineSegment2_1 = require("./LineSegment2");
+var Mat33_1 = require("../Mat33");
+var Rect2_1 = require("./Rect2");
+var Vec2_1 = require("../Vec2");
+var CubicBezier_1 = require("./CubicBezier");
+var QuadraticBezier_1 = require("./QuadraticBezier");
+var PointShape2D_1 = require("./PointShape2D");
+var PathCommandType;
+(function (PathCommandType) {
+    PathCommandType[PathCommandType["LineTo"] = 0] = "LineTo";
+    PathCommandType[PathCommandType["MoveTo"] = 1] = "MoveTo";
+    PathCommandType[PathCommandType["CubicBezierTo"] = 2] = "CubicBezierTo";
+    PathCommandType[PathCommandType["QuadraticBezierTo"] = 3] = "QuadraticBezierTo";
+})(PathCommandType || (exports.PathCommandType = PathCommandType = {}));
+var Path = /** @class */ (function () {
+    function Path(startPoint, parts) {
+        this.startPoint = startPoint;
+        this.parts = parts;
+        this.cachedGeometry = null;
+        this.cachedPolylineApproximation = null;
+        this.cachedStringVersion = null;
+        // Initial bounding box contains one point: the start point.
+        this.bbox = Rect2_1.default.bboxOf([startPoint]);
+        // Convert into a representation of the geometry (cache for faster intersection
+        // calculation)
+        for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
+            var part = parts_1[_i];
+            this.bbox = this.bbox.union(Path.computeBBoxForSegment(startPoint, part));
+        }
+    }
+    Path.prototype.getExactBBox = function () {
+        var bboxes = [];
+        for (var _i = 0, _a = this.geometry; _i < _a.length; _i++) {
+            var part = _a[_i];
+            bboxes.push(part.getTightBoundingBox());
+        }
+        return Rect2_1.default.union.apply(Rect2_1.default, bboxes);
+    };
+    Object.defineProperty(Path.prototype, "geometry", {
+        // Lazy-loads and returns this path's geometry
+        get: function () {
+            if (this.cachedGeometry) {
+                return this.cachedGeometry;
+            }
+            var startPoint = this.startPoint;
+            var geometry = [];
+            for (var _i = 0, _a = this.parts; _i < _a.length; _i++) {
+                var part = _a[_i];
+                switch (part.kind) {
+                    case PathCommandType.CubicBezierTo:
+                        geometry.push(new CubicBezier_1.default(startPoint, part.controlPoint1, part.controlPoint2, part.endPoint));
+                        startPoint = part.endPoint;
+                        break;
+                    case PathCommandType.QuadraticBezierTo:
+                        geometry.push(new QuadraticBezier_1.default(startPoint, part.controlPoint, part.endPoint));
+                        startPoint = part.endPoint;
+                        break;
+                    case PathCommandType.LineTo:
+                        geometry.push(new LineSegment2_1.default(startPoint, part.point));
+                        startPoint = part.point;
+                        break;
+                    case PathCommandType.MoveTo:
+                        geometry.push(new PointShape2D_1.default(part.point));
+                        startPoint = part.point;
+                        break;
+                }
+            }
+            this.cachedGeometry = geometry;
+            return this.cachedGeometry;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    // Approximates this path with a group of line segments.
+    Path.prototype.polylineApproximation = function () {
+        if (this.cachedPolylineApproximation) {
+            return this.cachedPolylineApproximation;
+        }
+        var points = [];
+        for (var _i = 0, _a = this.parts; _i < _a.length; _i++) {
+            var part = _a[_i];
+            switch (part.kind) {
+                case PathCommandType.CubicBezierTo:
+                    points.push(part.controlPoint1, part.controlPoint2, part.endPoint);
+                    break;
+                case PathCommandType.QuadraticBezierTo:
+                    points.push(part.controlPoint, part.endPoint);
+                    break;
+                case PathCommandType.MoveTo:
+                case PathCommandType.LineTo:
+                    points.push(part.point);
+                    break;
+            }
+        }
+        var result = [];
+        var prevPoint = this.startPoint;
+        for (var _b = 0, points_1 = points; _b < points_1.length; _b++) {
+            var point = points_1[_b];
+            result.push(new LineSegment2_1.default(prevPoint, point));
+            prevPoint = point;
+        }
+        return result;
+    };
+    Path.computeBBoxForSegment = function (startPoint, part) {
+        var points = [startPoint];
+        var exhaustivenessCheck;
+        switch (part.kind) {
+            case PathCommandType.MoveTo:
+            case PathCommandType.LineTo:
+                points.push(part.point);
+                break;
+            case PathCommandType.CubicBezierTo:
+                points.push(part.controlPoint1, part.controlPoint2, part.endPoint);
+                break;
+            case PathCommandType.QuadraticBezierTo:
+                points.push(part.controlPoint, part.endPoint);
+                break;
+            default:
+                exhaustivenessCheck = part;
+                return exhaustivenessCheck;
+        }
+        return Rect2_1.default.bboxOf(points);
+    };
+    /**
+     * 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`.
+     */
+    Path.prototype.raymarchIntersectionWith = function (line, strokeRadius, additionalRaymarchStartPoints) {
+        var _a, _b;
+        if (additionalRaymarchStartPoints === void 0) { additionalRaymarchStartPoints = []; }
+        // No intersection between bounding boxes: No possible intersection
+        // of the interior.
+        if (!line.bbox.intersects(this.bbox.grownBy(strokeRadius))) {
+            return [];
+        }
+        var lineLength = line.length;
+        var partDistFunctionRecords = [];
+        var _loop_1 = function (part) {
+            var bbox = part.getTightBoundingBox().grownBy(strokeRadius);
+            if (!bbox.intersects(line.bbox)) {
+                return "continue";
+            }
+            // Signed distance function
+            var partDist = function (point) { return part.signedDistance(point); };
+            // Part signed distance function (negative result implies `point` is
+            // inside the shape).
+            var partSdf = function (point) { return partDist(point) - strokeRadius; };
+            // If the line can't possibly intersect the part,
+            if (partSdf(line.p1) > lineLength && partSdf(line.p2) > lineLength) {
+                return "continue";
+            }
+            partDistFunctionRecords.push({
+                part: part,
+                distFn: partDist,
+                bbox: bbox,
+            });
+        };
+        // Determine distance functions for all parts that the given line could possibly intersect with
+        for (var _i = 0, _c = this.geometry; _i < _c.length; _i++) {
+            var part = _c[_i];
+            _loop_1(part);
+        }
+        // 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.
+        var sdf = function (point) {
+            var minDist = Infinity;
+            var minDistPart = null;
+            var uncheckedDistFunctions = [];
+            // First pass: only curves for which the current point is inside
+            // the bounding box.
+            for (var _i = 0, partDistFunctionRecords_1 = partDistFunctionRecords; _i < partDistFunctionRecords_1.length; _i++) {
+                var distFnRecord = partDistFunctionRecords_1[_i];
+                var part = distFnRecord.part, distFn = distFnRecord.distFn, bbox = distFnRecord.bbox;
+                // Check later if the current point isn't in the bounding box.
+                if (!bbox.containsPoint(point)) {
+                    uncheckedDistFunctions.push(distFnRecord);
+                    continue;
+                }
+                var currentDist = distFn(point);
+                if (currentDist <= minDist) {
+                    minDist = currentDist;
+                    minDistPart = part;
+                }
+            }
+            // Second pass: Everything else
+            for (var _a = 0, uncheckedDistFunctions_1 = uncheckedDistFunctions; _a < uncheckedDistFunctions_1.length; _a++) {
+                var _b = uncheckedDistFunctions_1[_a], part = _b.part, distFn = _b.distFn, bbox = _b.bbox;
+                // Skip if impossible for the distance to the target to be lesser than
+                // the current minimum.
+                if (!bbox.grownBy(minDist).containsPoint(point)) {
+                    continue;
+                }
+                var currentDist = distFn(point);
+                if (currentDist <= minDist) {
+                    minDist = currentDist;
+                    minDistPart = part;
+                }
+            }
+            return [minDistPart, minDist - strokeRadius];
+        };
+        // Raymarch:
+        var maxRaymarchSteps = 7;
+        // Start raymarching from each of these points. This allows detection of multiple
+        // intersections.
+        var startPoints = __spreadArray(__spreadArray([
+            line.p1
+        ], additionalRaymarchStartPoints, true), [
+            line.p2
+        ], false);
+        // Converts a point ON THE LINE to a parameter
+        var pointToParameter = function (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(function (a, b) {
+            var t_a = pointToParameter(a);
+            var t_b = pointToParameter(b);
+            // Sort in increasing order
+            return t_a - t_b;
+        });
+        var result = [];
+        var stoppingThreshold = strokeRadius / 1000;
+        // Returns the maximum x value explored
+        var raymarchFrom = function (startPoint, 
+        // Direction to march in (multiplies line.direction)
+        directionMultiplier, 
+        // Terminate if the current point corresponds to a parameter
+        // below this.
+        minimumLineParameter) {
+            var currentPoint = startPoint;
+            var _a = sdf(currentPoint), lastPart = _a[0], lastDist = _a[1];
+            var lastParameter = pointToParameter(currentPoint);
+            if (lastDist > lineLength) {
+                return lastParameter;
+            }
+            var direction = line.direction.times(directionMultiplier);
+            for (var i = 0; i < maxRaymarchSteps; i++) {
+                // Step in the direction of the edge of the shape.
+                var 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;
+                }
+                var _b = sdf(currentPoint), currentPart = _b[0], signedDist = _b[1];
+                // 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.
+            var 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)
+        var maxLineT = 0;
+        // Raymarch for each start point.
+        //
+        // Use a for (i from 0 to length) loop because startPoints may be added
+        // during iteration.
+        for (var i = 0; i < startPoints.length; i++) {
+            var 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.
+     */
+    Path.prototype.intersection = function (line, strokeRadius) {
+        var 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 (var _i = 0, _a = this.geometry; _i < _a.length; _i++) {
+            var part = _a[_i];
+            var intersection = part.intersectsLineSegment(line);
+            if (intersection.length > 0) {
+                result.push({
+                    curve: part,
+                    point: intersection[0],
+                });
+            }
+        }
+        // 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.
+        var doRaymarching = strokeRadius && strokeRadius > 1e-8;
+        if (doRaymarching) {
+            // Starting points for raymarching (in addition to the end points of the line).
+            var startPoints = result.map(function (intersection) { return intersection.point; });
+            result = this.raymarchIntersectionWith(line, strokeRadius, startPoints);
+        }
+        return result;
+    };
+    Path.mapPathCommand = function (part, mapping) {
+        switch (part.kind) {
+            case PathCommandType.MoveTo:
+            case PathCommandType.LineTo:
+                return {
+                    kind: part.kind,
+                    point: mapping(part.point),
+                };
+                break;
+            case PathCommandType.CubicBezierTo:
+                return {
+                    kind: part.kind,
+                    controlPoint1: mapping(part.controlPoint1),
+                    controlPoint2: mapping(part.controlPoint2),
+                    endPoint: mapping(part.endPoint),
+                };
+                break;
+            case PathCommandType.QuadraticBezierTo:
+                return {
+                    kind: part.kind,
+                    controlPoint: mapping(part.controlPoint),
+                    endPoint: mapping(part.endPoint),
+                };
+                break;
+        }
+        var exhaustivenessCheck = part;
+        return exhaustivenessCheck;
+    };
+    Path.prototype.mapPoints = function (mapping) {
+        var startPoint = mapping(this.startPoint);
+        var newParts = [];
+        for (var _i = 0, _a = this.parts; _i < _a.length; _i++) {
+            var part = _a[_i];
+            newParts.push(Path.mapPathCommand(part, mapping));
+        }
+        return new Path(startPoint, newParts);
+    };
+    Path.prototype.transformedBy = function (affineTransfm) {
+        if (affineTransfm.isIdentity()) {
+            return this;
+        }
+        return this.mapPoints(function (point) { return affineTransfm.transformVec2(point); });
+    };
+    // Creates a new path by joining [other] to the end of this path
+    Path.prototype.union = function (other) {
+        if (!other) {
+            return this;
+        }
+        return new Path(this.startPoint, __spreadArray(__spreadArray(__spreadArray([], this.parts, true), [
+            {
+                kind: PathCommandType.MoveTo,
+                point: other.startPoint,
+            }
+        ], false), other.parts, true));
+    };
+    Path.prototype.getEndPoint = function () {
+        if (this.parts.length === 0) {
+            return this.startPoint;
+        }
+        var lastPart = this.parts[this.parts.length - 1];
+        if (lastPart.kind === PathCommandType.QuadraticBezierTo || lastPart.kind === PathCommandType.CubicBezierTo) {
+            return lastPart.endPoint;
+        }
+        else {
+            return lastPart.point;
+        }
+    };
+    Path.prototype.roughlyIntersects = function (rect, strokeWidth) {
+        if (strokeWidth === void 0) { strokeWidth = 0; }
+        if (this.parts.length === 0) {
+            return rect.containsPoint(this.startPoint);
+        }
+        var isClosed = this.startPoint.eq(this.getEndPoint());
+        if (isClosed && strokeWidth === 0) {
+            return this.closedRoughlyIntersects(rect);
+        }
+        if (rect.containsRect(this.bbox)) {
+            return true;
+        }
+        // Does the rectangle intersect the bounding boxes of any of this' parts?
+        var startPoint = this.startPoint;
+        for (var _i = 0, _a = this.parts; _i < _a.length; _i++) {
+            var part = _a[_i];
+            var bbox = Path.computeBBoxForSegment(startPoint, part).grownBy(strokeWidth);
+            if (part.kind === PathCommandType.LineTo || part.kind === PathCommandType.MoveTo) {
+                startPoint = part.point;
+            }
+            else {
+                startPoint = part.endPoint;
+            }
+            if (rect.intersects(bbox)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    // Treats this as a closed path and returns true if part of `rect` is roughly within
+    // this path's interior.
+    //
+    // Note: Assumes that this is a closed, non-self-intersecting path.
+    Path.prototype.closedRoughlyIntersects = function (rect) {
+        if (rect.containsRect(this.bbox)) {
+            return true;
+        }
+        // Choose a point outside of the path.
+        var startPt = this.bbox.topLeft.minus(Vec2_1.Vec2.of(1, 1));
+        var testPts = rect.corners;
+        var polygon = this.polylineApproximation();
+        for (var _i = 0, testPts_1 = testPts; _i < testPts_1.length; _i++) {
+            var point = testPts_1[_i];
+            var testLine = new LineSegment2_1.default(point, startPt);
+            var intersectionCount = 0;
+            for (var _a = 0, polygon_1 = polygon; _a < polygon_1.length; _a++) {
+                var line = polygon_1[_a];
+                if (line.intersects(testLine)) {
+                    intersectionCount++;
+                }
+            }
+            // Odd? The point is within the polygon!
+            if (intersectionCount % 2 === 1) {
+                return true;
+            }
+        }
+        // Grow the rectangle for possible additional precision.
+        var grownRect = rect.grownBy(Math.min(rect.size.x, rect.size.y));
+        var edges = [];
+        for (var _b = 0, _c = grownRect.divideIntoGrid(4, 4); _b < _c.length; _b++) {
+            var subrect = _c[_b];
+            edges.push.apply(edges, subrect.getEdges());
+        }
+        for (var _d = 0, edges_1 = edges; _d < edges_1.length; _d++) {
+            var edge = edges_1[_d];
+            for (var _e = 0, polygon_2 = polygon; _e < polygon_2.length; _e++) {
+                var line = polygon_2[_e];
+                if (edge.intersects(line)) {
+                    return true;
+                }
+            }
+        }
+        // Even? Probably no intersection.
+        return false;
+    };
+    // Returns a path that outlines [rect]. If [lineWidth] is not given, the resultant path is
+    // the outline of [rect]. Otherwise, the resultant path represents a line of width [lineWidth]
+    // that traces [rect].
+    Path.fromRect = function (rect, lineWidth) {
+        if (lineWidth === void 0) { lineWidth = null; }
+        var commands = [];
+        var corners;
+        var startPoint;
+        if (lineWidth !== null) {
+            // Vector from the top left corner or bottom right corner to the edge of the
+            // stroked region.
+            var cornerToEdge = Vec2_1.Vec2.of(lineWidth, lineWidth).times(0.5);
+            var innerRect = Rect2_1.default.fromCorners(rect.topLeft.plus(cornerToEdge), rect.bottomRight.minus(cornerToEdge));
+            var outerRect = Rect2_1.default.fromCorners(rect.topLeft.minus(cornerToEdge), rect.bottomRight.plus(cornerToEdge));
+            corners = __spreadArray(__spreadArray([
+                innerRect.corners[3]
+            ], innerRect.corners, true), outerRect.corners.reverse(), true);
+            startPoint = outerRect.corners[3];
+        }
+        else {
+            corners = rect.corners.slice(1);
+            startPoint = rect.corners[0];
+        }
+        for (var _i = 0, corners_1 = corners; _i < corners_1.length; _i++) {
+            var corner = corners_1[_i];
+            commands.push({
+                kind: PathCommandType.LineTo,
+                point: corner,
+            });
+        }
+        // Close the shape
+        commands.push({
+            kind: PathCommandType.LineTo,
+            point: startPoint,
+        });
+        return new Path(startPoint, commands);
+    };
+    Path.fromRenderable = function (renderable) {
+        if (renderable.path) {
+            return renderable.path;
+        }
+        return new Path(renderable.startPoint, renderable.commands);
+    };
+    Path.prototype.toRenderable = function (fill) {
+        return {
+            startPoint: this.startPoint,
+            style: fill,
+            commands: this.parts,
+            path: this,
+        };
+    };
+    /**
+     * @returns a Path that, when rendered, looks roughly equivalent to the given path.
+     */
+    Path.visualEquivalent = function (renderablePath, visibleRect) {
+        var _a, _b;
+        var path = Path.fromRenderable(renderablePath);
+        var strokeWidth = (_b = (_a = renderablePath.style.stroke) === null || _a === void 0 ? void 0 : _a.width) !== null && _b !== void 0 ? _b : 0;
+        var onlyStroked = strokeWidth > 0 && renderablePath.style.fill.a === 0;
+        // Scale the expanded rect --- the visual equivalent is only close for huge strokes.
+        var expandedRect = visibleRect.grownBy(strokeWidth)
+            .transformedBoundingBox(Mat33_1.default.scaling2D(4, visibleRect.center));
+        // TODO: Handle simplifying very small paths.
+        if (expandedRect.containsRect(path.bbox.grownBy(strokeWidth))) {
+            return renderablePath;
+        }
+        var parts = [];
+        var startPoint = path.startPoint;
+        for (var _i = 0, _c = path.parts; _i < _c.length; _i++) {
+            var part = _c[_i];
+            var partBBox = Path.computeBBoxForSegment(startPoint, part).grownBy(strokeWidth);
+            var endPoint = void 0;
+            if (part.kind === PathCommandType.LineTo || part.kind === PathCommandType.MoveTo) {
+                endPoint = part.point;
+            }
+            else {
+                endPoint = part.endPoint;
+            }
+            var intersectsVisible = partBBox.intersects(visibleRect);
+            if (intersectsVisible) {
+                // TODO: Can we trim parts of paths that intersect the visible rectangle?
+                parts.push(part);
+            }
+            else if (onlyStroked || part.kind === PathCommandType.MoveTo) {
+                // We're stroking (not filling) and the path doesn't intersect the bounding box.
+                // Don't draw it, but preserve the endpoints.
+                parts.push({
+                    kind: PathCommandType.MoveTo,
+                    point: endPoint,
+                });
+            }
+            else {
+                // Otherwise, we may be filling. Try to roughly preserve the filled region.
+                parts.push({
+                    kind: PathCommandType.LineTo,
+                    point: endPoint,
+                });
+            }
+            startPoint = endPoint;
+        }
+        return new Path(path.startPoint, parts).toRenderable(renderablePath.style);
+    };
+    Path.prototype.toString = function (useNonAbsCommands) {
+        if (this.cachedStringVersion) {
+            return this.cachedStringVersion;
+        }
+        if (useNonAbsCommands === undefined) {
+            // Hueristic: Try to determine whether converting absolute to relative commands is worth it.
+            useNonAbsCommands = Math.abs(this.bbox.topLeft.x) > 10 && Math.abs(this.bbox.topLeft.y) > 10;
+        }
+        var result = Path.toString(this.startPoint, this.parts, !useNonAbsCommands);
+        this.cachedStringVersion = result;
+        return result;
+    };
+    Path.prototype.serialize = function () {
+        return this.toString();
+    };
+    // @param onlyAbsCommands - True if we should avoid converting absolute coordinates to relative offsets -- such
+    //   conversions can lead to smaller output strings, but also take time.
+    Path.toString = function (startPoint, parts, onlyAbsCommands) {
+        var _a;
+        var result = [];
+        var prevPoint;
+        var addCommand = function (command) {
+            var points = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                points[_i - 1] = arguments[_i];
+            }
+            var absoluteCommandParts = [];
+            var relativeCommandParts = [];
+            var makeAbsCommand = !prevPoint || onlyAbsCommands;
+            var roundedPrevX = prevPoint ? (0, rounding_1.toRoundedString)(prevPoint.x) : '';
+            var roundedPrevY = prevPoint ? (0, rounding_1.toRoundedString)(prevPoint.y) : '';
+            for (var _a = 0, points_2 = points; _a < points_2.length; _a++) {
+                var point = points_2[_a];
+                var xComponent = (0, rounding_1.toRoundedString)(point.x);
+                var yComponent = (0, rounding_1.toRoundedString)(point.y);
+                // Relative commands are often shorter as strings than absolute commands.
+                if (!makeAbsCommand) {
+                    var xComponentRelative = (0, rounding_1.toStringOfSamePrecision)(point.x - prevPoint.x, xComponent, roundedPrevX, roundedPrevY);
+                    var yComponentRelative = (0, rounding_1.toStringOfSamePrecision)(point.y - prevPoint.y, yComponent, roundedPrevX, roundedPrevY);
+                    // No need for an additional separator if it starts with a '-'
+                    if (yComponentRelative.charAt(0) === '-') {
+                        relativeCommandParts.push("".concat(xComponentRelative).concat(yComponentRelative));
+                    }
+                    else {
+                        relativeCommandParts.push("".concat(xComponentRelative, ",").concat(yComponentRelative));
+                    }
+                }
+                else {
+                    absoluteCommandParts.push("".concat(xComponent, ",").concat(yComponent));
+                }
+            }
+            var commandString;
+            if (makeAbsCommand) {
+                commandString = "".concat(command).concat(absoluteCommandParts.join(' '));
+            }
+            else {
+                commandString = "".concat(command.toLowerCase()).concat(relativeCommandParts.join(' '));
+            }
+            // Don't add no-ops.
+            if (commandString === 'l0,0' || commandString === 'm0,0') {
+                return;
+            }
+            result.push(commandString);
+            if (points.length > 0) {
+                prevPoint = points[points.length - 1];
+            }
+        };
+        // Don't add two moveTos in a row (this can happen if
+        // the start point corresponds to a moveTo _and_ the first command is
+        // also a moveTo)
+        if (((_a = parts[0]) === null || _a === void 0 ? void 0 : _a.kind) !== PathCommandType.MoveTo) {
+            addCommand('M', startPoint);
+        }
+        var exhaustivenessCheck;
+        for (var i = 0; i < parts.length; i++) {
+            var part = parts[i];
+            switch (part.kind) {
+                case PathCommandType.MoveTo:
+                    addCommand('M', part.point);
+                    break;
+                case PathCommandType.LineTo:
+                    addCommand('L', part.point);
+                    break;
+                case PathCommandType.CubicBezierTo:
+                    addCommand('C', part.controlPoint1, part.controlPoint2, part.endPoint);
+                    break;
+                case PathCommandType.QuadraticBezierTo:
+                    addCommand('Q', part.controlPoint, part.endPoint);
+                    break;
+                default:
+                    exhaustivenessCheck = part;
+                    return exhaustivenessCheck;
+            }
+        }
+        return result.join('');
+    };
+    // Create a Path from a SVG path specification.
+    // TODO: Support a larger subset of SVG paths.
+    // TODO: Support `s`,`t` commands shorthands.
+    Path.fromString = function (pathString) {
+        // See the MDN reference:
+        // https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/d
+        // and
+        // https://www.w3.org/TR/SVG2/paths.html
+        var _a;
+        // Remove linebreaks
+        pathString = pathString.split('\n').join(' ');
+        var lastPos = Vec2_1.Vec2.zero;
+        var firstPos = null;
+        var startPos = null;
+        var isFirstCommand = true;
+        var commands = [];
+        var moveTo = function (point) {
+            // The first moveTo/lineTo is already handled by the [startPoint] parameter of the Path constructor.
+            if (isFirstCommand) {
+                isFirstCommand = false;
+                return;
+            }
+            commands.push({
+                kind: PathCommandType.MoveTo,
+                point: point,
+            });
+        };
+        var lineTo = function (point) {
+            if (isFirstCommand) {
+                isFirstCommand = false;
+                return;
+            }
+            commands.push({
+                kind: PathCommandType.LineTo,
+                point: point,
+            });
+        };
+        var cubicBezierTo = function (cp1, cp2, end) {
+            commands.push({
+                kind: PathCommandType.CubicBezierTo,
+                controlPoint1: cp1,
+                controlPoint2: cp2,
+                endPoint: end,
+            });
+        };
+        var quadraticBeierTo = function (controlPoint, endPoint) {
+            commands.push({
+                kind: PathCommandType.QuadraticBezierTo,
+                controlPoint: controlPoint,
+                endPoint: endPoint,
+            });
+        };
+        var commandArgCounts = {
+            'm': 1,
+            'l': 1,
+            'c': 3,
+            'q': 2,
+            'z': 0,
+            'h': 1,
+            'v': 1,
+        };
+        // Each command: Command character followed by anything that isn't a command character
+        var commandExp = /([MZLHVCSQTA])\s*([^MZLHVCSQTA]*)/ig;
+        var current;
+        var _loop_2 = function () {
+            var argParts = current[2].trim().split(/[^0-9Ee.-]/).filter(function (part) { return part.length > 0; }).reduce(function (accumualtor, current) {
+                // As of 09/2022, iOS Safari doesn't support support lookbehind in regular
+                // expressions. As such, we need an alternative.
+                // Because '-' can be used as a path separator, unless preceeded by an 'e' (as in 1e-5),
+                // we need special cases:
+                current = current.replace(/([^eE])[-]/g, '$1 -');
+                var parts = current.split(' -');
+                if (parts[0] !== '') {
+                    accumualtor.push(parts[0]);
+                }
+                accumualtor.push.apply(accumualtor, parts.slice(1).map(function (part) { return "-".concat(part); }));
+                return accumualtor;
+            }, []);
+            var numericArgs = argParts.map(function (arg) { return parseFloat(arg); });
+            var commandChar = current[1].toLowerCase();
+            var uppercaseCommand = current[1] !== commandChar;
+            // Convert commands that don't take points into commands that do.
+            if (commandChar === 'v' || commandChar === 'h') {
+                numericArgs = numericArgs.reduce(function (accumulator, current) {
+                    if (commandChar === 'v') {
+                        return accumulator.concat(uppercaseCommand ? lastPos.x : 0, current);
+                    }
+                    else {
+                        return accumulator.concat(current, uppercaseCommand ? lastPos.y : 0);
+                    }
+                }, []);
+                commandChar = 'l';
+            }
+            else if (commandChar === 'z') {
+                if (firstPos) {
+                    numericArgs = [firstPos.x, firstPos.y];
+                    firstPos = lastPos;
+                }
+                else {
+                    return "continue";
+                }
+                // 'z' always acts like an uppercase lineTo(startPos)
+                uppercaseCommand = true;
+                commandChar = 'l';
+            }
+            var commandArgCount = (_a = commandArgCounts[commandChar]) !== null && _a !== void 0 ? _a : 0;
+            var allArgs = numericArgs.reduce(function (accumulator, current, index, parts) {
+                if (index % 2 !== 0) {
+                    var currentAsFloat = current;
+                    var prevAsFloat = parts[index - 1];
+                    return accumulator.concat(Vec2_1.Vec2.of(prevAsFloat, currentAsFloat));
+                }
+                else {
+                    return accumulator;
+                }
+            }, []).map(function (coordinate, index) {
+                // Lowercase commands are relative, uppercase commands use absolute
+                // positioning
+                var newPos;
+                if (uppercaseCommand) {
+                    newPos = coordinate;
+                }
+                else {
+                    newPos = lastPos.plus(coordinate);
+                }
+                if ((index + 1) % commandArgCount === 0) {
+                    lastPos = newPos;
+                }
+                return newPos;
+            });
+            if (allArgs.length % commandArgCount !== 0) {
+                throw new Error([
+                    "Incorrect number of arguments: got ".concat(JSON.stringify(allArgs), " with a length of ").concat(allArgs.length, " \u2260 ").concat(commandArgCount, "k, k \u2208 \u2124."),
+                    "The number of arguments to ".concat(commandChar, " must be a multiple of ").concat(commandArgCount, "!"),
+                    "Command: ".concat(current[0]),
+                ].join('\n'));
+            }
+            for (var argPos = 0; argPos < allArgs.length; argPos += commandArgCount) {
+                var args = allArgs.slice(argPos, argPos + commandArgCount);
+                switch (commandChar.toLowerCase()) {
+                    case 'm':
+                        if (argPos === 0) {
+                            moveTo(args[0]);
+                        }
+                        else {
+                            lineTo(args[0]);
+                        }
+                        break;
+                    case 'l':
+                        lineTo(args[0]);
+                        break;
+                    case 'c':
+                        cubicBezierTo(args[0], args[1], args[2]);
+                        break;
+                    case 'q':
+                        quadraticBeierTo(args[0], args[1]);
+                        break;
+                    default:
+                        throw new Error("Unknown path command ".concat(commandChar));
+                }
+                isFirstCommand = false;
+            }
+            if (allArgs.length > 0) {
+                firstPos !== null && firstPos !== void 0 ? firstPos : (firstPos = allArgs[0]);
+                startPos !== null && startPos !== void 0 ? startPos : (startPos = firstPos);
+                lastPos = allArgs[allArgs.length - 1];
+            }
+        };
+        while ((current = commandExp.exec(pathString)) !== null) {
+            _loop_2();
+        }
+        var result = new Path(startPos !== null && startPos !== void 0 ? startPos : Vec2_1.Vec2.zero, commands);
+        result.cachedStringVersion = pathString;
+        return result;
+    };
+    Path.empty = new Path(Vec2_1.Vec2.zero, []);
+    return Path;
+}());
+exports.default = Path;