     /// - Parameters:
     ///   - center: The point the rotation will be applied around.
     ///   - angle: The rotation's angle in radians.
-    @inlinable
-    func rotated(relativeTo center: CGPoint, by angle: CGFloat) -> CGRect {
+    @inlinable func rotated(relativeTo center: CGPoint, by angle: CGFloat) -> CGRect {
         var transform = CGAffineTransform(translationX: center.x, y: center.y)
         transform = transform.rotated(by: angle)
         transform = transform.translatedBy(x: -center.x, y: -center.y)
-        return self.applying(transform)
+        return applying(transform)
     }
     
     /// Rotates `self` around the given point by the given angle.

public extension CGRect {
    
    /// Returns a copy of `self` translated by the given vector.
    @inlinable
    func translated(by vector: CGVector) -> CGRect {
        CGRect(origin: self.origin.translated(along: vector), size: self.size)
    }
    
    /// Returns a copy of `self` translated by `(tx,ty)`.
    @inlinable
    func translated<I: BinaryInteger>(byTx tx: I, ty: I) -> CGRect {
        self.translated(byTx: CGFloat(tx), ty: CGFloat(ty))
    }
    
    /// Returns a copy of `self` translated by `(tx,ty)`.
    @inlinable
    func translated<F: BinaryFloatingPoint>(byTx tx: F, ty: F) -> CGRect {
        self.translated(byTx: CGFloat(tx), ty: CGFloat(ty))
    }
    
    /// Returns a copy of `self` translated by `(tx,ty)`.
    @inlinable
    func translated(byTx tx: CGFloat, ty: CGFloat) -> CGRect {
        CGRect(origin: self.origin.translated(tx: tx, ty: ty), size: self.size)
    }

    /// Translate `self` by the given vector.
    @inlinable
    mutating func translate(along vector: CGVector) {
        self = self.translated(by: vector)
    }

    /// Translate `self` by `(tx,ty)`.
    @inlinable
    mutating func translate<I: BinaryInteger>(tx: I, ty: I) {
        self = self.translated(byTx: tx, ty: ty)
    }
    
    /// Translate `self` by `(tx,ty)`.
    @inlinable
    mutating func translate<F: BinaryFloatingPoint>(tx: F, ty: F) {
        self = self.translated(byTx: tx, ty: ty)
    }
    
    /// Translate `self` by `(tx,ty)`.
    @inlinable
    mutating func translate(tx: CGFloat, ty: CGFloat) {
        self = self.translated(byTx: tx, ty: ty)
    }
    
    /// Returns a copy of `self` rotated around the given point by the given angle.

    }
}

public extension CGRect {
    /// The receiver's SIMD representation.
    @inlinable var simd4: SIMD4<CGFloat.NativeType> {
        get { .init(origin.x.native, origin.y.native, size.width.native, size.height.native) }
        set { (origin.simd2, size.simd2) = (newValue.lowHalf, newValue.highHalf) }
    }
    
    @inlinable init(simd4: SIMD4<CGFloat.NativeType>) {
        self.init(x: simd4.x, y: simd4.y, width: simd4.z, height: simd4.w)
    }
}

// MARK: -
// MARK: Corners
public extension CGRect {
    
    /// A point representing the rectangle's center.
    @inlinable var center: CGPoint {
        get { .init(x: midX, y: midY) }
        set { origin.simd2 = newValue.simd2 - (size.simd2 / 2) }
    }
    
    @inlinable subscript(xBound: RectBoundary = .mid, yBound: RectBoundary = .mid) -> CGPoint {
        get {
            let x, y: CGFloat
            
            switch xBound {
            case .min: x = minX
            case .mid: x = midX
            case .max: x = maxX
            }
            
            switch yBound {
            case .min: y = minY
            case .mid: y = midY
            case .max: y = maxY
            }
            
            return .init(x: x, y: y)
        }
        set {
            origin.simd2 += newValue.simd2 - self[xBound, yBound].simd2
        }
    }
}
