@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/SwiftUI/API/Path.swift

@@ -0,0 +1,543 @@
+// `Path` and `CGAffineTransform`: the outline a custom `Shape` draws in
+// `path(in:)` (Shape.swift), kept as SwiftUI's elements (moves, lines,
+// quadratic and cubic curves, closes). Arcs, ellipses and rounded rectangles
+// are added as cubic curves, as Core Graphics adds them. The page draws a
+// path as SVG path data (`_svg`).
+//
+// `CGAffineTransform` lives here, not in the CoreGraphics module, so that a
+// path can be transformed (`applying(_:)`, the `transform:` arguments);
+// CoreGraphics re-exports it, as it does the geometry types.
+
+#if canImport(WASILibc)
+import WASILibc
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#elseif canImport(Darwin)
+import Darwin
+#endif
+
+// MARK: - Transforms
+
+public struct CGAffineTransform: Equatable, Hashable, Sendable {
+    public var a, b, c, d, tx, ty: CGFloat
+
+    public init(a: CGFloat, b: CGFloat, c: CGFloat, d: CGFloat, tx: CGFloat, ty: CGFloat) {
+        (self.a, self.b, self.c, self.d, self.tx, self.ty) = (a, b, c, d, tx, ty)
+    }
+
+    public init(_ a: CGFloat, _ b: CGFloat, _ c: CGFloat, _ d: CGFloat, _ tx: CGFloat, _ ty: CGFloat) {
+        self.init(a: a, b: b, c: c, d: d, tx: tx, ty: ty)
+    }
+
+    public init() { self.init(a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0) }
+    public init(translationX tx: CGFloat, y ty: CGFloat) { self.init(a: 1, b: 0, c: 0, d: 1, tx: tx, ty: ty) }
+    public init(scaleX sx: CGFloat, y sy: CGFloat) { self.init(a: sx, b: 0, c: 0, d: sy, tx: 0, ty: 0) }
+    public init(rotationAngle angle: CGFloat) {
+        let (s, c) = (sin(angle), cos(angle))
+        self.init(a: c, b: s, c: -s, d: c, tx: 0, ty: 0)
+    }
+
+    public static let identity = CGAffineTransform()
+    public var isIdentity: Bool { self == .identity }
+
+    public func concatenating(_ t: CGAffineTransform) -> CGAffineTransform {
+        CGAffineTransform(a: a * t.a + b * t.c, b: a * t.b + b * t.d,
+                          c: c * t.a + d * t.c, d: c * t.b + d * t.d,
+                          tx: tx * t.a + ty * t.c + t.tx, ty: tx * t.b + ty * t.d + t.ty)
+    }
+
+    public func translatedBy(x: CGFloat, y: CGFloat) -> CGAffineTransform { CGAffineTransform(translationX: x, y: y).concatenating(self) }
+    public func scaledBy(x: CGFloat, y: CGFloat) -> CGAffineTransform { CGAffineTransform(scaleX: x, y: y).concatenating(self) }
+    public func rotated(by angle: CGFloat) -> CGAffineTransform { CGAffineTransform(rotationAngle: angle).concatenating(self) }
+
+    public func inverted() -> CGAffineTransform {
+        let det = a * d - b * c
+        guard det != 0 else { return self }
+        return CGAffineTransform(a: d / det, b: -b / det, c: -c / det, d: a / det,
+                                 tx: (c * ty - d * tx) / det, ty: (b * tx - a * ty) / det)
+    }
+}
+
+extension CGPoint {
+    public func applying(_ t: CGAffineTransform) -> CGPoint {
+        CGPoint(x: t.a * x + t.c * y + t.tx, y: t.b * x + t.d * y + t.ty)
+    }
+}
+
+extension CGSize {
+    public func applying(_ t: CGAffineTransform) -> CGSize {
+        CGSize(width: t.a * width + t.c * height, height: t.b * width + t.d * height)
+    }
+}
+
+extension CGRect {
+    /// The bounding box of the transformed corners.
+    public func applying(_ t: CGAffineTransform) -> CGRect {
+        let corners = [CGPoint(x: minX, y: minY), CGPoint(x: maxX, y: minY), CGPoint(x: minX, y: maxY), CGPoint(x: maxX, y: maxY)].map { $0.applying(t) }
+        let xs = corners.map(\.x), ys = corners.map(\.y)
+        return CGRect(x: xs.min()!, y: ys.min()!, width: xs.max()! - xs.min()!, height: ys.max()! - ys.min()!)
+    }
+}
+
+// MARK: - Path
+
+/// An outline: subpaths of lines and curves.
+public struct Path: Equatable, Sendable {
+    /// One step of a path.
+    public enum Element: Equatable, Sendable {
+        case move(to: CGPoint)
+        case line(to: CGPoint)
+        case quadCurve(to: CGPoint, control: CGPoint)
+        case curve(to: CGPoint, control1: CGPoint, control2: CGPoint)
+        case closeSubpath
+    }
+
+    private(set) var elements: [Element] = []
+    /// Where the current subpath started (a close returns there).
+    private var subpathStart: CGPoint?
+
+    public init() {}
+
+    public init(_ rect: CGRect) {
+        addRect(rect)
+    }
+
+    public init(roundedRect rect: CGRect, cornerRadius: CGFloat, style: RoundedCornerStyle = .continuous) {
+        addRoundedRect(in: rect, cornerSize: CGSize(width: cornerRadius, height: cornerRadius), style: style)
+    }
+
+    public init(roundedRect rect: CGRect, cornerSize: CGSize, style: RoundedCornerStyle = .continuous) {
+        addRoundedRect(in: rect, cornerSize: cornerSize, style: style)
+    }
+
+    public init(roundedRect rect: CGRect, cornerRadii: RectangleCornerRadii, style: RoundedCornerStyle = .continuous) {
+        addRoundedRect(in: rect, cornerRadii: cornerRadii, style: style)
+    }
+
+    public init(ellipseIn rect: CGRect) {
+        addEllipse(in: rect)
+    }
+
+    public init(_ callback: (inout Path) -> Void) {
+        var path = Path()
+        callback(&path)
+        self = path
+    }
+
+    public var isEmpty: Bool { elements.isEmpty }
+
+    /// The last point of the path; nil for an empty one.
+    public var currentPoint: CGPoint? {
+        switch elements.last {
+        case .move(let p)?, .line(let p)?, .quadCurve(let p, _)?, .curve(let p, _, _)?: p
+        case .closeSubpath?: subpathStart
+        case nil: nil
+        }
+    }
+
+    // MARK: Building
+
+    public mutating func move(to point: CGPoint) {
+        elements.append(.move(to: point))
+        subpathStart = point
+    }
+
+    public mutating func addLine(to point: CGPoint) {
+        guard currentPoint != nil else { move(to: point); return }
+        elements.append(.line(to: point))
+    }
+
+    public mutating func addLines(_ points: [CGPoint]) {
+        guard let first = points.first else { return }
+        move(to: first)
+        for point in points.dropFirst() { addLine(to: point) }
+    }
+
+    public mutating func addQuadCurve(to point: CGPoint, control: CGPoint) {
+        guard currentPoint != nil else { move(to: point); return }
+        elements.append(.quadCurve(to: point, control: control))
+    }
+
+    public mutating func addCurve(to point: CGPoint, control1: CGPoint, control2: CGPoint) {
+        guard currentPoint != nil else { move(to: point); return }
+        elements.append(.curve(to: point, control1: control1, control2: control2))
+    }
+
+    public mutating func closeSubpath() {
+        guard let last = elements.last, last != .closeSubpath else { return }
+        elements.append(.closeSubpath)
+    }
+
+    public mutating func addRect(_ rect: CGRect, transform: CGAffineTransform = .identity) {
+        let r = rect.standardized
+        var path = Path()
+        path.move(to: CGPoint(x: r.minX, y: r.minY))
+        path.addLine(to: CGPoint(x: r.maxX, y: r.minY))
+        path.addLine(to: CGPoint(x: r.maxX, y: r.maxY))
+        path.addLine(to: CGPoint(x: r.minX, y: r.maxY))
+        path.closeSubpath()
+        addPath(path, transform: transform)
+    }
+
+    public mutating func addRects(_ rects: [CGRect], transform: CGAffineTransform = .identity) {
+        for rect in rects { addRect(rect, transform: transform) }
+    }
+
+    public mutating func addRoundedRect(in rect: CGRect, cornerSize: CGSize, style: RoundedCornerStyle = .continuous,
+                                        transform: CGAffineTransform = .identity) {
+        let r = rect.standardized
+        let rx = max(0, min(cornerSize.width, r.width / 2))
+        let ry = max(0, min(cornerSize.height, r.height / 2))
+        addRoundedRect(r, radii: [(rx, ry), (rx, ry), (rx, ry), (rx, ry)], transform: transform)
+    }
+
+    public mutating func addRoundedRect(in rect: CGRect, cornerRadii: RectangleCornerRadii, style: RoundedCornerStyle = .continuous,
+                                        transform: CGAffineTransform = .identity) {
+        let r = rect.standardized
+        let limit = min(r.width, r.height) / 2
+        func clamp(_ v: CGFloat) -> (CGFloat, CGFloat) { let v = max(0, min(v, limit)); return (v, v) }
+        // Clockwise from the top leading corner.
+        addRoundedRect(r, radii: [clamp(cornerRadii.topLeading), clamp(cornerRadii.topTrailing),
+                                  clamp(cornerRadii.bottomTrailing), clamp(cornerRadii.bottomLeading)], transform: transform)
+    }
+
+    /// A rectangle with elliptical corners (top leading, top trailing, bottom
+    /// trailing, bottom leading), clockwise from the end of the top leading one.
+    private mutating func addRoundedRect(_ r: CGRect, radii: [(CGFloat, CGFloat)], transform: CGAffineTransform) {
+        let k = Path.kappa
+        let (tl, tr, br, bl) = (radii[0], radii[1], radii[2], radii[3])
+        var path = Path()
+        path.move(to: CGPoint(x: r.minX + tl.0, y: r.minY))
+        path.addLine(to: CGPoint(x: r.maxX - tr.0, y: r.minY))
+        if tr.0 > 0 || tr.1 > 0 {
+            path.addCurve(to: CGPoint(x: r.maxX, y: r.minY + tr.1),
+                          control1: CGPoint(x: r.maxX - tr.0 + tr.0 * k, y: r.minY),
+                          control2: CGPoint(x: r.maxX, y: r.minY + tr.1 - tr.1 * k))
+        }
+        path.addLine(to: CGPoint(x: r.maxX, y: r.maxY - br.1))
+        if br.0 > 0 || br.1 > 0 {
+            path.addCurve(to: CGPoint(x: r.maxX - br.0, y: r.maxY),
+                          control1: CGPoint(x: r.maxX, y: r.maxY - br.1 + br.1 * k),
+                          control2: CGPoint(x: r.maxX - br.0 + br.0 * k, y: r.maxY))
+        }
+        path.addLine(to: CGPoint(x: r.minX + bl.0, y: r.maxY))
+        if bl.0 > 0 || bl.1 > 0 {
+            path.addCurve(to: CGPoint(x: r.minX, y: r.maxY - bl.1),
+                          control1: CGPoint(x: r.minX + bl.0 - bl.0 * k, y: r.maxY),
+                          control2: CGPoint(x: r.minX, y: r.maxY - bl.1 + bl.1 * k))
+        }
+        path.addLine(to: CGPoint(x: r.minX, y: r.minY + tl.1))
+        if tl.0 > 0 || tl.1 > 0 {
+            path.addCurve(to: CGPoint(x: r.minX + tl.0, y: r.minY),
+                          control1: CGPoint(x: r.minX, y: r.minY + tl.1 - tl.1 * k),
+                          control2: CGPoint(x: r.minX + tl.0 - tl.0 * k, y: r.minY))
+        }
+        path.closeSubpath()
+        addPath(path, transform: transform)
+    }
+
+    /// An ellipse, clockwise on screen from its trailing point (3 o'clock).
+    public mutating func addEllipse(in rect: CGRect, transform: CGAffineTransform = .identity) {
+        let r = rect.standardized
+        let (rx, ry) = (r.width / 2, r.height / 2)
+        let (cx, cy) = (r.midX, r.midY)
+        let (ox, oy) = (rx * Path.kappa, ry * Path.kappa)
+        var path = Path()
+        path.move(to: CGPoint(x: r.maxX, y: cy))
+        path.addCurve(to: CGPoint(x: cx, y: r.maxY), control1: CGPoint(x: r.maxX, y: cy + oy), control2: CGPoint(x: cx + ox, y: r.maxY))
+        path.addCurve(to: CGPoint(x: r.minX, y: cy), control1: CGPoint(x: cx - ox, y: r.maxY), control2: CGPoint(x: r.minX, y: cy + oy))
+        path.addCurve(to: CGPoint(x: cx, y: r.minY), control1: CGPoint(x: r.minX, y: cy - oy), control2: CGPoint(x: cx - ox, y: r.minY))
+        path.addCurve(to: CGPoint(x: r.maxX, y: cy), control1: CGPoint(x: cx + ox, y: r.minY), control2: CGPoint(x: r.maxX, y: cy - oy))
+        path.closeSubpath()
+        addPath(path, transform: transform)
+    }
+
+    /// An arc of the circle around `center`, from `startAngle` to
+    /// `endAngle`. Angles turn from the x axis towards the y axis, which is
+    /// down on screen; `clockwise` is as Core Graphics means it in a y-up
+    /// space, so on screen `clockwise: false` turns clockwise (SwiftUI's
+    /// well-known inversion). A line joins the current point to the start.
+    public mutating func addArc(center: CGPoint, radius: CGFloat, startAngle: Angle, endAngle: Angle, clockwise: Bool,
+                                transform: CGAffineTransform = .identity) {
+        let full = 2 * CGFloat.pi
+        var delta = endAngle.radians - startAngle.radians
+        if clockwise {
+            if delta <= -full { delta = -full } else if delta > 0 {
+                delta = delta.truncatingRemainder(dividingBy: full)
+                if delta > 0 { delta -= full }
+            }
+        } else {
+            if delta >= full { delta = full } else if delta < 0 {
+                delta = delta.truncatingRemainder(dividingBy: full)
+                if delta < 0 { delta += full }
+            }
+        }
+        addRelativeArc(center: center, radius: radius, startAngle: startAngle, delta: Angle(radians: delta), transform: transform)
+    }
+
+    /// An arc of `delta` from `startAngle` (positive: clockwise on screen).
+    public mutating func addRelativeArc(center: CGPoint, radius: CGFloat, startAngle: Angle, delta: Angle,
+                                        transform: CGAffineTransform = .identity) {
+        let start = startAngle.radians
+        let sweep = delta.radians
+        func point(_ angle: CGFloat) -> CGPoint {
+            CGPoint(x: center.x + radius * cos(angle), y: center.y + radius * sin(angle)).applying(transform)
+        }
+        let first = point(start)
+        if currentPoint == nil { move(to: first) } else { addLine(to: first) }
+        guard sweep != 0, radius > 0 else { return }
+        let segments = max(1, Int((abs(sweep) / (CGFloat.pi / 2)).rounded(.up)))
+        let step = sweep / CGFloat(segments)
+        let k = 4 / 3 * tan(step / 4)
+        var angle = start
+        for _ in 0..<segments {
+            let next = angle + step
+            let (c0, s0, c1, s1) = (cos(angle), sin(angle), cos(next), sin(next))
+            let control1 = CGPoint(x: center.x + radius * (c0 - k * s0), y: center.y + radius * (s0 + k * c0))
+            let control2 = CGPoint(x: center.x + radius * (c1 + k * s1), y: center.y + radius * (s1 - k * c1))
+            elements.append(.curve(to: point(next), control1: control1.applying(transform), control2: control2.applying(transform)))
+            angle = next
+        }
+    }
+
+    /// The arc of `radius` tangent to the lines from the current point to
+    /// `tangent1End` and from there to `tangent2End`.
+    public mutating func addArc(tangent1End: CGPoint, tangent2End: CGPoint, radius: CGFloat,
+                                transform: CGAffineTransform = .identity) {
+        guard let current = currentPoint?.applying(transform.inverted()) else {
+            move(to: tangent1End.applying(transform))
+            return
+        }
+        let (p0, p1, p2) = (current, tangent1End, tangent2End)
+        let v1 = CGPoint(x: p0.x - p1.x, y: p0.y - p1.y), v2 = CGPoint(x: p2.x - p1.x, y: p2.y - p1.y)
+        let l1 = (v1.x * v1.x + v1.y * v1.y).squareRoot(), l2 = (v2.x * v2.x + v2.y * v2.y).squareRoot()
+        let cross = v1.x * v2.y - v1.y * v2.x
+        guard l1 > 0, l2 > 0, abs(cross) > 1e-9, radius > 0 else {
+            addLine(to: p1.applying(transform))
+            return
+        }
+        let angle = acos(max(-1, min(1, (v1.x * v2.x + v1.y * v2.y) / (l1 * l2))))
+        let distance = radius / tan(angle / 2)
+        let t1 = CGPoint(x: p1.x + v1.x / l1 * distance, y: p1.y + v1.y / l1 * distance)
+        let t2 = CGPoint(x: p1.x + v2.x / l2 * distance, y: p1.y + v2.y / l2 * distance)
+        // The center lies along the bisector, `radius` from both tangent points.
+        let bisector = CGPoint(x: v1.x / l1 + v2.x / l2, y: v1.y / l1 + v2.y / l2)
+        let bl = (bisector.x * bisector.x + bisector.y * bisector.y).squareRoot()
+        let centerDistance = (distance * distance + radius * radius).squareRoot()
+        let center = CGPoint(x: p1.x + bisector.x / bl * centerDistance, y: p1.y + bisector.y / bl * centerDistance)
+        let a1 = atan2(t1.y - center.y, t1.x - center.x)
+        let a2 = atan2(t2.y - center.y, t2.x - center.x)
+        var sweep = a2 - a1
+        while sweep > CGFloat.pi { sweep -= 2 * CGFloat.pi }
+        while sweep < -CGFloat.pi { sweep += 2 * CGFloat.pi }
+        addLine(to: t1.applying(transform))
+        addRelativeArc(center: center, radius: radius, startAngle: Angle(radians: a1), delta: Angle(radians: sweep), transform: transform)
+    }
+
+    public mutating func addPath(_ path: Path, transform: CGAffineTransform = .identity) {
+        for element in path.applying(transform).elements {
+            switch element {
+            case .move(let p): move(to: p)
+            case .line(let p): elements.append(.line(to: p))
+            case .quadCurve(let p, let c): elements.append(.quadCurve(to: p, control: c))
+            case .curve(let p, let c1, let c2): elements.append(.curve(to: p, control1: c1, control2: c2))
+            case .closeSubpath: closeSubpath()
+            }
+        }
+    }
+
+    // MARK: Reading
+
+    public func forEach(_ body: (Element) -> Void) {
+        elements.forEach(body)
+    }
+
+    public func applying(_ transform: CGAffineTransform) -> Path {
+        guard !transform.isIdentity else { return self }
+        var path = Path()
+        path.elements = elements.map { element in
+            switch element {
+            case .move(let p): .move(to: p.applying(transform))
+            case .line(let p): .line(to: p.applying(transform))
+            case .quadCurve(let p, let c): .quadCurve(to: p.applying(transform), control: c.applying(transform))
+            case .curve(let p, let c1, let c2): .curve(to: p.applying(transform), control1: c1.applying(transform), control2: c2.applying(transform))
+            case .closeSubpath: .closeSubpath
+            }
+        }
+        path.subpathStart = subpathStart?.applying(transform)
+        return path
+    }
+
+    public func offsetBy(dx: CGFloat, dy: CGFloat) -> Path {
+        applying(CGAffineTransform(translationX: dx, y: dy))
+    }
+
+    /// The smallest rectangle around the path's outline (curves included,
+    /// their control points not).
+    public var boundingRect: CGRect {
+        let points = polylines().flatMap(\.points)
+        guard let first = points.first else { return .zero }
+        var (minX, minY, maxX, maxY) = (first.x, first.y, first.x, first.y)
+        for p in points {
+            minX = min(minX, p.x); minY = min(minY, p.y)
+            maxX = max(maxX, p.x); maxY = max(maxY, p.y)
+        }
+        return CGRect(x: minX, y: minY, width: maxX - minX, height: maxY - minY)
+    }
+
+    /// Whether `point` is inside the path filled with the non-zero winding
+    /// rule, or the even-odd rule with `eoFill`.
+    public func contains(_ point: CGPoint, eoFill: Bool = false) -> Bool {
+        var winding = 0
+        for line in polylines() {
+            var points = line.points
+            if let first = points.first, points.last != first { points.append(first) }
+            for (a, b) in zip(points, points.dropFirst()) where (a.y <= point.y) != (b.y <= point.y) {
+                let x = a.x + (point.y - a.y) / (b.y - a.y) * (b.x - a.x)
+                if x > point.x { winding += b.y > a.y ? 1 : -1 }
+            }
+        }
+        return eoFill ? winding % 2 != 0 : winding != 0
+    }
+
+    /// The part of the outline between two fractions of its length (curves
+    /// are kept as the short lines they flatten to).
+    public func trimmedPath(from: CGFloat, to: CGFloat) -> Path {
+        let from = max(0, min(1, from)), to = max(0, min(1, to))
+        guard to > from else { return Path() }
+        if from == 0 && to == 1 { return self }
+        let lines = polylines().map { line -> [CGPoint] in
+            line.closed && line.points.first != line.points.last ? line.points + [line.points[0]] : line.points
+        }
+        var total: CGFloat = 0
+        for points in lines { for (a, b) in zip(points, points.dropFirst()) { total += a.distance(to: b) } }
+        guard total > 0 else { return Path() }
+        let (start, end) = (from * total, to * total)
+        var result = Path()
+        var travelled: CGFloat = 0
+        for points in lines {
+            var drawing = false
+            for (a, b) in zip(points, points.dropFirst()) {
+                let length = a.distance(to: b)
+                let (s, e) = (travelled, travelled + length)
+                travelled = e
+                guard e > start, s < end, length > 0 else { continue }
+                let p = a.interpolated(to: b, amount: max(0, (start - s) / length))
+                let q = b == a ? b : a.interpolated(to: b, amount: min(1, (end - s) / length))
+                if !drawing { result.move(to: p); drawing = true }
+                result.addLine(to: q)
+            }
+        }
+        return result
+    }
+
+    /// The subpaths flattened to points (curves in short lines).
+    private func polylines() -> [(points: [CGPoint], closed: Bool)] {
+        var lines: [(points: [CGPoint], closed: Bool)] = []
+        var points: [CGPoint] = []
+        func finish(closed: Bool) {
+            if !points.isEmpty { lines.append((points, closed)) }
+            points = []
+        }
+        for element in elements {
+            switch element {
+            case .move(let p):
+                finish(closed: false)
+                points = [p]
+            case .line(let p):
+                points.append(p)
+            case .quadCurve(let p, let c):
+                let p0 = points.last ?? p
+                for i in 1...16 {
+                    let t = CGFloat(i) / 16, u = 1 - t
+                    points.append(CGPoint(x: u * u * p0.x + 2 * u * t * c.x + t * t * p.x,
+                                          y: u * u * p0.y + 2 * u * t * c.y + t * t * p.y))
+                }
+            case .curve(let p, let c1, let c2):
+                let p0 = points.last ?? p
+                for i in 1...16 {
+                    let t = CGFloat(i) / 16, u = 1 - t
+                    let (a, b, c, d) = (u * u * u, 3 * u * u * t, 3 * u * t * t, t * t * t)
+                    points.append(CGPoint(x: a * p0.x + b * c1.x + c * c2.x + d * p.x,
+                                          y: a * p0.y + b * c1.y + c * c2.y + d * p.y))
+                }
+            case .closeSubpath:
+                let start = points.first
+                finish(closed: true)
+                if let start { points = [start] }
+            }
+        }
+        finish(closed: false)
+        return lines.filter { $0.points.count > 1 || $0.closed }
+    }
+
+    /// The control point distance of a quarter circle drawn as a cubic curve.
+    static let kappa: CGFloat = 0.5522847498307936
+
+    /// The path as SVG path data, in points rounded to hundredths.
+    var _svg: String {
+        var out = ""
+        func add(_ command: Character, _ points: CGPoint...) {
+            out.append(command)
+            var first = true
+            for p in points {
+                if !first { out.append(" ") }
+                out += Path.number(p.x) + " " + Path.number(p.y)
+                first = false
+            }
+        }
+        for element in elements {
+            switch element {
+            case .move(let p): add("M", p)
+            case .line(let p): add("L", p)
+            case .quadCurve(let p, let c): add("Q", c, p)
+            case .curve(let p, let c1, let c2): add("C", c1, c2, p)
+            case .closeSubpath: out.append("Z")
+            }
+        }
+        return out
+    }
+
+    static func number(_ value: CGFloat) -> String {
+        guard value.isFinite else { return "0" }
+        let rounded = (value * 100).rounded() / 100
+        if rounded == 0 { return "0" }
+        if rounded == rounded.rounded() { return String(Int(rounded)) }
+        return String(rounded)
+    }
+}
+
+extension Path: CustomStringConvertible {
+    /// Core Graphics' textual form (`x y m`, `x y l`, `cx cy x y q`, `c1 c2 p c`, `h`).
+    public var description: String {
+        elements.map { element in
+            func n(_ p: CGPoint) -> String { Path.number(p.x) + " " + Path.number(p.y) }
+            switch element {
+            case .move(let p): return n(p) + " m"
+            case .line(let p): return n(p) + " l"
+            case .quadCurve(let p, let c): return n(c) + " " + n(p) + " q"
+            case .curve(let p, let c1, let c2): return n(c1) + " " + n(c2) + " " + n(p) + " c"
+            case .closeSubpath: return "h"
+            }
+        }.joined(separator: " ")
+    }
+}
+
+extension CGRect {
+    /// The rectangle with a positive width and height.
+    public var standardized: CGRect {
+        CGRect(x: min(minX, maxX), y: min(minY, maxY), width: abs(width), height: abs(height))
+    }
+}
+
+extension CGPoint {
+    fileprivate func distance(to other: CGPoint) -> CGFloat {
+        ((other.x - x) * (other.x - x) + (other.y - y) * (other.y - y)).squareRoot()
+    }
+
+    fileprivate func interpolated(to other: CGPoint, amount: CGFloat) -> CGPoint {
+        CGPoint(x: x + (other.x - x) * amount, y: y + (other.y - y) * amount)
+    }
+}