         return type(of: self).init(points: resultPoints, orders: resultOrders)
     }
 
+    public func split(range: PathComponentRange) -> Self {
+        let reverse = range.end < range.start
+        let result = self.split(standardizedRange: range.standardized)
+        return reverse ? result.reversed() : result
+    }
+
+    public func split(from start: IndexedPathComponentLocation, to end: IndexedPathComponentLocation) -> Self {
+        return self.split(range: PathComponentRange(start: start, end: end))
+    }
+
     open func reversed() -> Self {
         return type(of: self).init(points: self.points.reversed(), orders: self.orders.reversed())
     }

public struct PathComponentIntersection {
    let indexedComponentLocation1, indexedComponentLocation2: IndexedPathComponentLocation
}

        }
    }

    open func split(standardizedRange range: PathComponentRange) -> Self {
        assert(range.isStandardized)

        guard !self.isPoint else { return self }

        let start = range.start
        let end   = range.end

        var resultPoints = [CGPoint]()
        var resultOrders = [Int]()

        func appendElement(_ index: Int, _ start: CGFloat, _ end: CGFloat, includeStart: Bool, includeEnd: Bool) {
            assert(includeStart || includeEnd)
            let element = self.element(at: index).split(from: start, to: end)
            let startIndex  = includeStart ? 0 : 1
            let endIndex    = includeEnd ? element.order : element.order - 1
            resultPoints    += element.points[startIndex...endIndex]
            resultOrders.append(self.orders[index])
        }

