lottie-ios 3.4.1 → 3.4.2

package/Sources/Private/CoreAnimation/Animations/GradientAnimations.swift

@@ -104,10 +104,10 @@ extension GradientRenderLayer {
     // at any given time requires knowing the current `startPoint`,
     // we can't allow them to animate separately.
     let absoluteStartPoint = try gradient.startPoint
-      .exactlyOneKeyframe(context: context, description: "gradient startPoint").value.pointValue
+      .exactlyOneKeyframe(context: context, description: "gradient startPoint").pointValue
 
     let absoluteEndPoint = try gradient.endPoint
-      .exactlyOneKeyframe(context: context, description: "gradient endPoint").value.pointValue
+      .exactlyOneKeyframe(context: context, description: "gradient endPoint").pointValue
 
     startPoint = percentBasedPointInBounds(from: absoluteStartPoint)
 

package/Sources/Private/CoreAnimation/Animations/RectangleAnimation.swift

@@ -14,14 +14,12 @@ extension CAShapeLayer {
   {
     try addAnimation(
       for: .path,
-      keyframes: rectangle.size.keyframes,
-      value: { sizeKeyframe in
+      keyframes: try rectangle.combinedKeyframes(context: context).keyframes,
+      value: { keyframe in
         BezierPath.rectangle(
-          position: try rectangle.position
-            .exactlyOneKeyframe(context: context, description: "rectangle position").value.pointValue,
-          size: sizeKeyframe.sizeValue,
-          cornerRadius: try rectangle.cornerRadius
-            .exactlyOneKeyframe(context: context, description: "rectangle cornerRadius").value.cgFloatValue,
+          position: keyframe.position.pointValue,
+          size: keyframe.size.sizeValue,
+          cornerRadius: keyframe.cornerRadius.cgFloatValue,
           direction: rectangle.direction)
           .cgPath()
           .duplicated(times: pathMultiplier)
@@ -29,3 +27,32 @@ extension CAShapeLayer {
       context: context)
   }
 }
+
+extension Rectangle {
+  /// Data that represents how to render a rectangle at a specific point in time
+  struct Keyframe {
+    let size: Vector3D
+    let position: Vector3D
+    let cornerRadius: Vector1D
+  }
+
+  /// Creates a single array of animatable keyframes from the separate arrays of keyframes in this Rectangle
+  func combinedKeyframes(context: LayerAnimationContext) throws-> KeyframeGroup<Rectangle.Keyframe> {
+    let combinedKeyframes = Keyframes.combinedIfPossible(
+      size, position, cornerRadius,
+      makeCombinedResult: Rectangle.Keyframe.init)
+
+    if let combinedKeyframes = combinedKeyframes {
+      return combinedKeyframes
+    } else {
+      // If we weren't able to combine all of the keyframes, we have to take the timing values
+      // from one property and use a fixed value for the other properties.
+      return try size.map { sizeValue in
+        Keyframe(
+          size: sizeValue,
+          position: try position.exactlyOneKeyframe(context: context, description: "rectangle position"),
+          cornerRadius: try cornerRadius.exactlyOneKeyframe(context: context, description: "rectangle cornerRadius"))
+      }
+    }
+  }
+}

package/Sources/Private/CoreAnimation/Animations/ShapeAnimation.swift

@@ -120,25 +120,36 @@ extension Trim {
     let interpolatedStrokeEnd = strokeEnd.manuallyInterpolateKeyframes()
     let interpolatedStrokeOffset = offset.manuallyInterpolateKeyframes()
 
-    let adjustedStrokeStart = try adjustKeyframesForTrimOffsets(
-      strokeKeyframes: interpolatedStrokeStart,
-      offsetKeyframes: interpolatedStrokeOffset,
-      context: context)
-
-    let adjustedStrokeEnd = try adjustKeyframesForTrimOffsets(
-      strokeKeyframes: interpolatedStrokeEnd,
-      offsetKeyframes: interpolatedStrokeOffset,
-      context: context)
+    var adjustedStrokeStart = KeyframeGroup(
+      keyframes: try adjustKeyframesForTrimOffsets(
+        strokeKeyframes: interpolatedStrokeStart,
+        offsetKeyframes: interpolatedStrokeOffset,
+        context: context))
+
+    var adjustedStrokeEnd = KeyframeGroup(
+      keyframes: try adjustKeyframesForTrimOffsets(
+        strokeKeyframes: interpolatedStrokeEnd,
+        offsetKeyframes: interpolatedStrokeOffset,
+        context: context))
 
     // If maximum stroke value is larger than 100%, then we have to create copies of the path
     // so the total path length includes the maximum stroke
-    let maximumStroke = adjustedStrokeEnd.map { $0.value.cgFloatValue }.max() ?? 100
-    let pathMultiplier = Int(ceil(maximumStroke / 100.0))
+    let startStrokes = adjustedStrokeStart.keyframes.map { $0.value.cgFloatValue }
+    let endStrokes = adjustedStrokeEnd.keyframes.map { $0.value.cgFloatValue }
+    let minimumStrokeMultiplier = Double(floor((startStrokes.min() ?? 0) / 100.0))
+    let maximumStrokeMultiplier = Double(ceil((endStrokes.max() ?? 100) / 100.0))
+
+    if minimumStrokeMultiplier < 0 {
+      // Core Animation doesn't support negative stroke offsets, so we have to
+      // shift all of the offset values up by the minimum
+      adjustedStrokeStart = adjustedStrokeStart.map { Vector1D($0.value + (abs(minimumStrokeMultiplier) * 100.0)) }
+      adjustedStrokeEnd = adjustedStrokeEnd.map { Vector1D($0.value + (abs(minimumStrokeMultiplier) * 100.0)) }
+    }
 
     return (
-      strokeStart: KeyframeGroup<Vector1D>(keyframes: adjustedStrokeStart),
-      strokeEnd: KeyframeGroup<Vector1D>(keyframes: adjustedStrokeEnd),
-      pathMultiplier: pathMultiplier)
+      strokeStart: adjustedStrokeStart,
+      strokeEnd: adjustedStrokeEnd,
+      pathMultiplier: Int(abs(maximumStrokeMultiplier) + abs(minimumStrokeMultiplier)))
   }
 
   // MARK: Private

package/Sources/Private/CoreAnimation/Animations/StarAnimation.swift

@@ -36,25 +36,16 @@ extension CAShapeLayer {
   {
     try addAnimation(
       for: .path,
-      keyframes: star.position.keyframes,
-      value: { position in
-        // We can only use one set of keyframes to animate a given CALayer keypath,
-        // so we currently animate `position` and ignore any other keyframes.
-        // TODO: Is there a way to support this properly?
+      keyframes: try star.combinedKeyframes(context: context).keyframes,
+      value: { keyframe in
         BezierPath.star(
-          position: position.pointValue,
-          outerRadius: try star.outerRadius
-            .exactlyOneKeyframe(context: context, description: "outerRadius").value.cgFloatValue,
-          innerRadius: try star.innerRadius?
-            .exactlyOneKeyframe(context: context, description: "innerRadius").value.cgFloatValue ?? 0,
-          outerRoundedness: try star.outerRoundness
-            .exactlyOneKeyframe(context: context, description: "outerRoundness").value.cgFloatValue,
-          innerRoundedness: try star.innerRoundness?
-            .exactlyOneKeyframe(context: context, description: "innerRoundness").value.cgFloatValue ?? 0,
-          numberOfPoints: try star.points
-            .exactlyOneKeyframe(context: context, description: "points").value.cgFloatValue,
-          rotation: try star.rotation
-            .exactlyOneKeyframe(context: context, description: "rotation").value.cgFloatValue,
+          position: keyframe.position.pointValue,
+          outerRadius: keyframe.outerRadius.cgFloatValue,
+          innerRadius: keyframe.innerRadius.cgFloatValue,
+          outerRoundedness: keyframe.outerRoundness.cgFloatValue,
+          innerRoundedness: keyframe.innerRoundness.cgFloatValue,
+          numberOfPoints: keyframe.points.cgFloatValue,
+          rotation: keyframe.rotation.cgFloatValue,
           direction: star.direction)
           .cgPath()
           .duplicated(times: pathMultiplier)
@@ -71,21 +62,14 @@ extension CAShapeLayer {
   {
     try addAnimation(
       for: .path,
-      keyframes: star.position.keyframes,
-      value: { position in
-        // We can only use one set of keyframes to animate a given CALayer keypath,
-        // so we currently animate `position` and ignore any other keyframes.
-        // TODO: Is there a way to support this properly?
+      keyframes: try star.combinedKeyframes(context: context).keyframes,
+      value: { keyframe in
         BezierPath.polygon(
-          position: position.pointValue,
-          numberOfPoints: try star.points
-            .exactlyOneKeyframe(context: context, description: "numberOfPoints").value.cgFloatValue,
-          outerRadius: try star.outerRadius
-            .exactlyOneKeyframe(context: context, description: "outerRadius").value.cgFloatValue,
-          outerRoundedness: try star.outerRoundness
-            .exactlyOneKeyframe(context: context, description: "outerRoundedness").value.cgFloatValue,
-          rotation: try star.rotation
-            .exactlyOneKeyframe(context: context, description: "rotation").value.cgFloatValue,
+          position: keyframe.position.pointValue,
+          numberOfPoints: keyframe.points.cgFloatValue,
+          outerRadius: keyframe.outerRadius.cgFloatValue,
+          outerRoundedness: keyframe.outerRoundness.cgFloatValue,
+          rotation: keyframe.rotation.cgFloatValue,
           direction: star.direction)
           .cgPath()
           .duplicated(times: pathMultiplier)
@@ -93,3 +77,48 @@ extension CAShapeLayer {
       context: context)
   }
 }
+
+extension Star {
+  /// Data that represents how to render a star at a specific point in time
+  struct Keyframe {
+    let position: Vector3D
+    let outerRadius: Vector1D
+    let innerRadius: Vector1D
+    let outerRoundness: Vector1D
+    let innerRoundness: Vector1D
+    let points: Vector1D
+    let rotation: Vector1D
+  }
+
+  /// Creates a single array of animatable keyframes from the separate arrays of keyframes in this star/polygon
+  func combinedKeyframes(context: LayerAnimationContext) throws -> KeyframeGroup<Keyframe> {
+    let combinedKeyframes = Keyframes.combinedIfPossible(
+      position,
+      outerRadius,
+      innerRadius ?? KeyframeGroup(Vector1D(0)),
+      outerRoundness,
+      innerRoundness ?? KeyframeGroup(Vector1D(0)),
+      points,
+      rotation,
+      makeCombinedResult: Star.Keyframe.init)
+
+    if let combinedKeyframes = combinedKeyframes {
+      return combinedKeyframes
+    } else {
+      // If we weren't able to combine all of the keyframes, we have to take the timing values
+      // from one property and use a fixed value for the other properties.
+      return try position.map { positionValue in
+        Keyframe(
+          position: positionValue,
+          outerRadius: try outerRadius.exactlyOneKeyframe(context: context, description: "star outerRadius"),
+          innerRadius: try innerRadius?.exactlyOneKeyframe(context: context, description: "star innerRadius")
+            ?? Vector1D(0),
+          outerRoundness: try outerRoundness.exactlyOneKeyframe(context: context, description: "star outerRoundness"),
+          innerRoundness: try innerRoundness?.exactlyOneKeyframe(context: context, description: "star innerRoundness")
+            ?? Vector1D(0),
+          points: try points.exactlyOneKeyframe(context: context, description: "star points"),
+          rotation: try rotation.exactlyOneKeyframe(context: context, description: "star rotation"))
+      }
+    }
+  }
+}

package/Sources/Private/CoreAnimation/Animations/StrokeAnimation.swift

@@ -57,7 +57,10 @@ extension CAShapeLayer {
     if let (dashPattern, dashPhase) = stroke.dashPattern?.shapeLayerConfiguration {
       lineDashPattern = try dashPattern.map {
         try KeyframeGroup(keyframes: $0)
-          .exactlyOneKeyframe(context: context, description: "stroke dashPattern").value.cgFloatValue as NSNumber
+          .exactlyOneKeyframe(context: context, description: "stroke dashPattern").cgFloatValue as NSNumber
+      }
+      if lineDashPattern?.allSatisfy({ $0.floatValue.isZero }) == true {
+        lineDashPattern = nil
       }
 
       try addAnimation(

package/Sources/Private/CoreAnimation/CoreAnimationLayer.swift

@@ -264,6 +264,11 @@ final class CoreAnimationLayer: BaseAnimationLayer {
 
     let timedProgressAnimation = animationProgressTracker.timed(with: context, for: self)
     timedProgressAnimation.delegate = currentAnimationConfiguration?.animationContext.closure
+
+    // Remove the progress animation once complete so we know when the animation
+    // has finished playing (if it doesn't loop infinitely)
+    timedProgressAnimation.isRemovedOnCompletion = true
+
     add(timedProgressAnimation, forKey: #keyPath(animationProgress))
   }
 
@@ -311,7 +316,7 @@ extension CoreAnimationLayer: RootAnimationLayer {
   var isAnimationPlaying: Bool? {
     switch playbackState {
     case .playing:
-      return true
+      return animation(forKey: #keyPath(animationProgress)) != nil
     case nil, .paused:
       return false
     }

package/Sources/Private/CoreAnimation/Extensions/KeyframeGroup+exactlyOneKeyframe.swift

@@ -23,7 +23,7 @@ extension KeyframeGroup {
     fileID _: StaticString = #fileID,
     line _: UInt = #line)
     throws
-    -> Keyframe<T>
+    -> T
   {
     try context.compatibilityAssert(
       keyframes.count == 1,
@@ -32,6 +32,6 @@ extension KeyframeGroup {
       for \(description) values (due to limitations of Core Animation `CAKeyframeAnimation`s).
       """)
 
-    return keyframes[0]
+    return keyframes[0].value
   }
 }

package/Sources/Private/CoreAnimation/Extensions/Keyframes+combinedIfPossible.swift

@@ -4,46 +4,113 @@
 // MARK: - Keyframes
 
 enum Keyframes {
-  /// Combines the given `[KeyframeGroup]` of `Keyframe<T>`s
-  /// into a single `KeyframeGroup` of `Keyframe<[T]>`s
-  /// if all of the `KeyframeGroup`s have the exact same animation timing
+
+  // MARK: Internal
+
+  /// Combines the given keyframe groups of `Keyframe<T>`s into a single keyframe group of
+  /// of `Keyframe<[T]>`s if all of the `KeyframeGroup`s have the exact same animation timing
   static func combinedIfPossible<T>(_ allGroups: [KeyframeGroup<T>]) -> KeyframeGroup<[T]>? {
+    combinedIfPossible(allGroups, makeCombinedResult: { index in
+      allGroups.map { $0.valueForCombinedKeyframes(at: index) }
+    })
+  }
+
+  /// Combines the given keyframe groups of `Keyframe<T>`s into a single keyframe group of
+  /// of `Keyframe<[T]>`s if all of the `KeyframeGroup`s have the exact same animation timing
+  static func combinedIfPossible<T1, T2, CombinedResult>(
+    _ k1: KeyframeGroup<T1>,
+    _ k2: KeyframeGroup<T2>,
+    makeCombinedResult: (T1, T2) -> CombinedResult)
+    -> KeyframeGroup<CombinedResult>?
+  {
+    combinedIfPossible(
+      [k1, k2],
+      makeCombinedResult: { index in
+        makeCombinedResult(
+          k1.valueForCombinedKeyframes(at: index),
+          k2.valueForCombinedKeyframes(at: index))
+      })
+  }
+
+  /// Combines the given keyframe groups of `Keyframe<T>`s into a single keyframe group of
+  /// of `Keyframe<[T]>`s if all of the `KeyframeGroup`s have the exact same animation timing
+  static func combinedIfPossible<T1, T2, T3, CombinedResult>(
+    _ k1: KeyframeGroup<T1>,
+    _ k2: KeyframeGroup<T2>,
+    _ k3: KeyframeGroup<T3>,
+    makeCombinedResult: (T1, T2, T3) -> CombinedResult)
+    -> KeyframeGroup<CombinedResult>?
+  {
+    combinedIfPossible(
+      [k1, k2, k3],
+      makeCombinedResult: { index in
+        makeCombinedResult(
+          k1.valueForCombinedKeyframes(at: index),
+          k2.valueForCombinedKeyframes(at: index),
+          k3.valueForCombinedKeyframes(at: index))
+      })
+  }
+
+  /// Combines the given keyframe groups of `Keyframe<T>`s into a single keyframe group of
+  /// of `Keyframe<[T]>`s if all of the `KeyframeGroup`s have the exact same animation timing
+  static func combinedIfPossible<T1, T2, T3, T4, T5, T6, T7, CombinedResult>(
+    _ k1: KeyframeGroup<T1>,
+    _ k2: KeyframeGroup<T2>,
+    _ k3: KeyframeGroup<T3>,
+    _ k4: KeyframeGroup<T4>,
+    _ k5: KeyframeGroup<T5>,
+    _ k6: KeyframeGroup<T6>,
+    _ k7: KeyframeGroup<T7>,
+    makeCombinedResult: (T1, T2, T3, T4, T5, T6, T7) -> CombinedResult)
+    -> KeyframeGroup<CombinedResult>?
+  {
+    combinedIfPossible(
+      [k1, k2, k3, k4, k5, k6, k7],
+      makeCombinedResult: { index in
+        makeCombinedResult(
+          k1.valueForCombinedKeyframes(at: index),
+          k2.valueForCombinedKeyframes(at: index),
+          k3.valueForCombinedKeyframes(at: index),
+          k4.valueForCombinedKeyframes(at: index),
+          k5.valueForCombinedKeyframes(at: index),
+          k6.valueForCombinedKeyframes(at: index),
+          k7.valueForCombinedKeyframes(at: index))
+      })
+  }
+
+  // MARK: Private
+
+  /// Combines the given `[KeyframeGroup]` of `Keyframe<T>`s into a single `KeyframeGroup`
+  /// of `Keyframe<CombinedResult>`s if all of the `KeyframeGroup`s have the exact same animation timing
+  private static func combinedIfPossible<CombinedResult>(
+    _ allGroups: [AnyKeyframeGroup],
+    makeCombinedResult: (_ index: Int) -> CombinedResult)
+    -> KeyframeGroup<CombinedResult>?
+  {
+    let untypedGroups = allGroups.map { $0.untyped }
+
     // Animations with no timing information (e.g. with just a single keyframe)
     // can be trivially combined with any other set of keyframes, so we don't need
     // to check those.
-    let animatingKeyframes = allGroups.filter { $0.keyframes.count > 1 }
+    let animatingKeyframes = untypedGroups.filter { $0.keyframes.count > 1 }
 
     guard
       !allGroups.isEmpty,
       animatingKeyframes.allSatisfy({ $0.hasSameTimingParameters(as: animatingKeyframes[0]) })
     else { return nil }
 
-    var combinedKeyframes = ContiguousArray<Keyframe<[T]>>()
-    let baseKeyframes = (animatingKeyframes.first ?? allGroups[0]).keyframes
+    var combinedKeyframes = ContiguousArray<Keyframe<CombinedResult>>()
+    let baseKeyframes = (animatingKeyframes.first ?? untypedGroups[0]).keyframes
 
     for index in baseKeyframes.indices {
       let baseKeyframe = baseKeyframes[index]
-      let combinedValues = allGroups.map { otherKeyframes -> T in
-        if otherKeyframes.keyframes.count == 1 {
-          return otherKeyframes.keyframes[0].value
-        } else {
-          return otherKeyframes.keyframes[index].value
-        }
-      }
-      combinedKeyframes.append(baseKeyframe.withValue(combinedValues))
+      let combinedValue = makeCombinedResult(index)
+      combinedKeyframes.append(baseKeyframe.withValue(combinedValue))
     }
 
     return KeyframeGroup(keyframes: combinedKeyframes)
   }
 
-  /// Combines the given `[KeyframeGroup?]` of `Keyframe<T>`s
-  /// into a single `KeyframeGroup` of `Keyframe<[T]>`s
-  /// if all of the `KeyframeGroup`s have the exact same animation timing
-  static func combinedIfPossible<T>(_ groups: [KeyframeGroup<T>?]) -> KeyframeGroup<[T]>? {
-    let nonOptionalGroups = groups.compactMap { $0 }
-    guard nonOptionalGroups.count == groups.count else { return nil }
-    return combinedIfPossible(nonOptionalGroups)
-  }
 }
 
 extension KeyframeGroup {
@@ -61,13 +128,27 @@ extension KeyframeGroup {
 }
 
 extension Keyframe {
-  /// Whether or not this keyframe has the same timing parameters as the given keyframe
-  func hasSameTimingParameters<T>(as other: Keyframe<T>) -> Bool {
+  /// Whether or not this keyframe has the same timing parameters as the given keyframe,
+  /// excluding `spatialInTangent` and `spatialOutTangent`.
+  fileprivate func hasSameTimingParameters<T>(as other: Keyframe<T>) -> Bool {
     time == other.time
       && isHold == other.isHold
       && inTangent == other.inTangent
       && outTangent == other.outTangent
-      && spatialInTangent == other.spatialInTangent
-      && spatialOutTangent == other.spatialOutTangent
+    // We intentionally don't compare spatial in/out tangents,
+    // since those values are only used in very specific cases
+    // (animating the x/y position of a layer), which aren't ever
+    // combined in this way.
+  }
+}
+
+extension KeyframeGroup {
+  /// The value to use for a combined set of keyframes, for the given index
+  fileprivate func valueForCombinedKeyframes(at index: Int) -> T {
+    if keyframes.count == 1 {
+      return keyframes[0].value
+    } else {
+      return keyframes[index].value
+    }
   }
 }

package/Sources/Private/CoreAnimation/Layers/BaseCompositionLayer.swift

@@ -78,7 +78,8 @@ class BaseCompositionLayer: BaseAnimationLayer {
   private func setupSublayers() {
     if
       renderLayerContents,
-      let masks = baseLayerModel.masks
+      let masks = baseLayerModel.masks?.filter({ $0.mode != .none }),
+      !masks.isEmpty
     {
       mask = MaskCompositionLayer(masks: masks)
     }

package/Sources/Private/CoreAnimation/Layers/CALayer+setupLayerHierarchy.swift

@@ -4,6 +4,9 @@
 import QuartzCore
 
 extension CALayer {
+
+  // MARK: Internal
+
   /// Sets up an `AnimationLayer` / `CALayer` hierarchy in this layer,
   /// using the given list of layers.
   @nonobjc
@@ -48,7 +51,7 @@ extension CALayer {
     }
 
     // Create an `AnimationLayer` for each `LayerModel`
-    for (layerModel, maskLayerModel) in try layersInZAxisOrder.pairedLayersAndMasks(context: context) {
+    for (layerModel, mask) in try layersInZAxisOrder.pairedLayersAndMasks(context: context) {
       guard let layer = try layerModel.makeAnimationLayer(context: context) else {
         continue
       }
@@ -64,14 +67,14 @@ extension CALayer {
 
       // Create the `mask` layer for this layer, if it has a `MatteType`
       if
-        let maskLayerModel = maskLayerModel,
-        let maskLayer = try maskLayerModel.makeAnimationLayer(context: context)
+        let mask = mask,
+        let maskLayer = try maskLayer(for: mask.model, type: mask.matteType, context: context)
       {
         let maskParentTransformLayer = makeParentTransformLayer(
-          childLayerModel: maskLayerModel,
+          childLayerModel: mask.model,
           childLayer: maskLayer,
           name: { parentLayerModel in
-            "\(maskLayerModel.name) (mask of \(layerModel.name)) (parent, \(parentLayerModel.name))"
+            "\(mask.model.name) (mask of \(layerModel.name)) (parent, \(parentLayerModel.name))"
           })
 
         // Set up a parent container to host both the layer
@@ -96,6 +99,41 @@ extension CALayer {
     }
   }
 
+  // MARK: Fileprivate
+
+  /// Creates a mask `CALayer` from the given matte layer model, using the `MatteType`
+  /// from the layer that is being masked.
+  fileprivate func maskLayer(
+    for matteLayerModel: LayerModel,
+    type: MatteType,
+    context: LayerContext) throws
+    -> CALayer?
+  {
+    switch type {
+    case .add:
+      return try matteLayerModel.makeAnimationLayer(context: context)
+
+    case .invert:
+      guard let maskLayer = try matteLayerModel.makeAnimationLayer(context: context) else {
+        return nil
+      }
+
+      // We can invert the mask layer by having a large solid black layer with the
+      // given mask layer subtracted out using the `xor` blend mode. When applied to the
+      // layer being masked, this creates an inverted mask where only areas _outside_
+      // of the mask layer are visible.
+      // https://developer.apple.com/documentation/coregraphics/cgblendmode/xor
+      let base = BaseAnimationLayer()
+      base.backgroundColor = .rgb(0, 0, 0)
+      base.addSublayer(maskLayer)
+      maskLayer.compositingFilter = "xor"
+      return base
+
+    case .none, .unknown:
+      return nil
+    }
+  }
+
 }
 
 extension Collection where Element == LayerModel {
@@ -103,8 +141,10 @@ extension Collection where Element == LayerModel {
   /// a `LayerModel` to use as its mask, if applicable
   /// based on the layer's `MatteType` configuration.
   ///  - Assumes the layers are sorted in z-axis order.
-  fileprivate func pairedLayersAndMasks(context: LayerContext) throws -> [(layer: LayerModel, mask: LayerModel?)] {
-    var layersAndMasks = [(layer: LayerModel, mask: LayerModel?)]()
+  fileprivate func pairedLayersAndMasks(context _: LayerContext) throws
+    -> [(layer: LayerModel, mask: (model: LayerModel, matteType: MatteType)?)]
+  {
+    var layersAndMasks = [(layer: LayerModel, mask: (model: LayerModel, matteType: MatteType)?)]()
     var unprocessedLayers = reversed()
 
     while let layer = unprocessedLayers.popLast() {
@@ -114,11 +154,7 @@ extension Collection where Element == LayerModel {
         matteType != .none,
         let maskLayer = unprocessedLayers.popLast()
       {
-        try context.compatibilityAssert(
-          matteType == .add,
-          "The Core Animation rendering engine currently only supports `MatteMode.add`.")
-
-        layersAndMasks.append((layer: layer, mask: maskLayer))
+        layersAndMasks.append((layer: layer, mask: (model: maskLayer, matteType: matteType)))
       }
 
       else {

package/Sources/Private/CoreAnimation/Layers/GradientRenderLayer.swift

@@ -59,7 +59,7 @@ final class GradientRenderLayer: CAGradientLayer {
   ///  - This specific value is arbitrary and can be increased if necessary.
   ///    Theoretically this should be "infinite", to match the behavior of
   ///    `CGContext.drawLinearGradient` with `[.drawsAfterEndLocation, .drawsBeforeStartLocation]`.
-  private let gradientPadding: CGFloat = 2_000
+  private let gradientPadding: CGFloat = 10_000
 
   private func updateLayout() {
     anchorPoint = .zero

package/Sources/Private/CoreAnimation/Layers/LayerModel+makeAnimationLayer.swift

@@ -27,6 +27,10 @@ extension LayerModel {
   func makeAnimationLayer(context: LayerContext) throws -> BaseCompositionLayer? {
     let context = context.forLayer(self)
 
+    if hidden {
+      return TransformLayer(layerModel: self)
+    }
+
     switch (type, self) {
     case (.precomp, let preCompLayerModel as PreCompLayerModel):
       let preCompLayer = PreCompLayer(preCompLayer: preCompLayerModel)

package/Sources/Private/CoreAnimation/Layers/MaskCompositionLayer.swift

@@ -74,7 +74,7 @@ extension MaskCompositionLayer: AnimationLayer {
   }
 }
 
-// MARK: - MaskLayer
+// MARK: MaskCompositionLayer.MaskLayer
 
 extension MaskCompositionLayer {
   final class MaskLayer: CAShapeLayer {