@octane-xplat/lottie 0.9.0 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Private/Model/ShapeItems/Repeater.swift

@@ -0,0 +1,181 @@
+//
+//  Repeater.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+// MARK: - Repeater
+
+final class Repeater: ShapeItem {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Repeater.CodingKeys.self)
+    copies = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .copies) ?? KeyframeGroup(LottieVector1D(0))
+    offset = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .offset) ?? KeyframeGroup(LottieVector1D(0))
+    let transformContainer = try container.nestedContainer(keyedBy: TransformKeys.self, forKey: .transform)
+    startOpacity = try transformContainer
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .startOpacity) ?? KeyframeGroup(LottieVector1D(100))
+    endOpacity = try transformContainer
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .endOpacity) ?? KeyframeGroup(LottieVector1D(100))
+    if let rotation = try transformContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotation) {
+      rotationZ = rotation
+    } else if let rotation = try transformContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationZ) {
+      rotationZ = rotation
+    } else {
+      rotationZ = KeyframeGroup(LottieVector1D(0))
+    }
+
+    rotationX = try transformContainer
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationX) ?? KeyframeGroup(LottieVector1D(0))
+    rotationY = try transformContainer
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationY) ?? KeyframeGroup(LottieVector1D(0))
+
+    position = try transformContainer
+      .decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .position) ??
+      KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
+    anchorPoint = try transformContainer
+      .decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .anchorPoint) ??
+      KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
+    scale = try transformContainer
+      .decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .scale) ??
+      KeyframeGroup(LottieVector3D(x: Double(100), y: 100, z: 100))
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    if let copiesDictionary = dictionary[CodingKeys.copies.rawValue] as? [String: Any] {
+      copies = try KeyframeGroup<LottieVector1D>(dictionary: copiesDictionary)
+    } else {
+      copies = KeyframeGroup(LottieVector1D(0))
+    }
+    if let offsetDictionary = dictionary[CodingKeys.offset.rawValue] as? [String: Any] {
+      offset = try KeyframeGroup<LottieVector1D>(dictionary: offsetDictionary)
+    } else {
+      offset = KeyframeGroup(LottieVector1D(0))
+    }
+    let transformDictionary: [String: Any] = try dictionary.value(for: CodingKeys.transform)
+    if let startOpacityDictionary = transformDictionary[TransformKeys.startOpacity.rawValue] as? [String: Any] {
+      startOpacity = try KeyframeGroup<LottieVector1D>(dictionary: startOpacityDictionary)
+    } else {
+      startOpacity = KeyframeGroup(LottieVector1D(100))
+    }
+    if let endOpacityDictionary = transformDictionary[TransformKeys.endOpacity.rawValue] as? [String: Any] {
+      endOpacity = try KeyframeGroup<LottieVector1D>(dictionary: endOpacityDictionary)
+    } else {
+      endOpacity = KeyframeGroup(LottieVector1D(100))
+    }
+    if let rotationDictionary = transformDictionary[TransformKeys.rotationX.rawValue] as? [String: Any] {
+      rotationX = try KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    } else {
+      rotationX = KeyframeGroup(LottieVector1D(0))
+    }
+    if let rotationDictionary = transformDictionary[TransformKeys.rotationY.rawValue] as? [String: Any] {
+      rotationY = try KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    } else {
+      rotationY = KeyframeGroup(LottieVector1D(0))
+    }
+    if let rotationDictionary = transformDictionary[TransformKeys.rotation.rawValue] as? [String: Any] {
+      rotationZ = try KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    } else if let rotationDictionary = transformDictionary[TransformKeys.rotationZ.rawValue] as? [String: Any] {
+      rotationZ = try KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    } else {
+      rotationZ = KeyframeGroup(LottieVector1D(0))
+    }
+    if let positionDictionary = transformDictionary[TransformKeys.position.rawValue] as? [String: Any] {
+      position = try KeyframeGroup<LottieVector3D>(dictionary: positionDictionary)
+    } else {
+      position = KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
+    }
+    if let anchorPointDictionary = transformDictionary[TransformKeys.anchorPoint.rawValue] as? [String: Any] {
+      anchorPoint = try KeyframeGroup<LottieVector3D>(dictionary: anchorPointDictionary)
+    } else {
+      anchorPoint = KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
+    }
+    if let scaleDictionary = transformDictionary[TransformKeys.scale.rawValue] as? [String: Any] {
+      scale = try KeyframeGroup<LottieVector3D>(dictionary: scaleDictionary)
+    } else {
+      scale = KeyframeGroup(LottieVector3D(x: Double(100), y: 100, z: 100))
+    }
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The number of copies to repeat
+  let copies: KeyframeGroup<LottieVector1D>
+
+  /// The offset of each copy
+  let offset: KeyframeGroup<LottieVector1D>
+
+  /// Start Opacity
+  let startOpacity: KeyframeGroup<LottieVector1D>
+
+  /// End opacity
+  let endOpacity: KeyframeGroup<LottieVector1D>
+
+  /// The rotation on X axis
+  let rotationX: KeyframeGroup<LottieVector1D>
+
+  /// The rotation on Y axis
+  let rotationY: KeyframeGroup<LottieVector1D>
+
+  /// The rotation on Z axis
+  let rotationZ: KeyframeGroup<LottieVector1D>
+
+  /// Anchor Point
+  let anchorPoint: KeyframeGroup<LottieVector3D>
+
+  /// Position
+  let position: KeyframeGroup<LottieVector3D>
+
+  /// Scale
+  let scale: KeyframeGroup<LottieVector3D>
+
+  override func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(copies, forKey: .copies)
+    try container.encode(offset, forKey: .offset)
+    var transformContainer = container.nestedContainer(keyedBy: TransformKeys.self, forKey: .transform)
+    try transformContainer.encode(startOpacity, forKey: .startOpacity)
+    try transformContainer.encode(endOpacity, forKey: .endOpacity)
+    try transformContainer.encode(rotationX, forKey: .rotationX)
+    try transformContainer.encode(rotationY, forKey: .rotationY)
+    try transformContainer.encode(rotationZ, forKey: .rotationZ)
+    try transformContainer.encode(position, forKey: .position)
+    try transformContainer.encode(anchorPoint, forKey: .anchorPoint)
+    try transformContainer.encode(scale, forKey: .scale)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case copies = "c"
+    case offset = "o"
+    case transform = "tr"
+  }
+
+  private enum TransformKeys: String, CodingKey {
+    case rotation = "r"
+    case rotationX = "rx"
+    case rotationY = "ry"
+    case rotationZ = "rz"
+    case startOpacity = "so"
+    case endOpacity = "eo"
+    case anchorPoint = "a"
+    case position = "p"
+    case scale = "s"
+  }
+}
+
+// MARK: @unchecked Sendable
+
+/// `Repeater` inherits `@unchecked Sendable` from `ShapeItem` and
+/// we need to restate that here to avoid a warning in Xcode 16
+// swiftlint:disable:next no_unchecked_sendable
+extension Repeater: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/ShapeItems/RoundedCorners.swift

