lottie-ios 3.4.3 → 3.5.0

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

@@ -28,8 +28,8 @@ final class GradientStrokeProperties: NodePropertyMap, KeypathSearchable {
     lineJoin = gradientStroke.lineJoin
 
     if let dashes = gradientStroke.dashPattern {
-      var dashPatterns = ContiguousArray<ContiguousArray<Keyframe<Vector1D>>>()
-      var dashPhase = ContiguousArray<Keyframe<Vector1D>>()
+      var dashPatterns = ContiguousArray<ContiguousArray<Keyframe<LottieVector1D>>>()
+      var dashPhase = ContiguousArray<Keyframe<LottieVector1D>>()
       for dash in dashes {
         if dash.type == .offset {
           dashPhase = dash.value.keyframes
@@ -40,8 +40,8 @@ final class GradientStrokeProperties: NodePropertyMap, KeypathSearchable {
       dashPattern = NodeProperty(provider: GroupInterpolator(keyframeGroups: dashPatterns))
       self.dashPhase = NodeProperty(provider: KeyframeInterpolator(keyframes: dashPhase))
     } else {
-      dashPattern = NodeProperty(provider: SingleValueProvider([Vector1D]()))
-      dashPhase = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
+      dashPattern = NodeProperty(provider: SingleValueProvider([LottieVector1D]()))
+      dashPhase = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
     }
     keypathProperties = [
       "Opacity" : opacity,
@@ -59,14 +59,14 @@ final class GradientStrokeProperties: NodePropertyMap, KeypathSearchable {
 
   var keypathName: String
 
-  let opacity: NodeProperty<Vector1D>
-  let startPoint: NodeProperty<Vector3D>
-  let endPoint: NodeProperty<Vector3D>
+  let opacity: NodeProperty<LottieVector1D>
+  let startPoint: NodeProperty<LottieVector3D>
+  let endPoint: NodeProperty<LottieVector3D>
   let colors: NodeProperty<[Double]>
-  let width: NodeProperty<Vector1D>
+  let width: NodeProperty<LottieVector1D>
 
-  let dashPattern: NodeProperty<[Vector1D]>
-  let dashPhase: NodeProperty<Vector1D>
+  let dashPattern: NodeProperty<[LottieVector1D]>
+  let dashPhase: NodeProperty<LottieVector1D>
 
   let lineCap: LineCap
   let lineJoin: LineJoin

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

@@ -27,13 +27,13 @@ final class StrokeNodeProperties: NodePropertyMap, KeypathSearchable {
       let (dashPatterns, dashPhase) = dashes.shapeLayerConfiguration
       dashPattern = NodeProperty(provider: GroupInterpolator(keyframeGroups: dashPatterns))
       if dashPhase.count == 0 {
-        self.dashPhase = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
+        self.dashPhase = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
       } else {
         self.dashPhase = NodeProperty(provider: KeyframeInterpolator(keyframes: dashPhase))
       }
     } else {
-      dashPattern = NodeProperty(provider: SingleValueProvider([Vector1D]()))
-      dashPhase = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
+      dashPattern = NodeProperty(provider: SingleValueProvider([LottieVector1D]()))
+      dashPhase = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
     }
     keypathProperties = [
       "Opacity" : opacity,
@@ -51,12 +51,12 @@ final class StrokeNodeProperties: NodePropertyMap, KeypathSearchable {
   let keypathProperties: [String: AnyNodeProperty]
   let properties: [AnyNodeProperty]
 
-  let opacity: NodeProperty<Vector1D>
-  let color: NodeProperty<Color>
-  let width: NodeProperty<Vector1D>
+  let opacity: NodeProperty<LottieVector1D>
+  let color: NodeProperty<LottieColor>
+  let width: NodeProperty<LottieVector1D>
 
-  let dashPattern: NodeProperty<[Vector1D]>
-  let dashPhase: NodeProperty<Vector1D>
+  let dashPattern: NodeProperty<[LottieVector1D]>
+  let dashPhase: NodeProperty<LottieVector1D>
 
   let lineCap: LineCap
   let lineJoin: LineJoin
@@ -133,14 +133,14 @@ final class StrokeNode: AnimatorNode, RenderNode {
 
 extension Array where Element == DashElement {
   typealias ShapeLayerConfiguration = (
-    dashPatterns: ContiguousArray<ContiguousArray<Keyframe<Vector1D>>>,
-    dashPhase: ContiguousArray<Keyframe<Vector1D>>)
+    dashPatterns: ContiguousArray<ContiguousArray<Keyframe<LottieVector1D>>>,
+    dashPhase: ContiguousArray<Keyframe<LottieVector1D>>)
 
   /// Converts the `[DashElement]` data model into `lineDashPattern` and `lineDashPhase`
   /// representations usable in a `CAShapeLayer`
   var shapeLayerConfiguration: ShapeLayerConfiguration {
-    var dashPatterns = ContiguousArray<ContiguousArray<Keyframe<Vector1D>>>()
-    var dashPhase = ContiguousArray<Keyframe<Vector1D>>()
+    var dashPatterns = ContiguousArray<ContiguousArray<Keyframe<LottieVector1D>>>()
+    var dashPhase = ContiguousArray<Keyframe<LottieVector1D>>()
     for dash in self {
       if dash.type == .offset {
         dashPhase = dash.value.keyframes
@@ -150,14 +150,14 @@ extension Array where Element == DashElement {
     }
 
     dashPatterns = ContiguousArray(dashPatterns.map { pattern in
-      ContiguousArray(pattern.map { keyframe -> Keyframe<Vector1D> in
+      ContiguousArray(pattern.map { keyframe -> Keyframe<LottieVector1D> 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))
+          return keyframe.withValue(LottieVector1D(0.01))
         } else {
           return keyframe
         }

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/Text/TextAnimatorNode.swift

@@ -105,17 +105,17 @@ final class TextAnimatorNodeProperties: NodePropertyMap, KeypathSearchable {
 
   let keypathName: String
 
-  let anchor: NodeProperty<Vector3D>?
-  let position: NodeProperty<Vector3D>?
-  let scale: NodeProperty<Vector3D>?
-  let skew: NodeProperty<Vector1D>?
-  let skewAxis: NodeProperty<Vector1D>?
-  let rotation: NodeProperty<Vector1D>?
-  let opacity: NodeProperty<Vector1D>?
-  let strokeColor: NodeProperty<Color>?
-  let fillColor: NodeProperty<Color>?
-  let strokeWidth: NodeProperty<Vector1D>?
-  let tracking: NodeProperty<Vector1D>?
+  let anchor: NodeProperty<LottieVector3D>?
+  let position: NodeProperty<LottieVector3D>?
+  let scale: NodeProperty<LottieVector3D>?
+  let skew: NodeProperty<LottieVector1D>?
+  let skewAxis: NodeProperty<LottieVector1D>?
+  let rotation: NodeProperty<LottieVector1D>?
+  let opacity: NodeProperty<LottieVector1D>?
+  let strokeColor: NodeProperty<LottieColor>?
+  let fillColor: NodeProperty<LottieColor>?
+  let strokeWidth: NodeProperty<LottieVector1D>?
+  let tracking: NodeProperty<LottieVector1D>?
 
   let keypathProperties: [String: AnyNodeProperty]
   let properties: [AnyNodeProperty]

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

@@ -24,10 +24,10 @@ final class KeyframeData<T> {
     endValue: T?,
     time: AnimationFrameTime?,
     hold: Int?,
-    inTangent: Vector2D?,
-    outTangent: Vector2D?,
-    spatialInTangent: Vector3D?,
-    spatialOutTangent: Vector3D?)
+    inTangent: LottieVector2D?,
+    outTangent: LottieVector2D?,
+    spatialInTangent: LottieVector3D?,
+    spatialOutTangent: LottieVector3D?)
   {
     self.startValue = startValue
     self.endValue = endValue
@@ -62,14 +62,14 @@ final class KeyframeData<T> {
   let hold: Int?
 
   /// The in tangent for the time interpolation curve.
-  let inTangent: Vector2D?
+  let inTangent: LottieVector2D?
   /// The out tangent for the time interpolation curve.
-  let outTangent: Vector2D?
+  let outTangent: LottieVector2D?
 
   /// The spacial in tangent of the vector.
-  let spatialInTangent: Vector3D?
+  let spatialInTangent: LottieVector3D?
   /// The spacial out tangent of the vector.
-  let spatialOutTangent: Vector3D?
+  let spatialOutTangent: LottieVector3D?
 
   var isHold: Bool {
     if let hold = hold {
@@ -95,10 +95,10 @@ extension KeyframeData: DictionaryInitializable where T: AnyInitializable {
     let endValue = try? dictionary[CodingKeys.endValue.rawValue].flatMap(T.init)
     let time: AnimationFrameTime? = try? dictionary.value(for: CodingKeys.time)
     let hold: Int? = try? dictionary.value(for: CodingKeys.hold)
-    let inTangent: Vector2D? = try? dictionary.value(for: CodingKeys.inTangent)
-    let outTangent: Vector2D? = try? dictionary.value(for: CodingKeys.outTangent)
-    let spatialInTangent: Vector3D? = try? dictionary.value(for: CodingKeys.spatialInTangent)
-    let spatialOutTangent: Vector3D? = try? dictionary.value(for: CodingKeys.spatialOutTangent)
+    let inTangent: LottieVector2D? = try? dictionary.value(for: CodingKeys.inTangent)
+    let outTangent: LottieVector2D? = try? dictionary.value(for: CodingKeys.outTangent)
+    let spatialInTangent: LottieVector3D? = try? dictionary.value(for: CodingKeys.spatialInTangent)
+    let spatialOutTangent: LottieVector3D? = try? dictionary.value(for: CodingKeys.spatialOutTangent)
 
     self.init(
       startValue: startValue,

package/Sources/Private/Model/Layers/PreCompLayerModel.swift

@@ -15,7 +15,7 @@ final class PreCompLayerModel: LayerModel {
   required init(from decoder: Decoder) throws {
     let container = try decoder.container(keyedBy: PreCompLayerModel.CodingKeys.self)
     referenceID = try container.decode(String.self, forKey: .referenceID)
-    timeRemapping = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .timeRemapping)
+    timeRemapping = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .timeRemapping)
     width = try container.decode(Double.self, forKey: .width)
     height = try container.decode(Double.self, forKey: .height)
     try super.init(from: decoder)
@@ -24,7 +24,7 @@ final class PreCompLayerModel: LayerModel {
   required init(dictionary: [String: Any]) throws {
     referenceID = try dictionary.value(for: CodingKeys.referenceID)
     if let timeRemappingDictionary = dictionary[CodingKeys.timeRemapping.rawValue] as? [String: Any] {
-      timeRemapping = try KeyframeGroup<Vector1D>(dictionary: timeRemappingDictionary)
+      timeRemapping = try KeyframeGroup<LottieVector1D>(dictionary: timeRemappingDictionary)
     } else {
       timeRemapping = nil
     }
@@ -39,7 +39,7 @@ final class PreCompLayerModel: LayerModel {
   let referenceID: String
 
   /// A value that remaps time over time.
-  let timeRemapping: KeyframeGroup<Vector1D>?
+  let timeRemapping: KeyframeGroup<LottieVector1D>?
 
   /// Precomp Width
   let width: Double

package/Sources/Private/Model/Objects/DashPattern.swift

@@ -28,7 +28,7 @@ final class DashElement: Codable, DictionaryInitializable {
     }
     self.type = type
     let valueDictionary: [String: Any] = try dictionary.value(for: CodingKeys.value)
-    value = try KeyframeGroup<Vector1D>(dictionary: valueDictionary)
+    value = try KeyframeGroup<LottieVector1D>(dictionary: valueDictionary)
   }
 
   // MARK: Internal
@@ -39,6 +39,6 @@ final class DashElement: Codable, DictionaryInitializable {
   }
 
   let type: DashElementType
-  let value: KeyframeGroup<Vector1D>
+  let value: KeyframeGroup<LottieVector1D>
 
 }

package/Sources/Private/Model/Objects/Marker.swift

@@ -15,6 +15,7 @@ final class Marker: Codable, DictionaryInitializable {
   init(dictionary: [String: Any]) throws {
     name = try dictionary.value(for: CodingKeys.name)
     frameTime = try dictionary.value(for: CodingKeys.frameTime)
+    durationFrameTime = try dictionary.value(for: CodingKeys.durationFrameTime)
   }
 
   // MARK: Internal
@@ -22,6 +23,7 @@ final class Marker: Codable, DictionaryInitializable {
   enum CodingKeys: String, CodingKey {
     case name = "cm"
     case frameTime = "tm"
+    case durationFrameTime = "dr"
   }
 
   /// The Marker Name
@@ -30,4 +32,6 @@ final class Marker: Codable, DictionaryInitializable {
   /// The Frame time of the marker
   let frameTime: AnimationFrameTime
 
+  /// The duration of the marker, in frames.
+  let durationFrameTime: AnimationFrameTime
 }

package/Sources/Private/Model/Objects/Mask.swift

@@ -28,10 +28,12 @@ final class Mask: Codable, DictionaryInitializable {
   required init(from decoder: Decoder) throws {
     let container = try decoder.container(keyedBy: Mask.CodingKeys.self)
     mode = try container.decodeIfPresent(MaskMode.self, forKey: .mode) ?? .add
-    opacity = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .opacity) ?? KeyframeGroup(Vector1D(100))
+    opacity = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .opacity) ?? KeyframeGroup(LottieVector1D(100))
     shape = try container.decode(KeyframeGroup<BezierPath>.self, forKey: .shape)
     inverted = try container.decodeIfPresent(Bool.self, forKey: .inverted) ?? false
-    expansion = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .expansion) ?? KeyframeGroup(Vector1D(0))
+    expansion = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .expansion) ?? KeyframeGroup(LottieVector1D(0))
   }
 
   init(dictionary: [String: Any]) throws {
@@ -44,17 +46,17 @@ final class Mask: Codable, DictionaryInitializable {
       mode = .add
     }
     if let opacityDictionary = dictionary[CodingKeys.opacity.rawValue] as? [String: Any] {
-      opacity = try KeyframeGroup<Vector1D>(dictionary: opacityDictionary)
+      opacity = try KeyframeGroup<LottieVector1D>(dictionary: opacityDictionary)
     } else {
-      opacity = KeyframeGroup(Vector1D(100))
+      opacity = KeyframeGroup(LottieVector1D(100))
     }
     let shapeDictionary: [String: Any] = try dictionary.value(for: CodingKeys.shape)
     shape = try KeyframeGroup<BezierPath>(dictionary: shapeDictionary)
     inverted = (try? dictionary.value(for: CodingKeys.inverted)) ?? false
     if let expansionDictionary = dictionary[CodingKeys.expansion.rawValue] as? [String: Any] {
-      expansion = try KeyframeGroup<Vector1D>(dictionary: expansionDictionary)
+      expansion = try KeyframeGroup<LottieVector1D>(dictionary: expansionDictionary)
     } else {
-      expansion = KeyframeGroup(Vector1D(0))
+      expansion = KeyframeGroup(LottieVector1D(0))
     }
   }
 
@@ -70,11 +72,11 @@ final class Mask: Codable, DictionaryInitializable {
 
   let mode: MaskMode
 
-  let opacity: KeyframeGroup<Vector1D>
+  let opacity: KeyframeGroup<LottieVector1D>
 
   let shape: KeyframeGroup<BezierPath>
 
   let inverted: Bool
 
-  let expansion: KeyframeGroup<Vector1D>
+  let expansion: KeyframeGroup<LottieVector1D>
 }

package/Sources/Private/Model/Objects/Transform.swift

@@ -19,23 +19,24 @@ final class Transform: Codable, DictionaryInitializable {
 
     // AnchorPoint
     anchorPoint = try container
-      .decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .anchorPoint) ?? KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+      .decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .anchorPoint) ??
+      KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
 
     // Position
     if container.contains(.positionX), container.contains(.positionY) {
       // Position dimensions are split into two keyframe groups
-      positionX = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .positionX)
-      positionY = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .positionY)
+      positionX = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .positionX)
+      positionY = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .positionY)
       position = nil
-    } else if let positionKeyframes = try? container.decode(KeyframeGroup<Vector3D>.self, forKey: .position) {
+    } else if let positionKeyframes = try? container.decode(KeyframeGroup<LottieVector3D>.self, forKey: .position) {
       // Position dimensions are a single keyframe group.
       position = positionKeyframes
       positionX = nil
       positionY = nil
     } else if
       let positionContainer = try? container.nestedContainer(keyedBy: PositionCodingKeys.self, forKey: .position),
-      let positionX = try? positionContainer.decode(KeyframeGroup<Vector1D>.self, forKey: .positionX),
-      let positionY = try? positionContainer.decode(KeyframeGroup<Vector1D>.self, forKey: .positionY)
+      let positionX = try? positionContainer.decode(KeyframeGroup<LottieVector1D>.self, forKey: .positionX),
+      let positionY = try? positionContainer.decode(KeyframeGroup<LottieVector1D>.self, forKey: .positionY)
     {
       /// Position keyframes are split and nested.
       self.positionX = positionX
@@ -43,49 +44,52 @@ final class Transform: Codable, DictionaryInitializable {
       position = nil
     } else {
       /// Default value.
-      position = KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+      position = KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
       positionX = nil
       positionY = nil
     }
 
     // Scale
     scale = try container
-      .decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .scale) ?? KeyframeGroup(Vector3D(x: Double(100), y: 100, z: 100))
+      .decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .scale) ??
+      KeyframeGroup(LottieVector3D(x: Double(100), y: 100, z: 100))
 
     // Rotation
-    if let rotationZ = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .rotationZ) {
+    if let rotationZ = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationZ) {
       rotation = rotationZ
     } else {
-      rotation = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .rotation) ?? KeyframeGroup(Vector1D(0))
+      rotation = try container
+        .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotation) ?? KeyframeGroup(LottieVector1D(0))
     }
     rotationZ = nil
 
     // Opacity
-    opacity = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .opacity) ?? KeyframeGroup(Vector1D(100))
+    opacity = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .opacity) ?? KeyframeGroup(LottieVector1D(100))
   }
 
   init(dictionary: [String: Any]) throws {
     if
       let anchorPointDictionary = dictionary[CodingKeys.anchorPoint.rawValue] as? [String: Any],
-      let anchorPoint = try? KeyframeGroup<Vector3D>(dictionary: anchorPointDictionary)
+      let anchorPoint = try? KeyframeGroup<LottieVector3D>(dictionary: anchorPointDictionary)
     {
       self.anchorPoint = anchorPoint
     } else {
-      anchorPoint = KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+      anchorPoint = KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
     }
 
     if
       let xDictionary = dictionary[CodingKeys.positionX.rawValue] as? [String: Any],
       let yDictionary = dictionary[CodingKeys.positionY.rawValue] as? [String: Any]
     {
-      positionX = try KeyframeGroup<Vector1D>(dictionary: xDictionary)
-      positionY = try KeyframeGroup<Vector1D>(dictionary: yDictionary)
+      positionX = try KeyframeGroup<LottieVector1D>(dictionary: xDictionary)
+      positionY = try KeyframeGroup<LottieVector1D>(dictionary: yDictionary)
       position = nil
     } else if
       let positionDictionary = dictionary[CodingKeys.position.rawValue] as? [String: Any],
-      positionDictionary[KeyframeGroup<Vector3D>.KeyframeWrapperKey.keyframeData.rawValue] != nil
+      positionDictionary[KeyframeGroup<LottieVector3D>.KeyframeWrapperKey.keyframeData.rawValue] != nil
     {
-      position = try KeyframeGroup<Vector3D>(dictionary: positionDictionary)
+      position = try KeyframeGroup<LottieVector3D>(dictionary: positionDictionary)
       positionX = nil
       positionY = nil
     } else if
@@ -93,44 +97,44 @@ final class Transform: Codable, DictionaryInitializable {
       let xDictionary = positionDictionary[PositionCodingKeys.positionX.rawValue] as? [String: Any],
       let yDictionary = positionDictionary[PositionCodingKeys.positionY.rawValue] as? [String: Any]
     {
-      positionX = try KeyframeGroup<Vector1D>(dictionary: xDictionary)
-      positionY = try KeyframeGroup<Vector1D>(dictionary: yDictionary)
+      positionX = try KeyframeGroup<LottieVector1D>(dictionary: xDictionary)
+      positionY = try KeyframeGroup<LottieVector1D>(dictionary: yDictionary)
       position = nil
     } else {
-      position = KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+      position = KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
       positionX = nil
       positionY = nil
     }
 
     if
       let scaleDictionary = dictionary[CodingKeys.scale.rawValue] as? [String: Any],
-      let scale = try? KeyframeGroup<Vector3D>(dictionary: scaleDictionary)
+      let scale = try? KeyframeGroup<LottieVector3D>(dictionary: scaleDictionary)
     {
       self.scale = scale
     } else {
-      scale = KeyframeGroup(Vector3D(x: Double(100), y: 100, z: 100))
+      scale = KeyframeGroup(LottieVector3D(x: Double(100), y: 100, z: 100))
     }
     if
       let rotationDictionary = dictionary[CodingKeys.rotationZ.rawValue] as? [String: Any],
-      let rotation = try? KeyframeGroup<Vector1D>(dictionary: rotationDictionary)
+      let rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
     {
       self.rotation = rotation
     } else if
       let rotationDictionary = dictionary[CodingKeys.rotation.rawValue] as? [String: Any],
-      let rotation = try? KeyframeGroup<Vector1D>(dictionary: rotationDictionary)
+      let rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
     {
       self.rotation = rotation
     } else {
-      rotation = KeyframeGroup(Vector1D(0))
+      rotation = KeyframeGroup(LottieVector1D(0))
     }
     rotationZ = nil
     if
       let opacityDictionary = dictionary[CodingKeys.opacity.rawValue] as? [String: Any],
-      let opacity = try? KeyframeGroup<Vector1D>(dictionary: opacityDictionary)
+      let opacity = try? KeyframeGroup<LottieVector1D>(dictionary: opacityDictionary)
     {
       self.opacity = opacity
     } else {
-      opacity = KeyframeGroup(Vector1D(100))
+      opacity = KeyframeGroup(LottieVector1D(100))
     }
   }
 
@@ -154,26 +158,26 @@ final class Transform: Codable, DictionaryInitializable {
   }
 
   /// The anchor point of the transform.
-  let anchorPoint: KeyframeGroup<Vector3D>
+  let anchorPoint: KeyframeGroup<LottieVector3D>
 
   /// The position of the transform. This is nil if the position data was split.
-  let position: KeyframeGroup<Vector3D>?
+  let position: KeyframeGroup<LottieVector3D>?
 
   /// The positionX of the transform. This is nil if the position property is set.
-  let positionX: KeyframeGroup<Vector1D>?
+  let positionX: KeyframeGroup<LottieVector1D>?
 
   /// The positionY of the transform. This is nil if the position property is set.
-  let positionY: KeyframeGroup<Vector1D>?
+  let positionY: KeyframeGroup<LottieVector1D>?
 
   /// The scale of the transform
-  let scale: KeyframeGroup<Vector3D>
+  let scale: KeyframeGroup<LottieVector3D>
 
   /// The rotation of the transform. Note: This is single dimensional rotation.
-  let rotation: KeyframeGroup<Vector1D>
+  let rotation: KeyframeGroup<LottieVector1D>
 
   /// The opacity of the transform.
-  let opacity: KeyframeGroup<Vector1D>
+  let opacity: KeyframeGroup<LottieVector1D>
 
   /// Should always be nil.
-  let rotationZ: KeyframeGroup<Vector1D>?
+  let rotationZ: KeyframeGroup<LottieVector1D>?
 }

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

@@ -24,8 +24,8 @@ final class Ellipse: ShapeItem {
   required init(from decoder: Decoder) throws {
     let container = try decoder.container(keyedBy: Ellipse.CodingKeys.self)
     direction = try container.decodeIfPresent(PathDirection.self, forKey: .direction) ?? .clockwise
-    position = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .position)
-    size = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .size)
+    position = try container.decode(KeyframeGroup<LottieVector3D>.self, forKey: .position)
+    size = try container.decode(KeyframeGroup<LottieVector3D>.self, forKey: .size)
     try super.init(from: decoder)
   }
 
@@ -39,9 +39,9 @@ final class Ellipse: ShapeItem {
       direction = .clockwise
     }
     let positionDictionary: [String: Any] = try dictionary.value(for: CodingKeys.position)
-    position = try KeyframeGroup<Vector3D>(dictionary: positionDictionary)
+    position = try KeyframeGroup<LottieVector3D>(dictionary: positionDictionary)
     let sizeDictionary: [String: Any] = try dictionary.value(for: CodingKeys.size)
-    size = try KeyframeGroup<Vector3D>(dictionary: sizeDictionary)
+    size = try KeyframeGroup<LottieVector3D>(dictionary: sizeDictionary)
     try super.init(dictionary: dictionary)
   }
 
@@ -51,10 +51,10 @@ final class Ellipse: ShapeItem {
   let direction: PathDirection
 
   /// The position of the ellipse
-  let position: KeyframeGroup<Vector3D>
+  let position: KeyframeGroup<LottieVector3D>
 
   /// The size of the ellipse
-  let size: KeyframeGroup<Vector3D>
+  let size: KeyframeGroup<LottieVector3D>
 
   override func encode(to encoder: Encoder) throws {
     try super.encode(to: encoder)

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

@@ -23,17 +23,17 @@ final class Fill: ShapeItem {
 
   required init(from decoder: Decoder) throws {
     let container = try decoder.container(keyedBy: Fill.CodingKeys.self)
-    opacity = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .opacity)
-    color = try container.decode(KeyframeGroup<Color>.self, forKey: .color)
+    opacity = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .opacity)
+    color = try container.decode(KeyframeGroup<LottieColor>.self, forKey: .color)
     fillRule = try container.decodeIfPresent(FillRule.self, forKey: .fillRule) ?? .nonZeroWinding
     try super.init(from: decoder)
   }
 
   required init(dictionary: [String: Any]) throws {
     let opacityDictionary: [String: Any] = try dictionary.value(for: CodingKeys.opacity)
-    opacity = try KeyframeGroup<Vector1D>(dictionary: opacityDictionary)
+    opacity = try KeyframeGroup<LottieVector1D>(dictionary: opacityDictionary)
     let colorDictionary: [String: Any] = try dictionary.value(for: CodingKeys.color)
-    color = try KeyframeGroup<Color>(dictionary: colorDictionary)
+    color = try KeyframeGroup<LottieColor>(dictionary: colorDictionary)
     if
       let fillRuleRawValue = dictionary[CodingKeys.fillRule.rawValue] as? Int,
       let fillRule = FillRule(rawValue: fillRuleRawValue)
@@ -48,10 +48,10 @@ final class Fill: ShapeItem {
   // MARK: Internal
 
   /// The opacity of the fill
-  let opacity: KeyframeGroup<Vector1D>
+  let opacity: KeyframeGroup<LottieVector1D>
 
   /// The color keyframes for the fill
-  let color: KeyframeGroup<Color>
+  let color: KeyframeGroup<LottieColor>
 
   /// The fill rule to use when filling a path
   let fillRule: FillRule

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

@@ -23,12 +23,12 @@ final class GradientFill: ShapeItem {
 
   required init(from decoder: Decoder) throws {
     let container = try decoder.container(keyedBy: GradientFill.CodingKeys.self)
-    opacity = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .opacity)
-    startPoint = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .startPoint)
-    endPoint = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .endPoint)
+    opacity = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .opacity)
+    startPoint = try container.decode(KeyframeGroup<LottieVector3D>.self, forKey: .startPoint)
+    endPoint = try container.decode(KeyframeGroup<LottieVector3D>.self, forKey: .endPoint)
     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)
+    highlightLength = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .highlightLength)
+    highlightAngle = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.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)
@@ -38,23 +38,23 @@ final class GradientFill: ShapeItem {
 
   required init(dictionary: [String: Any]) throws {
     let opacityDictionary: [String: Any] = try dictionary.value(for: CodingKeys.opacity)
-    opacity = try KeyframeGroup<Vector1D>(dictionary: opacityDictionary)
+    opacity = try KeyframeGroup<LottieVector1D>(dictionary: opacityDictionary)
     let startPointDictionary: [String: Any] = try dictionary.value(for: CodingKeys.startPoint)
-    startPoint = try KeyframeGroup<Vector3D>(dictionary: startPointDictionary)
+    startPoint = try KeyframeGroup<LottieVector3D>(dictionary: startPointDictionary)
     let endPointDictionary: [String: Any] = try dictionary.value(for: CodingKeys.endPoint)
-    endPoint = try KeyframeGroup<Vector3D>(dictionary: endPointDictionary)
+    endPoint = try KeyframeGroup<LottieVector3D>(dictionary: endPointDictionary)
     let gradientRawType: Int = try dictionary.value(for: CodingKeys.gradientType)
     guard let gradient = GradientType(rawValue: gradientRawType) else {
       throw InitializableError.invalidInput
     }
     gradientType = gradient
     if let highlightLengthDictionary = dictionary[CodingKeys.highlightLength.rawValue] as? [String: Any] {
-      highlightLength = try? KeyframeGroup<Vector1D>(dictionary: highlightLengthDictionary)
+      highlightLength = try? KeyframeGroup<LottieVector1D>(dictionary: highlightLengthDictionary)
     } else {
       highlightLength = nil
     }
     if let highlightAngleDictionary = dictionary[CodingKeys.highlightAngle.rawValue] as? [String: Any] {
-      highlightAngle = try? KeyframeGroup<Vector1D>(dictionary: highlightAngleDictionary)
+      highlightAngle = try? KeyframeGroup<LottieVector1D>(dictionary: highlightAngleDictionary)
     } else {
       highlightAngle = nil
     }
@@ -76,22 +76,22 @@ final class GradientFill: ShapeItem {
   // MARK: Internal
 
   /// The opacity of the fill
-  let opacity: KeyframeGroup<Vector1D>
+  let opacity: KeyframeGroup<LottieVector1D>
 
   /// The start of the gradient
-  let startPoint: KeyframeGroup<Vector3D>
+  let startPoint: KeyframeGroup<LottieVector3D>
 
   /// The end of the gradient
-  let endPoint: KeyframeGroup<Vector3D>
+  let endPoint: KeyframeGroup<LottieVector3D>
 
   /// The type of gradient
   let gradientType: GradientType
 
   /// Gradient Highlight Length. Only if type is Radial
-  let highlightLength: KeyframeGroup<Vector1D>?
+  let highlightLength: KeyframeGroup<LottieVector1D>?
 
   /// Highlight Angle. Only if type is Radial
-  let highlightAngle: KeyframeGroup<Vector1D>?
+  let highlightAngle: KeyframeGroup<LottieVector1D>?
 
   /// The number of color points in the gradient
   let numberOfColors: Int