         return self.width / self.height
     }
 
-    func proportionalSize(for imageSize: CGSize, precision: PrecisionScheme) -> CGSize {
+    func proportionalSize(for imageSize: CGSize, precision: PrecisionScheme = .defaultPrecisionScheme) -> CGSize {
         let maximumDimension = CGFloat(maximumPixelSize(forImageSize: imageSize))
         let ratio = imageSize.aspectRatio
-        if ratio > 1.0 {
+        if ratio.isLandscape {
             return CGSize(width: precision.applied(to: maximumDimension), height: precision.applied(to: maximumDimension / ratio))
         } else {
             return CGSize(width: precision.applied(to: ratio * maximumDimension), height: precision.applied(to: maximumDimension))

    static var unconstrained: CGFloat {
        infinity
    }
}

public extension CGSize {

        let ratio = imageSize.aspectRatio

        if widthIsUnconstrained && heightIsUnconstrained {
            if ratio.isLandscape {
                return Int(PrecisionScheme.imageIOMaxPixelSizePrecisionScheme.applied(to: imageSize.width))
            }
            return Int(PrecisionScheme.imageIOMaxPixelSizePrecisionScheme.applied(to: imageSize.height))

        } else if widthIsUnconstrained {
            if ratio.isLandscape {
                return Int(imageSize.proportionalWidth(
                    forHeight: self.height, precision: .imageIOMaxPixelSizePrecisionScheme
                ))
            }
            return Int(PrecisionScheme.imageIOMaxPixelSizePrecisionScheme.applied(to: self.height))

        } else if heightIsUnconstrained {
            if ratio.isLandscape {
                return Int(PrecisionScheme.imageIOMaxPixelSizePrecisionScheme.applied(to: self.width))
            }
            return Int(imageSize.proportionalHeight(forWidth: self.width, precision: .imageIOMaxPixelSizePrecisionScheme))
        }

        return Int(round(min(self.width, self.height)))