@@ -0,0 +1,53 @@
+//
+//  RoundedCorners.swift
+//  Lottie
+//
+//  Created by Duolingo on 10/31/22.
+//
+
+// MARK: - RoundedCorners
+
+final class RoundedCorners: ShapeItem {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: RoundedCorners.CodingKeys.self)
+    radius = try
+      container.decode(
+        KeyframeGroup<LottieVector1D>.self,
+        forKey: .radius
+      )
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    let radiusDictionary: [String: Any] = try dictionary.value(for: CodingKeys.radius)
+    radius = try KeyframeGroup<LottieVector1D>(dictionary: radiusDictionary)
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The radius of rounded corners
+  let radius: KeyframeGroup<LottieVector1D>
+
+  override func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(radius, forKey: .radius)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case radius = "r"
+  }
+}
+
+// MARK: @unchecked Sendable
+
+/// `RoundedCorners` inherits `@unchecked Sendable` from `ShapeItem` and
+/// we need to restate that here to avoid a warning in Xcode 16
+// swiftlint:disable:next no_unchecked_sendable
+extension RoundedCorners: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/ShapeItems/Shape.swift

@@ -0,0 +1,63 @@
+//
+//  VectorShape.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+// MARK: - Shape
+
+/// An item that defines an custom shape
+final class Shape: ShapeItem {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Shape.CodingKeys.self)
+    path = try container.decode(KeyframeGroup<BezierPath>.self, forKey: .path)
+    direction = try container.decodeIfPresent(PathDirection.self, forKey: .direction)
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    let pathDictionary: [String: Any] = try dictionary.value(for: CodingKeys.path)
+    path = try KeyframeGroup<BezierPath>(dictionary: pathDictionary)
+    if
+      let directionRawValue = dictionary[CodingKeys.direction.rawValue] as? Int,
+      let direction = PathDirection(rawValue: directionRawValue)
+    {
+      self.direction = direction
+    } else {
+      direction = nil
+    }
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The Path
+  let path: KeyframeGroup<BezierPath>
+
+  let direction: PathDirection?
+
+  override func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(path, forKey: .path)
+    try container.encodeIfPresent(direction, forKey: .direction)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case path = "ks"
+    case direction = "d"
+  }
+}
+
+// MARK: @unchecked Sendable
+
+/// `Shape` inherits `@unchecked Sendable` from `ShapeItem` and
+/// we need to restate that here to avoid a warning in Xcode 16
+// swiftlint:disable:next no_unchecked_sendable
+extension Shape: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/ShapeItems/ShapeItem.swift

