js-draw 0.25.0 → 1.0.0

package/dist/mjs/math/shapes/Path.mjs

@@ -1,862 +0,0 @@
-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));
-};
-import  { toRoundedString, toStringOfSamePrecision }  from '../rounding.mjs';
-import  LineSegment2  from './LineSegment2.mjs';
-import  Mat33  from '../Mat33.mjs';
-import  Rect2  from './Rect2.mjs';
-import  { Vec2 }  from '../Vec2.mjs';
-import  CubicBezier  from './CubicBezier.mjs';
-import  QuadraticBezier  from './QuadraticBezier.mjs';
-import  PointShape2D  from './PointShape2D.mjs';
-export 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 || (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.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.union.apply(Rect2, 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(startPoint, part.controlPoint1, part.controlPoint2, part.endPoint));
-                        startPoint = part.endPoint;
-                        break;
-                    case PathCommandType.QuadraticBezierTo:
-                        geometry.push(new QuadraticBezier(startPoint, part.controlPoint, part.endPoint));
-                        startPoint = part.endPoint;
-                        break;
-                    case PathCommandType.LineTo:
-                        geometry.push(new LineSegment2(startPoint, part.point));
-                        startPoint = part.point;
-                        break;
-                    case PathCommandType.MoveTo:
-                        geometry.push(new PointShape2D(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(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.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.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(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.of(lineWidth, lineWidth).times(0.5);
-            var innerRect = Rect2.fromCorners(rect.topLeft.plus(cornerToEdge), rect.bottomRight.minus(cornerToEdge));
-            var outerRect = Rect2.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.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 ? toRoundedString(prevPoint.x) : '';
-            var roundedPrevY = prevPoint ? toRoundedString(prevPoint.y) : '';
-            for (var _a = 0, points_2 = points; _a < points_2.length; _a++) {
-                var point = points_2[_a];
-                var xComponent = toRoundedString(point.x);
-                var yComponent = toRoundedString(point.y);
-                // Relative commands are often shorter as strings than absolute commands.
-                if (!makeAbsCommand) {
-                    var xComponentRelative = toStringOfSamePrecision(point.x - prevPoint.x, xComponent, roundedPrevX, roundedPrevY);
-                    var yComponentRelative = 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.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.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.zero, commands);
-        result.cachedStringVersion = pathString;
-        return result;
-    };
-    Path.empty = new Path(Vec2.zero, []);
-    return Path;
-}());
-export default Path;