lottie-ios 3.4.3 → 3.5.0

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

@@ -15,74 +15,74 @@ final class TextAnimator: Codable, DictionaryInitializable {
     let container = try decoder.container(keyedBy: TextAnimator.CodingKeys.self)
     name = try container.decodeIfPresent(String.self, forKey: .name) ?? ""
     let animatorContainer = try container.nestedContainer(keyedBy: TextAnimatorKeys.self, forKey: .textAnimator)
-    fillColor = try animatorContainer.decodeIfPresent(KeyframeGroup<Color>.self, forKey: .fillColor)
-    strokeColor = try animatorContainer.decodeIfPresent(KeyframeGroup<Color>.self, forKey: .strokeColor)
-    strokeWidth = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .strokeWidth)
-    tracking = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .tracking)
-    anchor = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .anchor)
-    position = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .position)
-    scale = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .scale)
-    skew = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .skew)
-    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)
+    fillColor = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieColor>.self, forKey: .fillColor)
+    strokeColor = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieColor>.self, forKey: .strokeColor)
+    strokeWidth = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .strokeWidth)
+    tracking = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .tracking)
+    anchor = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .anchor)
+    position = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .position)
+    scale = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .scale)
+    skew = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .skew)
+    skewAxis = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .skewAxis)
+    rotation = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotation)
+    opacity = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .opacity)
   }
 
   init(dictionary: [String: Any]) throws {
     name = (try? dictionary.value(for: CodingKeys.name)) ?? ""
     let animatorDictionary: [String: Any] = try dictionary.value(for: CodingKeys.textAnimator)
     if let fillColorDictionary = animatorDictionary[TextAnimatorKeys.fillColor.rawValue] as? [String: Any] {
-      fillColor = try? KeyframeGroup<Color>(dictionary: fillColorDictionary)
+      fillColor = try? KeyframeGroup<LottieColor>(dictionary: fillColorDictionary)
     } else {
       fillColor = nil
     }
     if let strokeColorDictionary = animatorDictionary[TextAnimatorKeys.strokeColor.rawValue] as? [String: Any] {
-      strokeColor = try? KeyframeGroup<Color>(dictionary: strokeColorDictionary)
+      strokeColor = try? KeyframeGroup<LottieColor>(dictionary: strokeColorDictionary)
     } else {
       strokeColor = nil
     }
     if let strokeWidthDictionary = animatorDictionary[TextAnimatorKeys.strokeWidth.rawValue] as? [String: Any] {
-      strokeWidth = try? KeyframeGroup<Vector1D>(dictionary: strokeWidthDictionary)
+      strokeWidth = try? KeyframeGroup<LottieVector1D>(dictionary: strokeWidthDictionary)
     } else {
       strokeWidth = nil
     }
     if let trackingDictionary = animatorDictionary[TextAnimatorKeys.tracking.rawValue] as? [String: Any] {
-      tracking = try? KeyframeGroup<Vector1D>(dictionary: trackingDictionary)
+      tracking = try? KeyframeGroup<LottieVector1D>(dictionary: trackingDictionary)
     } else {
       tracking = nil
     }
     if let anchorDictionary = animatorDictionary[TextAnimatorKeys.anchor.rawValue] as? [String: Any] {
-      anchor = try? KeyframeGroup<Vector3D>(dictionary: anchorDictionary)
+      anchor = try? KeyframeGroup<LottieVector3D>(dictionary: anchorDictionary)
     } else {
       anchor = nil
     }
     if let positionDictionary = animatorDictionary[TextAnimatorKeys.position.rawValue] as? [String: Any] {
-      position = try? KeyframeGroup<Vector3D>(dictionary: positionDictionary)
+      position = try? KeyframeGroup<LottieVector3D>(dictionary: positionDictionary)
     } else {
       position = nil
     }
     if let scaleDictionary = animatorDictionary[TextAnimatorKeys.scale.rawValue] as? [String: Any] {
-      scale = try? KeyframeGroup<Vector3D>(dictionary: scaleDictionary)
+      scale = try? KeyframeGroup<LottieVector3D>(dictionary: scaleDictionary)
     } else {
       scale = nil
     }
     if let skewDictionary = animatorDictionary[TextAnimatorKeys.skew.rawValue] as? [String: Any] {
-      skew = try? KeyframeGroup<Vector1D>(dictionary: skewDictionary)
+      skew = try? KeyframeGroup<LottieVector1D>(dictionary: skewDictionary)
     } else {
       skew = nil
     }
     if let skewAxisDictionary = animatorDictionary[TextAnimatorKeys.skewAxis.rawValue] as? [String: Any] {
-      skewAxis = try? KeyframeGroup<Vector1D>(dictionary: skewAxisDictionary)
+      skewAxis = try? KeyframeGroup<LottieVector1D>(dictionary: skewAxisDictionary)
     } else {
       skewAxis = nil
     }
     if let rotationDictionary = animatorDictionary[TextAnimatorKeys.rotation.rawValue] as? [String: Any] {
-      rotation = try? KeyframeGroup<Vector1D>(dictionary: rotationDictionary)
+      rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
     } else {
       rotation = nil
     }
     if let opacityDictionary = animatorDictionary[TextAnimatorKeys.opacity.rawValue] as? [String: Any] {
-      opacity = try KeyframeGroup<Vector1D>(dictionary: opacityDictionary)
+      opacity = try KeyframeGroup<LottieVector1D>(dictionary: opacityDictionary)
     } else {
       opacity = nil
     }
@@ -93,37 +93,37 @@ final class TextAnimator: Codable, DictionaryInitializable {
   let name: String
 
   /// Anchor
-  let anchor: KeyframeGroup<Vector3D>?
+  let anchor: KeyframeGroup<LottieVector3D>?
 
   /// Position
-  let position: KeyframeGroup<Vector3D>?
+  let position: KeyframeGroup<LottieVector3D>?
 
   /// Scale
-  let scale: KeyframeGroup<Vector3D>?
+  let scale: KeyframeGroup<LottieVector3D>?
 
   /// Skew
-  let skew: KeyframeGroup<Vector1D>?
+  let skew: KeyframeGroup<LottieVector1D>?
 
   /// Skew Axis
-  let skewAxis: KeyframeGroup<Vector1D>?
+  let skewAxis: KeyframeGroup<LottieVector1D>?
 
   /// Rotation
-  let rotation: KeyframeGroup<Vector1D>?
+  let rotation: KeyframeGroup<LottieVector1D>?
 
   /// Opacity
-  let opacity: KeyframeGroup<Vector1D>?
+  let opacity: KeyframeGroup<LottieVector1D>?
 
   /// Stroke Color
-  let strokeColor: KeyframeGroup<Color>?
+  let strokeColor: KeyframeGroup<LottieColor>?
 
   /// Fill Color
-  let fillColor: KeyframeGroup<Color>?
+  let fillColor: KeyframeGroup<LottieColor>?
 
   /// Stroke Width
-  let strokeWidth: KeyframeGroup<Vector1D>?
+  let strokeWidth: KeyframeGroup<LottieVector1D>?
 
   /// Tracking
-  let tracking: KeyframeGroup<Vector1D>?
+  let tracking: KeyframeGroup<LottieVector1D>?
 
   func encode(to encoder: Encoder) throws {
     var container = encoder.container(keyedBy: CodingKeys.self)

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

@@ -34,24 +34,24 @@ final class TextDocument: Codable, DictionaryInitializable, AnyInitializable {
     lineHeight = try dictionary.value(for: CodingKeys.lineHeight)
     baseline = try dictionary.value(for: CodingKeys.baseline)
     if let fillColorRawValue = dictionary[CodingKeys.fillColorData.rawValue] {
-      fillColorData = try? Color(value: fillColorRawValue)
+      fillColorData = try? LottieColor(value: fillColorRawValue)
     } else {
       fillColorData = nil
     }
     if let strokeColorRawValue = dictionary[CodingKeys.strokeColorData.rawValue] {
-      strokeColorData = try? Color(value: strokeColorRawValue)
+      strokeColorData = try? LottieColor(value: strokeColorRawValue)
     } else {
       strokeColorData = nil
     }
     strokeWidth = try? dictionary.value(for: CodingKeys.strokeWidth)
     strokeOverFill = try? dictionary.value(for: CodingKeys.strokeOverFill)
     if let textFramePositionRawValue = dictionary[CodingKeys.textFramePosition.rawValue] {
-      textFramePosition = try? Vector3D(value: textFramePositionRawValue)
+      textFramePosition = try? LottieVector3D(value: textFramePositionRawValue)
     } else {
       textFramePosition = nil
     }
     if let textFrameSizeRawValue = dictionary[CodingKeys.textFrameSize.rawValue] {
-      textFrameSize = try? Vector3D(value: textFrameSizeRawValue)
+      textFrameSize = try? LottieVector3D(value: textFrameSizeRawValue)
     } else {
       textFrameSize = nil
     }
@@ -88,10 +88,10 @@ final class TextDocument: Codable, DictionaryInitializable, AnyInitializable {
   let baseline: Double?
 
   /// Fill Color data
-  let fillColorData: Color?
+  let fillColorData: LottieColor?
 
   /// Scroke Color data
-  let strokeColorData: Color?
+  let strokeColorData: LottieColor?
 
   /// Stroke Width
   let strokeWidth: Double?
@@ -99,9 +99,9 @@ final class TextDocument: Codable, DictionaryInitializable, AnyInitializable {
   /// Stroke Over Fill
   let strokeOverFill: Bool?
 
-  let textFramePosition: Vector3D?
+  let textFramePosition: LottieVector3D?
 
-  let textFrameSize: Vector3D?
+  let textFrameSize: LottieVector3D?
 
   // MARK: Private
 

package/Sources/Private/RootAnimationLayer.swift

@@ -17,16 +17,16 @@ protocol RootAnimationLayer: CALayer {
   var fontProvider: AnimationFontProvider { get set }
 
   /// The `CAAnimation` key corresponding to the primary animation.
-  ///  - `AnimationView` uses this key to check if the animation is still active
+  ///  - `LottieAnimationView` uses this key to check if the animation is still active
   var primaryAnimationKey: AnimationKey { get }
 
   /// Whether or not this layer is currently playing an animation
-  ///  - If the layer returns `nil`, `AnimationView` determines if an animation
+  ///  - If the layer returns `nil`, `LottieAnimationView` determines if an animation
   ///    is playing by checking if there is an active animation for `primaryAnimationKey`
   var isAnimationPlaying: Bool? { get }
 
   /// Instructs this layer to remove all `CAAnimation`s,
-  /// other than the `CAAnimation` managed by `AnimationView` (if applicable)
+  /// other than the `CAAnimation` managed by `LottieAnimationView` (if applicable)
   func removeAnimations()
 
   func reloadImages()
@@ -44,7 +44,7 @@ protocol RootAnimationLayer: CALayer {
 // MARK: - AnimationKey
 
 enum AnimationKey {
-  /// The primary animation and its key should be managed by `AnimationView`
+  /// The primary animation and its key should be managed by `LottieAnimationView`
   case managed
   /// The primary animation always uses the given key
   case specific(String)

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

@@ -8,7 +8,7 @@
 import CoreGraphics
 import Foundation
 
-extension Color {
+extension LottieColor {
 
   // MARK: Lifecycle
 

package/Sources/Private/Utility/Interpolatable/KeyframeGroup+Extensions.swift

@@ -8,7 +8,7 @@
 import CoreGraphics
 import Foundation
 
-extension KeyframeGroup where T == Vector1D {
+extension KeyframeGroup where T == LottieVector1D {
   /// Manually interpolates the keyframes so that they are defined linearly
   ///
   /// This method uses `UnitBezier` to perform the interpolation. It will create one keyframe
@@ -19,7 +19,7 @@ extension KeyframeGroup where T == Vector1D {
       return keyframes
     }
 
-    var output = ContiguousArray<Keyframe<Vector1D>>()
+    var output = ContiguousArray<Keyframe<LottieVector1D>>()
 
     for idx in 1 ..< keyframes.count {
       let prev = keyframes[idx - 1]
@@ -43,8 +43,8 @@ extension KeyframeGroup where T == Vector1D {
           epsilon: 0.005)
         let value = startValue + Double(progress) * difference
         output.append(
-          Keyframe<Vector1D>(
-            value: Vector1D(value),
+          Keyframe<LottieVector1D>(
+            value: LottieVector1D(value),
             time: startTime + CGFloat(t),
             isHold: false,
             inTangent: nil,

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

@@ -1,5 +1,5 @@
 //
-//  Color.swift
+//  LottieColor.swift
 //  lottie-swift
 //
 //  Created by Brandon Withrow on 1/14/19.
@@ -8,9 +8,9 @@
 import CoreGraphics
 import Foundation
 
-// MARK: - Color + Codable
+// MARK: - LottieColor + Codable
 
-extension Color: Codable {
+extension LottieColor: Codable {
 
   // MARK: Lifecycle
 
@@ -68,9 +68,9 @@ extension Color: Codable {
 
 }
 
-// MARK: - Color + AnyInitializable
+// MARK: - LottieColor + AnyInitializable
 
-extension Color: AnyInitializable {
+extension LottieColor: AnyInitializable {
 
   init(value: Any) throws {
     guard var array = value as? [Double] else {
@@ -94,7 +94,7 @@ extension Color: AnyInitializable {
 
 }
 
-extension Color {
+extension LottieColor {
 
   static var clearColor: CGColor {
     CGColor(colorSpace: CGColorSpaceCreateDeviceRGB(), components: [0, 0, 0, 0])!
@@ -103,6 +103,6 @@ extension Color {
   var cgColorValue: CGColor {
     // TODO: Fix color spaces
     let colorspace = CGColorSpaceCreateDeviceRGB()
-    return CGColor(colorSpace: colorspace, components: [CGFloat(r), CGFloat(g), CGFloat(b), CGFloat(a)]) ?? Color.clearColor
+    return CGColor(colorSpace: colorspace, components: [CGFloat(r), CGFloat(g), CGFloat(b), CGFloat(a)]) ?? LottieColor.clearColor
   }
 }

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

@@ -9,10 +9,10 @@ import CoreGraphics
 import Foundation
 import QuartzCore
 
-// MARK: - Vector1D + Codable
+// MARK: - LottieVector1D + Codable
 
 /// Single value container. Needed because lottie sometimes wraps a Double in an array.
-extension Vector1D: Codable {
+extension LottieVector1D: Codable {
 
   // MARK: Lifecycle
 
@@ -41,9 +41,9 @@ extension Vector1D: Codable {
 
 }
 
-// MARK: - Vector1D + AnyInitializable
+// MARK: - LottieVector1D + AnyInitializable
 
-extension Vector1D: AnyInitializable {
+extension LottieVector1D: AnyInitializable {
 
   init(value: Any) throws {
     if
@@ -61,15 +61,23 @@ extension Vector1D: AnyInitializable {
 }
 
 extension Double {
-  var vectorValue: Vector1D {
-    Vector1D(self)
+  var vectorValue: LottieVector1D {
+    LottieVector1D(self)
   }
 }
 
 // MARK: - Vector2D
 
+@available(*, deprecated, renamed: "LottieVector2D", message: """
+  `Lottie.Vector2D` has been renamed to `LottieVector2D` for consistency with \
+  the new `LottieVector3D` type. This notice will be removed in Lottie 4.0.
+  """)
+public typealias Vector2D = LottieVector2D
+
+// MARK: - LottieVector2D
+
 /// Needed for decoding json {x: y:} to a CGPoint
-public struct Vector2D: Codable, Hashable {
+public struct LottieVector2D: Codable, Hashable {
 
   // MARK: Lifecycle
 
@@ -79,7 +87,7 @@ public struct Vector2D: Codable, Hashable {
   }
 
   public init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: Vector2D.CodingKeys.self)
+    let container = try decoder.container(keyedBy: LottieVector2D.CodingKeys.self)
 
     do {
       let xValue: [Double] = try container.decode([Double].self, forKey: .x)
@@ -99,7 +107,7 @@ public struct Vector2D: Codable, Hashable {
   // MARK: Public
 
   public func encode(to encoder: Encoder) throws {
-    var container = encoder.container(keyedBy: Vector2D.CodingKeys.self)
+    var container = encoder.container(keyedBy: LottieVector2D.CodingKeys.self)
     try container.encode(x, forKey: .x)
     try container.encode(y, forKey: .y)
   }
@@ -123,7 +131,7 @@ public struct Vector2D: Codable, Hashable {
 
 // MARK: AnyInitializable
 
-extension Vector2D: AnyInitializable {
+extension LottieVector2D: AnyInitializable {
 
   init(value: Any) throws {
     guard let dictionary = value as? [String: Any] else {
@@ -154,17 +162,17 @@ extension Vector2D: AnyInitializable {
 }
 
 extension CGPoint {
-  var vector2dValue: Vector2D {
-    Vector2D(x: Double(x), y: Double(y))
+  var vector2dValue: LottieVector2D {
+    LottieVector2D(x: Double(x), y: Double(y))
   }
 }
 
-// MARK: - Vector3D + Codable
+// MARK: - LottieVector3D + Codable
 
 /// A three dimensional vector.
 /// These vectors are encoded and decoded from [Double]
 
-extension Vector3D: Codable {
+extension LottieVector3D: Codable {
 
   // MARK: Lifecycle
 
@@ -207,9 +215,9 @@ extension Vector3D: Codable {
 
 }
 
-// MARK: - Vector3D + AnyInitializable
+// MARK: - LottieVector3D + AnyInitializable
 
-extension Vector3D: AnyInitializable {
+extension LottieVector3D: AnyInitializable {
 
   init(value: Any) throws {
     guard var array = value as? [Double] else {
@@ -222,7 +230,7 @@ extension Vector3D: AnyInitializable {
 
 }
 
-extension Vector3D {
+extension LottieVector3D {
   public var pointValue: CGPoint {
     CGPoint(x: x, y: y)
   }
@@ -233,14 +241,14 @@ extension Vector3D {
 }
 
 extension CGPoint {
-  var vector3dValue: Vector3D {
-    Vector3D(x: x, y: y, z: 0)
+  var vector3dValue: LottieVector3D {
+    LottieVector3D(x: x, y: y, z: 0)
   }
 }
 
 extension CGSize {
-  var vector3dValue: Vector3D {
-    Vector3D(x: width, y: height, z: 1)
+  var vector3dValue: LottieVector3D {
+    LottieVector3D(x: width, y: height, z: 1)
   }
 }
 

package/Sources/{Private/Model/Animation.swift → Public/Animation/LottieAnimation.swift}

@@ -1,5 +1,5 @@
 //
-//  Animation.swift
+//  LottieAnimation.swift
 //  lottie-swift
 //
 //  Created by Brandon Withrow on 1/7/19.
@@ -16,16 +16,24 @@ public enum CoordinateSpace: Int, Codable {
 
 // MARK: - Animation
 
-/// The `Animation` model is the top level model object in Lottie.
+@available(*, deprecated, renamed: "LottieAnimation", message: """
+  `Lottie.Animation` has been renamed to `LottieAnimation`, to prevent conflicts \
+  with the `SwiftUI.Animation` type. This notice will be removed in Lottie 4.0.
+  """)
+public typealias Animation = LottieAnimation
+
+// MARK: - LottieAnimation
+
+/// The `LottieAnimation` model is the top level model object in Lottie.
 ///
-/// An `Animation` holds all of the animation data backing a Lottie Animation.
+/// A `LottieAnimation` holds all of the animation data backing a Lottie Animation.
 /// Codable, see JSON schema [here](https://github.com/airbnb/lottie-web/tree/master/docs/json).
-public final class Animation: Codable, DictionaryInitializable {
+public final class LottieAnimation: Codable, DictionaryInitializable {
 
   // MARK: Lifecycle
 
   required public init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: Animation.CodingKeys.self)
+    let container = try decoder.container(keyedBy: LottieAnimation.CodingKeys.self)
     version = try container.decode(String.self, forKey: .version)
     type = try container.decodeIfPresent(CoordinateSpace.self, forKey: .type) ?? .type2d
     startFrame = try container.decode(AnimationFrameTime.self, forKey: .startFrame)

package/Sources/Public/Animation/{AnimationPublic.swift → LottieAnimationHelpers.swift}

@@ -8,10 +8,10 @@
 import CoreGraphics
 import Foundation
 
-extension Animation {
+extension LottieAnimation {
 
   /// A closure for an Animation download. The closure is passed `nil` if there was an error.
-  public typealias DownloadClosure = (Animation?) -> Void
+  public typealias DownloadClosure = (LottieAnimation?) -> Void
 
   /// The duration in seconds of the animation.
   public var duration: TimeInterval {
@@ -37,13 +37,13 @@ extension Animation {
   /// - Parameter subdirectory: A subdirectory in the bundle in which the animation is located. Optional.
   /// - Parameter animationCache: A cache for holding loaded animations. Optional.
   ///
-  /// - Returns: Deserialized `Animation`. Optional.
+  /// - Returns: Deserialized `LottieAnimation`. Optional.
   public static func named(
     _ name: String,
     bundle: Bundle = Bundle.main,
     subdirectory: String? = nil,
     animationCache: AnimationCacheProvider? = nil)
-    -> Animation?
+    -> LottieAnimation?
   {
     /// Create a cache key for the animation.
     let cacheKey = bundle.bundlePath + (subdirectory ?? "") + "/" + name
@@ -62,7 +62,7 @@ extension Animation {
       guard let json = try bundle.getAnimationData(name, subdirectory: subdirectory) else {
         return nil
       }
-      let animation = try Animation.from(data: json)
+      let animation = try LottieAnimation.from(data: json)
       animationCache?.setAnimation(animation, forKey: cacheKey)
       return animation
     } catch {
@@ -76,11 +76,11 @@ extension Animation {
   /// - Parameter filepath: The absolute filepath of the animation to load. EG "/User/Me/starAnimation.json"
   /// - Parameter animationCache: A cache for holding loaded animations. Optional.
   ///
-  /// - Returns: Deserialized `Animation`. Optional.
+  /// - Returns: Deserialized `LottieAnimation`. Optional.
   public static func filepath(
     _ filepath: String,
     animationCache: AnimationCacheProvider? = nil)
-    -> Animation?
+    -> LottieAnimation?
   {
     /// Check cache for animation
     if
@@ -93,7 +93,7 @@ extension Animation {
     do {
       /// Decode the animation.
       let json = try Data(contentsOf: URL(fileURLWithPath: filepath))
-      let animation = try Animation.from(data: json)
+      let animation = try LottieAnimation.from(data: json)
       animationCache?.setAnimation(animation, forKey: filepath)
       return animation
     } catch {
@@ -106,12 +106,12 @@ extension Animation {
   ///    - Parameter name: The name of the json file in the asset catalog. EG "StarAnimation"
   ///    - Parameter bundle: The bundle in which the animation is located. Defaults to `Bundle.main`
   ///    - Parameter animationCache: A cache for holding loaded animations. Optional.
-  ///    - Returns: Deserialized `Animation`. Optional.
+  ///    - Returns: Deserialized `LottieAnimation`. Optional.
   public static func asset(
     _ name: String,
     bundle: Bundle = Bundle.main,
     animationCache: AnimationCacheProvider? = nil)
-    -> Animation?
+    -> LottieAnimation?
   {
     /// Create a cache key for the animation.
     let cacheKey = bundle.bundlePath + "/" + name
@@ -132,7 +132,7 @@ extension Animation {
 
     do {
       /// Decode animation.
-      let animation = try Animation.from(data: json)
+      let animation = try LottieAnimation.from(data: json)
       animationCache?.setAnimation(animation, forKey: cacheKey)
       return animation
     } catch {
@@ -145,22 +145,22 @@ extension Animation {
   ///
   /// - Parameter data: The object to load the animation from.
   /// - Parameter strategy: How the data should be decoded. Defaults to using the strategy set in `LottieConfiguration.shared`.
-  /// - Returns: Deserialized `Animation`. Optional.
+  /// - Returns: Deserialized `LottieAnimation`. Optional.
   ///
   public static func from(
     data: Data,
     strategy: DecodingStrategy = LottieConfiguration.shared.decodingStrategy) throws
-    -> Animation
+    -> LottieAnimation
   {
     switch strategy {
     case .codable:
-      return try JSONDecoder().decode(Animation.self, from: data)
+      return try JSONDecoder().decode(LottieAnimation.self, from: data)
     case .dictionaryBased:
       let json = try JSONSerialization.jsonObject(with: data)
       guard let dict = json as? [String: Any] else {
         throw InitializableError.invalidInput
       }
-      return try Animation(dictionary: dict)
+      return try LottieAnimation(dictionary: dict)
     }
   }
 
@@ -173,7 +173,7 @@ extension Animation {
   public static func loadedFrom(
     url: URL,
     session: URLSession = .shared,
-    closure: @escaping Animation.DownloadClosure,
+    closure: @escaping LottieAnimation.DownloadClosure,
     animationCache: AnimationCacheProvider?)
   {
     if let animationCache = animationCache, let animation = animationCache.animation(forKey: url.absoluteString) {
@@ -187,7 +187,7 @@ extension Animation {
           return
         }
         do {
-          let animation = try Animation.from(data: jsonData)
+          let animation = try LottieAnimation.from(data: jsonData)
           DispatchQueue.main.async {
             animationCache?.setAnimation(animation, forKey: url.absoluteString)
             closure(animation)
@@ -234,6 +234,21 @@ extension Animation {
     return marker.frameTime
   }
 
+  /// Markers are a way to describe a point in time and a duration by a key name.
+  ///
+  /// Markers are encoded into animation JSON. By using markers a designer can mark
+  /// playback points for a developer to use without having to worry about keeping
+  /// track of animation frames. If the animation file is updated, the developer
+  /// does not need to update playback code.
+  ///
+  /// - Returns: The duration frame time for the marker, or `nil` if no marker found.
+  public func durationFrameTime(forMarker named: String) -> AnimationFrameTime? {
+    guard let marker = markerMap?[named] else {
+      return nil
+    }
+    return marker.durationFrameTime
+  }
+
   /// Converts Frame Time (Seconds * Framerate) into Progress Time
   /// (optionally clamped to between 0 and 1).
   public func progressTime(