@@ -0,0 +1,171 @@
+//
+//  ShapeItem.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+// MARK: - ShapeType
+
+enum ShapeType: String, Codable, Sendable {
+  case ellipse = "el"
+  case fill = "fl"
+  case gradientFill = "gf"
+  case group = "gr"
+  case gradientStroke = "gs"
+  case merge = "mm"
+  case rectangle = "rc"
+  case repeater = "rp"
+  case round = "rd"
+  case shape = "sh"
+  case star = "sr"
+  case stroke = "st"
+  case trim = "tm"
+  case transform = "tr"
+  case unknown
+
+  init(from decoder: Decoder) throws {
+    self = try ShapeType(rawValue: decoder.singleValueContainer().decode(RawValue.self)) ?? .unknown
+  }
+}
+
+// MARK: ClassFamily
+
+extension ShapeType: ClassFamily {
+
+  static var discriminator = Discriminator.type
+
+  func getType() -> AnyObject.Type {
+    switch self {
+    case .ellipse:
+      Ellipse.self
+    case .fill:
+      Fill.self
+    case .gradientFill:
+      GradientFill.self
+    case .group:
+      Group.self
+    case .gradientStroke:
+      GradientStroke.self
+    case .merge:
+      Merge.self
+    case .rectangle:
+      Rectangle.self
+    case .repeater:
+      Repeater.self
+    case .round:
+      RoundedCorners.self
+    case .shape:
+      Shape.self
+    case .star:
+      Star.self
+    case .stroke:
+      Stroke.self
+    case .trim:
+      Trim.self
+    case .transform:
+      ShapeTransform.self
+    default:
+      ShapeItem.self
+    }
+  }
+}
+
+// MARK: - ShapeItem
+
+/// Base class for items belonging to a Shape Layer
+class ShapeItem: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: ShapeItem.CodingKeys.self)
+    name = try container.decodeIfPresent(String.self, forKey: .name) ?? "Layer"
+    type = try container.decode(ShapeType.self, forKey: .type)
+    hidden = try container.decodeIfPresent(Bool.self, forKey: .hidden) ?? false
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    name = (try? dictionary.value(for: CodingKeys.name)) ?? "Layer"
+    type = ShapeType(rawValue: try dictionary.value(for: CodingKeys.type)) ?? .unknown
+    hidden = (try? dictionary.value(for: CodingKeys.hidden)) ?? false
+  }
+
+  init(
+    name: String,
+    type: ShapeType,
+    hidden: Bool
+  ) {
+    self.name = name
+    self.type = type
+    self.hidden = hidden
+  }
+
+  // MARK: Internal
+
+  /// The name of the shape
+  let name: String
+
+  /// The type of shape
+  let type: ShapeType
+
+  let hidden: Bool
+
+  // MARK: Fileprivate
+
+  fileprivate enum CodingKeys: String, CodingKey {
+    case name = "nm"
+    case type = "ty"
+    case hidden = "hd"
+  }
+}
+
+extension [ShapeItem] {
+
+  static func fromDictionaries(_ dictionaries: [[String: Any]]) throws -> [ShapeItem] {
+    try dictionaries.compactMap { dictionary in
+      let shapeType = dictionary[ShapeItem.CodingKeys.type.rawValue] as? String
+      switch ShapeType(rawValue: shapeType ?? ShapeType.unknown.rawValue) {
+      case .ellipse:
+        return try Ellipse(dictionary: dictionary)
+      case .fill:
+        return try Fill(dictionary: dictionary)
+      case .gradientFill:
+        return try GradientFill(dictionary: dictionary)
+      case .group:
+        return try Group(dictionary: dictionary)
+      case .gradientStroke:
+        return try GradientStroke(dictionary: dictionary)
+      case .merge:
+        return try Merge(dictionary: dictionary)
+      case .rectangle:
+        return try Rectangle(dictionary: dictionary)
+      case .repeater:
+        return try Repeater(dictionary: dictionary)
+      case .round:
+        return try RoundedCorners(dictionary: dictionary)
+      case .shape:
+        return try Shape(dictionary: dictionary)
+      case .star:
+        return try Star(dictionary: dictionary)
+      case .stroke:
+        return try Stroke(dictionary: dictionary)
+      case .trim:
+        return try Trim(dictionary: dictionary)
+      case .transform:
+        return try ShapeTransform(dictionary: dictionary)
+      case .none:
+        return nil
+      default:
+        return try ShapeItem(dictionary: dictionary)
+      }
+    }
+  }
+}
+
+// MARK: - ShapeItem + @unchecked Sendable
+
+/// Since `ShapeItem` isn't `final`, we have to use `@unchecked Sendable` instead of `Sendable.`
+/// All `ShapeItem` subclasses are immutable `Sendable` values.
+// swiftlint:disable:next no_unchecked_sendable
+extension ShapeItem: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/ShapeItems/ShapeTransform.swift

