             
             let t = Double(_t) / Double(degree)
             
-            guard let q0 = _offset_point(s) else { continue }
-            guard let q3 = _offset_point(t) else { continue }
-            
-            let d0 = (q0 - self.eval(s)).unit * SDTransform.rotate(signed ? -0.5 * .pi : 0.5 * .pi)
-            let d3 = (q3 - self.eval(t)).unit * SDTransform.rotate(signed ? -0.5 * .pi : 0.5 * .pi)
-            
-            guard let m0 = _offset_point(0.25 * (t - s) + s) else { continue }
-            guard let m1 = _offset_point(0.5 * (t - s) + s) else { continue }
-            guard let m2 = _offset_point(0.75 * (t - s) + s) else { continue }
+            guard let (u0, v0) = _offset_point(s) else { continue }
+            guard let (u1, v1) = _offset_point(t) else { continue }
+            
+            let q0 = u0 + v0
+            let q3 = u1 + v1
+            
+            let d0 = v0.unit * SDTransform.rotate(signed ? -0.5 * .pi : 0.5 * .pi)
+            let d3 = v1.unit * SDTransform.rotate(signed ? -0.5 * .pi : 0.5 * .pi)
+            
+            guard let m0 = _offset_point(0.25 * (t - s) + s).map({ $0 + $1 }) else { continue }
+            guard let m1 = _offset_point(0.5 * (t - s) + s).map({ $0 + $1 }) else { continue }
+            guard let m2 = _offset_point(0.75 * (t - s) + s).map({ $0 + $1 }) else { continue }
             
             if let curve = CubicBezierFitting(q0, q3, d0, -d3, [(0.25, m0), (0.5, m1), (0.75, m2)]) {
                 try calback(s...t, curve)

            return
        }
        
        guard let q0 = _offset_point(s) else { return }
        guard let q3 = _offset_point(t) else { return }
        
        let d0 = (q0 - self.eval(s)).unit * SDTransform.rotate(signed ? -0.5 * .pi : 0.5 * .pi)
        let d3 = (q3 - self.eval(t)).unit * SDTransform.rotate(signed ? -0.5 * .pi : 0.5 * .pi)
        
        let angle = (d3.phase - d0.phase).remainder(dividingBy: 2 * .pi)
        
        if abs(angle) > 0.25 * .pi {
            
            let center = self.eval(0.5 * (s + t))
            guard var a = _offset_point(0.5 * (s + t))?.distance(to: center) else { return }
            if signed { a = -a }
            
            let arc = BezierArc(angle).map { a * $0 * SDTransform.rotate(d0.phase - 0.5 * .pi) + center }

    }
    
    @inlinable
    func _offset2(_ signed: Bool, _ _offset_point: (Double) -> (Point, Point)?, _ range: ClosedRange<Double>, _ limit: Int, _ calback: (ClosedRange<Double>, CubicBezier<Point>) throws -> Void) rethrows {
        
        let s = range.lowerBound
        let t = range.upperBound
