lottie-ios 3.4.0 → 3.4.3

package/Sources/Private/MainThread/NodeRenderSystem/Extensions/ItemsExtension.swift

@@ -19,7 +19,6 @@ final class NodeTree {
 
 extension Array where Element == ShapeItem {
   func initializeNodeTree() -> NodeTree {
-
     let nodeTree = NodeTree()
 
     for item in self {
@@ -73,7 +72,6 @@ extension Array where Element == ShapeItem {
         nodeTree.transform = xform
         continue
       } else if let group = item as? Group {
-
         let tree = group.items.initializeNodeTree()
         let node = GroupNode(name: group.name, parentNode: nodeTree.rootNode, tree: tree)
         nodeTree.rootNode = node
@@ -81,6 +79,11 @@ extension Array where Element == ShapeItem {
         /// Now add all child paths to current tree
         nodeTree.paths.append(contentsOf: tree.paths)
         nodeTree.renderContainers.append(node.container)
+      } else if item is Repeater {
+        LottieLogger.shared.assertionFailure("""
+          The Main Thread rendering engine doesn't currently support repeaters.
+          To play an animation with repeaters, you can use the Core Animation rendering engine instead.
+          """)
       }
 
       if let pathNode = nodeTree.rootNode as? PathNode {

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/ModifierNodes/TrimPathNode.swift

@@ -142,7 +142,6 @@ final class TrimPathNode: AnimatorNode {
 
     /// Now loop through all path containers
     for pathContainer in upstreamPaths {
-
       let pathEnd = pathStart + pathContainer.totalLength
 
       if
@@ -214,11 +213,10 @@ final class TrimPathNode: AnimatorNode {
         let subpaths = pathContainer.removePaths(updateFrame: frame)
         var subpathStart: CGFloat = 0
         for path in subpaths {
-
           let subpathEnd = subpathStart + path.length
 
           if
-            !startCutLength.isInRange(subpathStart, subpathEnd) &&
+            !startCutLength.isInRange(subpathStart, subpathEnd),
             !endCutLength.isInRange(subpathStart, subpathEnd)
           {
             // The whole path is included. Add
@@ -226,7 +224,7 @@ final class TrimPathNode: AnimatorNode {
             pathContainer.appendPath(path, updateFrame: frame)
 
           } else if
-            startCutLength.isInRange(subpathStart, subpathEnd) &&
+            startCutLength.isInRange(subpathStart, subpathEnd),
             !endCutLength.isInRange(subpathStart, subpathEnd)
           {
             /// The start of the path needs to be trimmed
@@ -235,7 +233,7 @@ final class TrimPathNode: AnimatorNode {
             let newPath = path.trim(fromPosition: cutLength / path.length, toPosition: 1, offset: 0, trimSimultaneously: false)
             pathContainer.appendPath(newPath, updateFrame: frame)
           } else if
-            !startCutLength.isInRange(subpathStart, subpathEnd) &&
+            !startCutLength.isInRange(subpathStart, subpathEnd),
             endCutLength.isInRange(subpathStart, subpathEnd)
           {
             // S|=======E----------------------|
@@ -244,7 +242,7 @@ final class TrimPathNode: AnimatorNode {
             pathContainer.appendPath(newPath, updateFrame: frame)
             break
           } else if
-            startCutLength.isInRange(subpathStart, subpathEnd) &&
+            startCutLength.isInRange(subpathStart, subpathEnd),
             endCutLength.isInRange(subpathStart, subpathEnd)
           {
             //  |-------S============E---------|
@@ -272,7 +270,6 @@ final class TrimPathNode: AnimatorNode {
 
       pathStart = pathEnd
     }
-
   }
 
   // MARK: Fileprivate

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/Renderables/GradientFillRenderer.swift

@@ -198,6 +198,11 @@ final class GradientFillRenderer: PassThroughOutputNode, Renderable {
     }
   }
 
+  var fillRule: CAShapeLayerFillRule {
+    get { maskLayer.fillRule }
+    set { maskLayer.fillRule = newValue }
+  }
+
   func render(_: CGContext) {
     // do nothing
   }

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/Renderables/GradientStrokeRenderer.swift

@@ -42,7 +42,7 @@ final class GradientStrokeRenderer: PassThroughOutputNode, Renderable {
   }
 
   func render(_ inContext: CGContext) {
-    guard inContext.path != nil && inContext.path!.isEmpty == false else {
+    guard inContext.path != nil, inContext.path!.isEmpty == false else {
       return
     }
 
@@ -56,7 +56,6 @@ final class GradientStrokeRenderer: PassThroughOutputNode, Renderable {
 
     /// Now draw the gradient.
     gradientRender.render(inContext)
-
   }
 
   func renderBoundsFor(_ boundingBox: CGRect) -> CGRect {

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/Renderables/LegacyGradientFillRenderer.swift

@@ -58,7 +58,7 @@ final class LegacyGradientFillRenderer: PassThroughOutputNode, Renderable {
   }
 
   func render(_ inContext: CGContext) {
-    guard inContext.path != nil && inContext.path!.isEmpty == false else {
+    guard inContext.path != nil, inContext.path!.isEmpty == false else {
       return
     }
     hasUpdate = false

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/Renderables/StrokeRenderer.swift

@@ -140,7 +140,7 @@ final class StrokeRenderer: PassThroughOutputNode, Renderable {
   }
 
   func render(_ inContext: CGContext) {
-    guard inContext.path != nil && inContext.path!.isEmpty == false else {
+    guard inContext.path != nil, inContext.path!.isEmpty == false else {
       return
     }
     guard let color = color else { return }

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/PathNodes/RectNode.swift

@@ -171,7 +171,7 @@ extension BezierPath {
         CurveVertex(
           CGPoint(x: 0, y: radius), // In tangent
           CGPoint(x: 0, y: radius), // Point
-          CGPoint(x: -controlPoint, y: radius))// Out tangent
+          CGPoint(x: -controlPoint, y: radius)) // Out tangent
           .translated(CGPoint(x: radius, y: -radius))
           .translated(CGPoint(x: -size.width, y: size.height))
           .translated(position),

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/PathNodes/StarNode.swift

@@ -158,17 +158,17 @@ extension BezierPath {
     for i in 0..<numPoints {
       var radius = longSegment ? outerRadius : innerRadius
       var dTheta = halfAnglePerPoint
-      if partialPointRadius != 0 && i == numPoints - 2 {
+      if partialPointRadius != 0, i == numPoints - 2 {
         dTheta = anglePerPoint * partialPointAmount / 2
       }
-      if partialPointRadius != 0 && i == numPoints - 1 {
+      if partialPointRadius != 0, i == numPoints - 1 {
         radius = partialPointRadius
       }
       previousPoint = point
       point.x = (radius * cos(currentAngle))
       point.y = (radius * sin(currentAngle))
 
-      if innerRoundedness == 0 && outerRoundedness == 0 {
+      if innerRoundedness == 0, outerRoundedness == 0 {
         vertices.append(CurveVertex(point: point + position, inTangentRelative: .zero, outTangentRelative: .zero))
       } else {
         let cp1Theta = (atan2(previousPoint.y, previousPoint.x) - CGFloat.pi / 2)

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/RenderNodes/GradientFillNode.swift

@@ -22,6 +22,7 @@ final class GradientFillProperties: NodePropertyMap, KeypathSearchable {
     colors = NodeProperty(provider: KeyframeInterpolator(keyframes: gradientfill.colors.keyframes))
     gradientType = gradientfill.gradientType
     numberOfColors = gradientfill.numberOfColors
+    fillRule = gradientfill.fillRule
     keypathProperties = [
       "Opacity" : opacity,
       "Start Point" : startPoint,
@@ -42,6 +43,7 @@ final class GradientFillProperties: NodePropertyMap, KeypathSearchable {
 
   let gradientType: GradientType
   let numberOfColors: Int
+  let fillRule: FillRule
 
   let keypathProperties: [String: AnyNodeProperty]
   let properties: [AnyNodeProperty]
@@ -98,5 +100,6 @@ final class GradientFillNode: AnimatorNode, RenderNode {
     fillRender.colors = fillProperties.colors.value.map { CGFloat($0) }
     fillRender.type = fillProperties.gradientType
     fillRender.numberOfColors = fillProperties.numberOfColors
+    fillRender.fillRule = fillProperties.fillRule.caFillRule
   }
 }

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/RenderNodes/GradientStrokeNode.swift

@@ -140,7 +140,7 @@ final class GradientStrokeNode: AnimatorNode, RenderNode {
 
     /// Get dash lengths
     let dashLengths = strokeProperties.dashPattern.value.map { $0.cgFloatValue }
-    if dashLengths.count > 0 {
+    if dashLengths.count > 0, dashLengths.isSupportedLayerDashPattern {
       strokeRender.strokeRender.dashPhase = strokeProperties.dashPhase.value.cgFloatValue
       strokeRender.strokeRender.dashLengths = dashLengths
     } else {

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/RenderNodes/StrokeNode.swift

@@ -118,7 +118,7 @@ final class StrokeNode: AnimatorNode, RenderNode {
 
     /// Get dash lengths
     let dashLengths = strokeProperties.dashPattern.value.map { $0.cgFloatValue }
-    if dashLengths.count > 0 {
+    if dashLengths.count > 0, dashLengths.isSupportedLayerDashPattern {
       strokeRender.dashPhase = strokeProperties.dashPhase.value.cgFloatValue
       strokeRender.dashLengths = dashLengths
     } else {
@@ -148,6 +148,33 @@ extension Array where Element == DashElement {
         dashPatterns.append(dash.value.keyframes)
       }
     }
+
+    dashPatterns = ContiguousArray(dashPatterns.map { pattern in
+      ContiguousArray(pattern.map { keyframe -> Keyframe<Vector1D> in
+        // The recommended way to create a stroke of round dots, in theory,
+        // is to use a value of 0 followed by the stroke width, but for
+        // some reason Core Animation incorrectly (?) renders these as pills
+        // instead of circles. As a workaround, for parity with Lottie on other
+        // platforms, we can change `0`s to `0.01`: https://stackoverflow.com/a/38036486
+        if keyframe.value.cgFloatValue == 0 {
+          return keyframe.withValue(Vector1D(0.01))
+        } else {
+          return keyframe
+        }
+      })
+    })
+
     return (dashPatterns, dashPhase)
   }
 }
+
+extension Array where Element == CGFloat {
+  // If all of the items in the dash pattern are zeros, then we shouldn't attempt to render it.
+  // This causes Core Animation to have extremely poor performance for some reason, even though
+  // it doesn't affect the appearance of the animation.
+  //  - We check for `== 0.01` instead of `== 0` because `dashPattern.shapeLayerConfiguration`
+  //    converts all `0` values to `0.01` to work around a different Core Animation rendering issue.
+  var isSupportedLayerDashPattern: Bool {
+    !allSatisfy { $0 == 0.01 }
+  }
+}

package/Sources/Private/MainThread/NodeRenderSystem/RenderLayers/ShapeContainerLayer.swift

@@ -69,7 +69,7 @@ class ShapeContainerLayer: CALayer {
 
   func updateRenderScale() {
     contentsScale = renderScale
-    renderLayers.forEach( { $0.renderScale = renderScale } )
+    renderLayers.forEach({ $0.renderScale = renderScale })
   }
 
 }

package/Sources/Private/MainThread/NodeRenderSystem/RenderLayers/ShapeRenderLayer.swift

@@ -69,7 +69,6 @@ final class ShapeRenderLayer: ShapeContainerLayer {
   }
 
   override func rebuildContents(forFrame _: CGFloat) {
-
     if renderer.shouldRenderInContext {
       if let newPath = renderer.outputPath {
         bounds = renderer.renderBoundsFor(newPath.boundingBox)

package/Sources/Private/Model/Animation.swift

@@ -31,8 +31,8 @@ public final class Animation: Codable, DictionaryInitializable {
     startFrame = try container.decode(AnimationFrameTime.self, forKey: .startFrame)
     endFrame = try container.decode(AnimationFrameTime.self, forKey: .endFrame)
     framerate = try container.decode(Double.self, forKey: .framerate)
-    width = try container.decode(Int.self, forKey: .width)
-    height = try container.decode(Int.self, forKey: .height)
+    width = try container.decode(Double.self, forKey: .width)
+    height = try container.decode(Double.self, forKey: .height)
     layers = try container.decode([LayerModel].self, ofFamily: LayerType.self, forKey: .layers)
     glyphs = try container.decodeIfPresent([Glyph].self, forKey: .glyphs)
     fonts = try container.decodeIfPresent(FontList.self, forKey: .fonts)
@@ -137,10 +137,10 @@ public final class Animation: Codable, DictionaryInitializable {
   let type: CoordinateSpace
 
   /// The height of the composition in points.
-  let width: Int
+  let width: Double
 
   /// The width of the composition in points.
-  let height: Int
+  let height: Double
 
   /// The list of animation layers
   let layers: [LayerModel]

package/Sources/Private/Model/Keyframes/KeyframeGroup.swift

@@ -195,3 +195,28 @@ extension Keyframe {
       spatialOutTangent: spatialOutTangent)
   }
 }
+
+extension KeyframeGroup {
+  /// Maps the values of each individual keyframe in this group
+  func map<NewValue>(_ transformation: (T) throws -> NewValue) rethrows -> KeyframeGroup<NewValue> {
+    KeyframeGroup<NewValue>(keyframes: ContiguousArray(try keyframes.map { keyframe in
+      keyframe.withValue(try transformation(keyframe.value))
+    }))
+  }
+}
+
+// MARK: - AnyKeyframeGroup
+
+/// A type-erased wrapper for `KeyframeGroup`s
+protocol AnyKeyframeGroup {
+  var untyped: KeyframeGroup<Any> { get }
+}
+
+// MARK: - KeyframeGroup + AnyKeyframeGroup
+
+extension KeyframeGroup: AnyKeyframeGroup {
+  /// An untyped copy of these keyframes
+  var untyped: KeyframeGroup<Any> {
+    map { $0 as Any }
+  }
+}

package/Sources/Private/Model/ShapeItems/Ellipse.swift

@@ -17,7 +17,6 @@ enum PathDirection: Int, Codable {
 
 // MARK: - Ellipse
 
-/// An item that define an ellipse shape
 final class Ellipse: ShapeItem {
 
   // MARK: Lifecycle

package/Sources/Private/Model/ShapeItems/Fill.swift

@@ -17,7 +17,6 @@ enum FillRule: Int, Codable {
 
 // MARK: - Fill
 
-/// An item that defines a fill render
 final class Fill: ShapeItem {
 
   // MARK: Lifecycle
@@ -54,6 +53,7 @@ final class Fill: ShapeItem {
   /// The color keyframes for the fill
   let color: KeyframeGroup<Color>
 
+  /// The fill rule to use when filling a path
   let fillRule: FillRule
 
   override func encode(to encoder: Encoder) throws {

package/Sources/Private/Model/ShapeItems/GradientFill.swift

@@ -17,7 +17,6 @@ enum GradientType: Int, Codable {
 
 // MARK: - GradientFill
 
-/// An item that define a gradient fill
 final class GradientFill: ShapeItem {
 
   // MARK: Lifecycle
@@ -30,6 +29,7 @@ final class GradientFill: ShapeItem {
     gradientType = try container.decode(GradientType.self, forKey: .gradientType)
     highlightLength = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .highlightLength)
     highlightAngle = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .highlightAngle)
+    fillRule = try container.decodeIfPresent(FillRule.self, forKey: .fillRule) ?? .nonZeroWinding
     let colorsContainer = try container.nestedContainer(keyedBy: GradientDataKeys.self, forKey: .colors)
     colors = try colorsContainer.decode(KeyframeGroup<[Double]>.self, forKey: .colors)
     numberOfColors = try colorsContainer.decode(Int.self, forKey: .numberOfColors)
@@ -62,6 +62,14 @@ final class GradientFill: ShapeItem {
     let nestedColorsDictionary: [String: Any] = try colorsDictionary.value(for: GradientDataKeys.colors)
     colors = try KeyframeGroup<[Double]>(dictionary: nestedColorsDictionary)
     numberOfColors = try colorsDictionary.value(for: GradientDataKeys.numberOfColors)
+    if
+      let fillRuleRawValue = dictionary[CodingKeys.fillRule.rawValue] as? Int,
+      let fillRule = FillRule(rawValue: fillRuleRawValue)
+    {
+      self.fillRule = fillRule
+    } else {
+      fillRule = .nonZeroWinding
+    }
     try super.init(dictionary: dictionary)
   }
 
@@ -91,6 +99,9 @@ final class GradientFill: ShapeItem {
   /// The Colors of the gradient.
   let colors: KeyframeGroup<[Double]>
 
+  /// The fill rule to use when filling a path
+  let fillRule: FillRule
+
   override func encode(to encoder: Encoder) throws {
     try super.encode(to: encoder)
     var container = encoder.container(keyedBy: CodingKeys.self)
@@ -100,6 +111,7 @@ final class GradientFill: ShapeItem {
     try container.encode(gradientType, forKey: .gradientType)
     try container.encodeIfPresent(highlightLength, forKey: .highlightLength)
     try container.encodeIfPresent(highlightAngle, forKey: .highlightAngle)
+    try container.encodeIfPresent(fillRule, forKey: .fillRule)
     var colorsContainer = container.nestedContainer(keyedBy: GradientDataKeys.self, forKey: .colors)
     try colorsContainer.encode(numberOfColors, forKey: .numberOfColors)
     try colorsContainer.encode(colors, forKey: .colors)
@@ -115,6 +127,7 @@ final class GradientFill: ShapeItem {
     case highlightLength = "h"
     case highlightAngle = "a"
     case colors = "g"
+    case fillRule = "r"
   }
 
   private enum GradientDataKeys: String, CodingKey {

package/Sources/Private/Model/ShapeItems/GradientStroke.swift

@@ -27,7 +27,6 @@ enum LineJoin: Int, Codable {
 
 // MARK: - GradientStroke
 
-/// An item that define an ellipse shape
 final class GradientStroke: ShapeItem {
 
   // MARK: Lifecycle

package/Sources/Private/Model/ShapeItems/Group.swift

@@ -7,7 +7,7 @@
 
 import Foundation
 
-/// An item that define an ellipse shape
+/// An item that define a a group of shape items
 final class Group: ShapeItem {
 
   // MARK: Lifecycle
@@ -24,6 +24,11 @@ final class Group: ShapeItem {
     try super.init(dictionary: dictionary)
   }
 
+  init(items: [ShapeItem], name: String) {
+    self.items = items
+    super.init(name: name, type: .group, hidden: false)
+  }
+
   // MARK: Internal
 
   /// A list of shape items.

package/Sources/Private/Model/ShapeItems/Merge.swift

@@ -20,7 +20,6 @@ enum MergeMode: Int, Codable {
 
 // MARK: - Merge
 
-/// An item that define an ellipse shape
 final class Merge: ShapeItem {
 
   // MARK: Lifecycle

package/Sources/Private/Model/ShapeItems/Rectangle.swift

@@ -7,7 +7,6 @@
 
 import Foundation
 
-/// An item that define an ellipse shape
 final class Rectangle: ShapeItem {
 
   // MARK: Lifecycle

package/Sources/Private/Model/ShapeItems/Repeater.swift

@@ -7,7 +7,6 @@
 
 import Foundation
 
-/// An item that define an ellipse shape
 final class Repeater: ShapeItem {
 
   // MARK: Lifecycle

package/Sources/Private/Model/ShapeItems/ShapeTransform.swift

@@ -7,7 +7,6 @@
 
 import Foundation
 
-/// An item that define an ellipse shape
 final class ShapeTransform: ShapeItem {
 
   // MARK: Lifecycle

package/Sources/Private/Model/ShapeItems/Star.swift

@@ -17,7 +17,6 @@ enum StarType: Int, Codable {
 
 // MARK: - Star
 
-/// An item that define an ellipse shape
 final class Star: ShapeItem {
 
   // MARK: Lifecycle

package/Sources/Private/Model/ShapeItems/Stroke.swift

@@ -7,7 +7,6 @@
 
 import Foundation
 
-/// An item that define an ellipse shape
 final class Stroke: ShapeItem {
 
   // MARK: Lifecycle

package/Sources/Private/Model/ShapeItems/Trim.swift

@@ -16,7 +16,6 @@ enum TrimType: Int, Codable {
 
 // MARK: - Trim
 
-/// An item that define an ellipse shape
 final class Trim: ShapeItem {
 
   // MARK: Lifecycle

package/Sources/Private/Model/Text/TextAnimator.swift

@@ -26,7 +26,6 @@ final class TextAnimator: Codable, DictionaryInitializable {
     skewAxis = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .skewAxis)
     rotation = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .rotation)
     opacity = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .opacity)
-
   }
 
   init(dictionary: [String: Any]) throws {

package/Sources/Private/Utility/Debugging/LayerDebugging.swift

@@ -53,7 +53,7 @@ extension CALayer {
       string = string + "  "
     }
     string = string + "|_" + String(describing: self)
-    print(string)
+    LottieLogger.shared.info(string)
     if let sublayers = sublayers {
       for sublayer in sublayers {
         sublayer.logLayerTree(withIndent: withIndent + 1)
@@ -75,7 +75,6 @@ extension CALayer {
 
   @nonobjc
   func setDebuggingState(visible: Bool) {
-
     var sublayers = self.sublayers
     if let cust = self as? CustomLayerDebugging {
       sublayers = cust.layerForDebugging().sublayers

package/Sources/Private/Utility/Extensions/MathKit.swift

@@ -344,7 +344,6 @@ extension CGPoint {
     var closestPoint = 0
 
     while previousAmount < 1 {
-
       previousAmount = previousAmount + step
 
       if previousAmount < amount {
@@ -429,7 +428,7 @@ extension CGPoint {
   func colinear(_ a: CGPoint, _ b: CGPoint) -> Bool {
     let area = x * (a.y - b.y) + a.x * (b.y - y) + b.x * (y - a.y);
     let accuracy: CGFloat = 0.05
-    if area < accuracy && area > -accuracy {
+    if area < accuracy, area > -accuracy {
       return true
     }
     return false

package/Sources/Private/Utility/Extensions/StringExtensions.swift

@@ -16,7 +16,6 @@ extension String {
   }
 
   func hexColorComponents() -> (red: CGFloat, green: CGFloat, blue: CGFloat) {
-
     var cString: String = trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
 
     if cString.hasPrefix("#") {

package/Sources/Private/Utility/Interpolatable/InterpolatableExtensions.swift

@@ -14,7 +14,6 @@ extension Color {
 
   /// Initialize a new color with Hue Saturation and Value
   init(h: Double, s: Double, v: Double, a: Double) {
-
     let i = floor(h * 6)
     let f = h * 6 - i
     let p = v * (1 - s);

package/Sources/Private/{MainThread/NodeRenderSystem/NodeProperties/ValueProviders → Utility/Interpolatable}/KeyframeInterpolator.swift

@@ -149,7 +149,7 @@ final class KeyframeInterpolator<ValueType>: ValueProvider where ValueType: AnyI
 
     /// Sets the initial keyframes. This is often only needed for the first check.
     if
-      leadingIndex == nil &&
+      leadingIndex == nil,
       trailingIndex == nil
     {
       if frame < keyframes[0].time {
@@ -170,7 +170,6 @@ final class KeyframeInterpolator<ValueType>: ValueProvider where ValueType: AnyI
       var newLeading = currentTrailing
       var keyframeFound = false
       while !keyframeFound {
-
         leadingIndex = newLeading
         trailingIndex = keyframes.validIndex(newLeading + 1)
 
@@ -192,13 +191,11 @@ final class KeyframeInterpolator<ValueType>: ValueProvider where ValueType: AnyI
       let currentLeading = leadingIndex,
       frame < keyframes[currentLeading].time
     {
-
       /// Time is before the current span. Iterate backwards
       var newTrailing = currentLeading
 
       var keyframeFound = false
       while !keyframeFound {
-
         leadingIndex = keyframes.validIndex(newTrailing - 1)
         trailingIndex = newTrailing
 

package/Sources/Private/Utility/Primitives/BezierPath.swift

@@ -388,7 +388,6 @@ extension BezierPath: Codable {
       try inPointsContainer.encode(element.vertex.inTangentRelative)
       try outPointsContainer.encode(element.vertex.outTangentRelative)
     }
-
   }
 }
 
@@ -469,7 +468,7 @@ extension BezierPath {
     var previousElement: PathElement?
     for element in elements {
       if let previous = previousElement {
-        if previous.vertex.outTangentRelative.isZero && element.vertex.inTangentRelative.isZero {
+        if previous.vertex.outTangentRelative.isZero, element.vertex.inTangentRelative.isZero {
           cgPath.addLine(to: element.vertex.point)
         } else {
           cgPath.addCurve(to: element.vertex.point, control1: previous.vertex.outTangent, control2: element.vertex.inTangent)

package/Sources/Private/Utility/Primitives/CurveVertex.swift

@@ -78,7 +78,6 @@ struct CurveVertex {
   func splitCurve(toVertex: CurveVertex, position: CGFloat) ->
     (start: CurveVertex, trimPoint: CurveVertex, end: CurveVertex)
   {
-
     /// If position is less than or equal to 0, trim at start.
     if position <= 0 {
       return (
@@ -101,7 +100,7 @@ struct CurveVertex {
           outTangentRelative: toVertex.outTangentRelative))
     }
 
-    if outTangentRelative.isZero && toVertex.inTangentRelative.isZero {
+    if outTangentRelative.isZero, toVertex.inTangentRelative.isZero {
       /// If both tangents are zero, then span to be trimmed is a straight line.
       let trimPoint = point.interpolate(to: toVertex.point, amount: position)
       return (
@@ -166,8 +165,7 @@ struct CurveVertex {
   /// For curves the curve is iterated over by sample count and the points are measured.
   /// This is ~99% accurate at a sample count of 30
   func distanceTo(_ toVertex: CurveVertex, sampleCount: Int = 25) -> CGFloat {
-
-    if outTangentRelative.isZero && toVertex.inTangentRelative.isZero {
+    if outTangentRelative.isZero, toVertex.inTangentRelative.isZero {
       /// Return a linear distance.
       return point.distanceTo(toVertex.point)
     }