@@ -0,0 +1,202 @@
+//
+//  TransformItem.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+// MARK: - ShapeTransform
+
+final class ShapeTransform: ShapeItem {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: ShapeTransform.CodingKeys.self)
+    anchor = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .anchor) ??
+      KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
+    position = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .position) ??
+      KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
+    scale = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .scale) ??
+      KeyframeGroup(LottieVector3D(x: Double(100), y: 100, z: 100))
+
+    rotationX = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationX) ?? KeyframeGroup(LottieVector1D(0))
+    rotationY = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationY) ?? KeyframeGroup(LottieVector1D(0))
+    if
+      let rotation = try container
+        .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotation)
+    {
+      rotationZ = rotation
+    } else if
+      let rotation = try container
+        .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationZ)
+    {
+      rotationZ = rotation
+    } else {
+      rotationZ = KeyframeGroup(LottieVector1D(0))
+    }
+
+    opacity = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .opacity) ?? KeyframeGroup(LottieVector1D(100))
+    skew = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .skew) ?? KeyframeGroup(LottieVector1D(0))
+    skewAxis = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .skewAxis) ?? KeyframeGroup(LottieVector1D(0))
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    if
+      let anchorDictionary = dictionary[CodingKeys.anchor.rawValue] as? [String: Any],
+      let anchor = try? KeyframeGroup<LottieVector3D>(dictionary: anchorDictionary)
+    {
+      self.anchor = anchor
+    } else {
+      anchor = KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
+    }
+    if
+      let positionDictionary = dictionary[CodingKeys.position.rawValue] as? [String: Any],
+      let position = try? KeyframeGroup<LottieVector3D>(dictionary: positionDictionary)
+    {
+      self.position = position
+    } else {
+      position = KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
+    }
+    if
+      let scaleDictionary = dictionary[CodingKeys.scale.rawValue] as? [String: Any],
+      let scale = try? KeyframeGroup<LottieVector3D>(dictionary: scaleDictionary)
+    {
+      self.scale = scale
+    } else {
+      scale = KeyframeGroup(LottieVector3D(x: Double(100), y: 100, z: 100))
+    }
+
+    if
+      let rotationDictionary = dictionary[CodingKeys.rotationX.rawValue] as? [String: Any],
+      let rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    {
+      rotationX = rotation
+    } else {
+      rotationX = KeyframeGroup(LottieVector1D(0))
+    }
+
+    if
+      let rotationDictionary = dictionary[CodingKeys.rotationY.rawValue] as? [String: Any],
+      let rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    {
+      rotationY = rotation
+    } else {
+      rotationY = KeyframeGroup(LottieVector1D(0))
+    }
+
+    if
+      let rotationDictionary = dictionary[CodingKeys.rotation.rawValue] as? [String: Any],
+      let rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    {
+      rotationZ = rotation
+    } else if
+      let rotationDictionary = dictionary[CodingKeys.rotationZ.rawValue] as? [String: Any],
+      let rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    {
+      rotationZ = rotation
+    } else {
+      rotationZ = KeyframeGroup(LottieVector1D(0))
+    }
+
+    if
+      let opacityDictionary = dictionary[CodingKeys.opacity.rawValue] as? [String: Any],
+      let opacity = try? KeyframeGroup<LottieVector1D>(dictionary: opacityDictionary)
+    {
+      self.opacity = opacity
+    } else {
+      opacity = KeyframeGroup(LottieVector1D(100))
+    }
+    if
+      let skewDictionary = dictionary[CodingKeys.skew.rawValue] as? [String: Any],
+      let skew = try? KeyframeGroup<LottieVector1D>(dictionary: skewDictionary)
+    {
+      self.skew = skew
+    } else {
+      skew = KeyframeGroup(LottieVector1D(0))
+    }
+    if
+      let skewAxisDictionary = dictionary[CodingKeys.skewAxis.rawValue] as? [String: Any],
+      let skewAxis = try? KeyframeGroup<LottieVector1D>(dictionary: skewAxisDictionary)
+    {
+      self.skewAxis = skewAxis
+    } else {
+      skewAxis = KeyframeGroup(LottieVector1D(0))
+    }
+
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// Anchor Point
+  let anchor: KeyframeGroup<LottieVector3D>
+
+  /// Position
+  let position: KeyframeGroup<LottieVector3D>
+
+  /// Scale
+  let scale: KeyframeGroup<LottieVector3D>
+
+  /// Rotation on X axis
+  let rotationX: KeyframeGroup<LottieVector1D>
+
+  /// Rotation on Y axis
+  let rotationY: KeyframeGroup<LottieVector1D>
+
+  /// Rotation on Z axis
+  let rotationZ: KeyframeGroup<LottieVector1D>
+
+  /// opacity
+  let opacity: KeyframeGroup<LottieVector1D>
+
+  /// Skew
+  let skew: KeyframeGroup<LottieVector1D>
+
+  /// Skew Axis
+  let skewAxis: KeyframeGroup<LottieVector1D>
+
+  override func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(anchor, forKey: .anchor)
+    try container.encode(position, forKey: .position)
+    try container.encode(scale, forKey: .scale)
+    try container.encode(rotationX, forKey: .rotationX)
+    try container.encode(rotationY, forKey: .rotationY)
+    try container.encode(rotationZ, forKey: .rotationZ)
+    try container.encode(opacity, forKey: .opacity)
+    try container.encode(skew, forKey: .skew)
+    try container.encode(skewAxis, forKey: .skewAxis)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case anchor = "a"
+    case position = "p"
+    case scale = "s"
+    case rotation = "r"
+    case rotationX = "rx"
+    case rotationY = "ry"
+    case rotationZ = "rz"
+    case opacity = "o"
+    case skew = "sk"
+    case skewAxis = "sa"
+  }
+}
+
+// MARK: @unchecked Sendable
+
+/// `ShapeTransform` inherits `@unchecked Sendable` from `ShapeItem` and
+/// we need to restate that here to avoid a warning in Xcode 16
+// swiftlint:disable:next no_unchecked_sendable
+extension ShapeTransform: @unchecked Sendable { }