lottie-ios 4.3.3 → 4.4.0

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

@@ -36,27 +36,8 @@ final class ShapeLayer: BaseCompositionLayer {
   private let shapeLayer: ShapeLayerModel
 
   private func setUpGroups(context: LayerContext) throws {
-    // If the layer has a `Repeater`, the `Group`s are duplicated and offset
-    // based on the copy count of the repeater.
-    if let repeater = shapeLayer.items.first(where: { $0 is Repeater }) as? Repeater {
-      try setUpRepeater(repeater, context: context)
-    } else {
-      let shapeItems = shapeLayer.items.map { ShapeItemLayer.Item(item: $0, groupPath: []) }
-      try setupGroups(from: shapeItems, parentGroup: nil, parentGroupPath: [], context: context)
-    }
-  }
-
-  private func setUpRepeater(_ repeater: Repeater, context: LayerContext) throws {
-    let items = shapeLayer.items.filter { !($0 is Repeater) }
-    let copyCount = Int(try repeater.copies.exactlyOneKeyframe(context: context, description: "repeater copies").value)
-
-    for index in 0..<copyCount {
-      let shapeItems = items.map { ShapeItemLayer.Item(item: $0, groupPath: []) }
-      for groupLayer in try makeGroupLayers(from: shapeItems, parentGroup: nil, parentGroupPath: [], context: context) {
-        let repeatedLayer = RepeaterLayer(repeater: repeater, childLayer: groupLayer, index: index)
-        addSublayer(repeatedLayer)
-      }
-    }
+    let shapeItems = shapeLayer.items.map { ShapeItemLayer.Item(item: $0, groupPath: []) }
+    try setupGroups(from: shapeItems, parentGroup: nil, parentGroupPath: [], context: context)
   }
 
 }
@@ -181,6 +162,9 @@ final class GroupLayer: BaseAnimationLayer {
 }
 
 extension CALayer {
+
+  // MARK: Fileprivate
+
   /// Sets up `GroupLayer`s for each `Group` in the given list of `ShapeItem`s
   ///  - Each `Group` item becomes its own `GroupLayer` sublayer.
   ///  - Other `ShapeItem` are applied to all sublayers
@@ -191,21 +175,77 @@ extension CALayer {
     context: LayerContext)
     throws
   {
-    let groupLayers = try makeGroupLayers(
-      from: items,
-      parentGroup: parentGroup,
-      parentGroupPath: parentGroupPath,
-      context: context)
-
-    for groupLayer in groupLayers {
-      addSublayer(groupLayer)
+    // If the layer has any `Repeater`s, set up each repeater
+    // and then handle any remaining groups like normal.
+    if items.contains(where: { $0.item is Repeater }) {
+      let repeaterGroupings = items.split(whereSeparator: { $0.item is Repeater })
+
+      // Iterate through the groupings backwards to preserve the expected rendering order
+      for repeaterGrouping in repeaterGroupings.reversed() {
+        // Each repeater applies to the previous items in the list
+        if let repeater = repeaterGrouping.trailingSeparator?.item as? Repeater {
+          try setUpRepeater(
+            repeater,
+            items: repeaterGrouping.grouping,
+            parentGroupPath: parentGroupPath,
+            context: context)
+        }
+
+        // Any remaining items after the last repeater are handled like normal
+        else {
+          try setupGroups(
+            from: repeaterGrouping.grouping,
+            parentGroup: parentGroup,
+            parentGroupPath: parentGroupPath,
+            context: context)
+        }
+      }
+    }
+
+    else {
+      let groupLayers = try makeGroupLayers(
+        from: items,
+        parentGroup: parentGroup,
+        parentGroupPath: parentGroupPath,
+        context: context)
+
+      for groupLayer in groupLayers {
+        addSublayer(groupLayer)
+      }
+    }
+  }
+
+  // MARK: Private
+
+  /// Sets up this layer using the given `Repeater`
+  private func setUpRepeater(
+    _ repeater: Repeater,
+    items allItems: [ShapeItemLayer.Item],
+    parentGroupPath: [String],
+    context: LayerContext)
+    throws
+  {
+    let items = allItems.filter { !($0.item is Repeater) }
+    let copyCount = Int(try repeater.copies.exactlyOneKeyframe(context: context, description: "repeater copies").value)
+
+    for index in 0..<copyCount {
+      let groupLayers = try makeGroupLayers(
+        from: items,
+        parentGroup: nil, // The repeater layer acts as the parent of its sublayers
+        parentGroupPath: parentGroupPath,
+        context: context)
+
+      for groupLayer in groupLayers {
+        let repeatedLayer = RepeaterLayer(repeater: repeater, childLayer: groupLayer, index: index)
+        addSublayer(repeatedLayer)
+      }
     }
   }
 
   /// Creates a `GroupLayer` for each `Group` in the given list of `ShapeItem`s
   ///  - Each `Group` item becomes its own `GroupLayer` sublayer.
   ///  - Other `ShapeItem` are applied to all sublayers
-  fileprivate func makeGroupLayers(
+  private func makeGroupLayers(
     from items: [ShapeItemLayer.Item],
     parentGroup: Group?,
     parentGroupPath: [String],
@@ -346,6 +386,32 @@ extension Collection {
 
     return (trueElements, falseElements)
   }
+
+  /// Splits this collection into an array of grouping separated by the given separator.
+  /// For example, `[A, B, C]` split by `B` returns an array with two elements:
+  ///  1. `(grouping: [A], trailingSeparator: B)`
+  ///  2. `(grouping: [C], trailingSeparator: nil)`
+  func split(whereSeparator separatorPredicate: (Element) -> Bool)
+    -> [(grouping: [Element], trailingSeparator: Element?)]
+  {
+    guard !isEmpty else { return [] }
+
+    var groupings: [(grouping: [Element], trailingSeparator: Element?)] = []
+
+    for element in self {
+      if groupings.isEmpty || groupings.last?.trailingSeparator != nil {
+        groupings.append((grouping: [], trailingSeparator: nil))
+      }
+
+      if separatorPredicate(element) {
+        groupings[groupings.indices.last!].trailingSeparator = element
+      } else {
+        groupings[groupings.indices.last!].grouping.append(element)
+      }
+    }
+
+    return groupings
+  }
 }
 
 // MARK: - ShapeRenderGroup
@@ -359,7 +425,7 @@ struct ShapeRenderGroup {
   var otherItems: [ShapeItemLayer.Item] = []
 }
 
-extension Array where Element == ShapeItemLayer.Item {
+extension [ShapeItemLayer.Item] {
   /// Splits this list of `ShapeItem`s into groups that should be rendered together as individual units,
   /// plus the remaining items that were not included in any group.
   ///  - groupHasChildGroupsToInheritUnusedItems: whether or not this group has child groups

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

@@ -35,13 +35,16 @@ final class SolidLayer: BaseCompositionLayer {
   override func setupAnimations(context: LayerAnimationContext) throws {
     try super.setupAnimations(context: context)
 
+    var context = context
+    context = context.addingKeypathComponent(solidLayer.name)
+
     // Even though the Lottie json schema provides a fixed `solidLayer.colorHex` value,
     // we still need to create a set of keyframes and go through the standard `CAAnimation`
     // codepath so that this value can be customized using the custom `ValueProvider`s API.
     try shapeLayer.addAnimation(
       for: .fillColor,
-      keyframes: KeyframeGroup(solidLayer.colorHex.cgColor),
-      value: { $0 },
+      keyframes: KeyframeGroup(solidLayer.colorHex.lottieColor),
+      value: { $0.cgColorValue },
       context: context)
   }
 

package/Sources/Private/EmbeddedLibraries/EpoxyCore/Model/EpoxyModelArrayBuilder.swift

@@ -16,7 +16,7 @@ enum EpoxyModelArrayBuilder<Model> {
   }
 
   static func buildExpression(_ expression: Expression?) -> Component {
-    if let expression = expression {
+    if let expression {
       return [expression]
     }
     return []

package/Sources/Private/EmbeddedLibraries/EpoxyCore/Model/EpoxyModelProperty.swift

@@ -93,8 +93,8 @@ extension EpoxyModelProperty.UpdateStrategy {
   /// calls the old closure and then subsequently calls the new closure.
   static func chain() -> EpoxyModelProperty<(() -> Void)?>.UpdateStrategy {
     .init { old, new in
-      guard let new = new else { return old }
-      guard let old = old else { return new }
+      guard let new else { return old }
+      guard let old else { return new }
       return {
         old()
         new()
@@ -106,8 +106,8 @@ extension EpoxyModelProperty.UpdateStrategy {
   /// calls the old closure and then subsequently calls the new closure.
   static func chain<A>() -> EpoxyModelProperty<((A) -> Void)?>.UpdateStrategy {
     .init { old, new in
-      guard let new = new else { return old }
-      guard let old = old else { return new }
+      guard let new else { return old }
+      guard let old else { return new }
       return { a in
         old(a)
         new(a)
@@ -119,8 +119,8 @@ extension EpoxyModelProperty.UpdateStrategy {
   /// calls the old closure and then subsequently calls the new closure.
   static func chain<A, B>() -> EpoxyModelProperty<((A, B) -> Void)?>.UpdateStrategy {
     .init { old, new in
-      guard let new = new else { return old }
-      guard let old = old else { return new }
+      guard let new else { return old }
+      guard let old else { return new }
       return { a, b in
         old(a, b)
         new(a, b)
@@ -132,8 +132,8 @@ extension EpoxyModelProperty.UpdateStrategy {
   /// calls the old closure and then subsequently calls the new closure.
   static func chain<A, B, C>() -> EpoxyModelProperty<((A, B, C) -> Void)?>.UpdateStrategy {
     .init { old, new in
-      guard let new = new else { return old }
-      guard let old = old else { return new }
+      guard let new else { return old }
+      guard let old else { return new }
       return { a, b, c in
         old(a, b, c)
         new(a, b, c)
@@ -145,8 +145,8 @@ extension EpoxyModelProperty.UpdateStrategy {
   /// calls the old closure and then subsequently calls the new closure.
   static func chain<A, B, C, D>() -> EpoxyModelProperty<((A, B, C, D) -> Void)?>.UpdateStrategy {
     .init { old, new in
-      guard let new = new else { return old }
-      guard let old = old else { return new }
+      guard let new else { return old }
+      guard let old else { return new }
       return { a, b, c, d in
         old(a, b, c, d)
         new(a, b, c, d)

package/Sources/Private/EmbeddedLibraries/EpoxyCore/SwiftUI/EpoxySwiftUIHostingController.swift

@@ -1,9 +1,9 @@
 // Created by eric_horacek on 10/8/21.
 // Copyright © 2021 Airbnb Inc. All rights reserved.
 
+#if canImport(SwiftUI) && !os(macOS)
 import SwiftUI
 
-#if !os(macOS)
 // MARK: - EpoxySwiftUIUIHostingController
 
 /// A `UIHostingController` that hosts SwiftUI views within an Epoxy container, e.g. an Epoxy

package/Sources/Private/EmbeddedLibraries/EpoxyCore/SwiftUI/EpoxySwiftUIHostingView.swift

@@ -1,11 +1,10 @@
 // Created by eric_horacek on 9/16/21.
 // Copyright © 2021 Airbnb Inc. All rights reserved.
 
+#if canImport(Combine) && canImport(SwiftUI) && !os(macOS)
 import Combine
 import SwiftUI
 
-#if !os(macOS)
-
 // MARK: - SwiftUIHostingViewReuseBehavior
 
 /// The reuse behavior of an `EpoxySwiftUIHostingView`.
@@ -387,5 +386,4 @@ struct EpoxyHostingWrapper<Content: View>: View {
       .environment(\.epoxyIntrinsicContentSizeInvalidator, environment.intrinsicContentSizeInvalidator)
   }
 }
-
 #endif

package/Sources/Private/EmbeddedLibraries/EpoxyCore/SwiftUI/EpoxySwiftUIIntrinsicContentSizeInvalidator.swift

@@ -1,6 +1,7 @@
 // Created by matthew_cheok on 11/19/21.
 // Copyright © 2021 Airbnb Inc. All rights reserved.
 
+#if canImport(SwiftUI)
 import SwiftUI
 
 // MARK: - EpoxyIntrinsicContentSizeInvalidator
@@ -42,3 +43,4 @@ extension EnvironmentValues {
 private struct EpoxyIntrinsicContentSizeInvalidatorKey: EnvironmentKey {
   static let defaultValue = EpoxyIntrinsicContentSizeInvalidator(invalidate: { })
 }
+#endif

package/Sources/Private/EmbeddedLibraries/EpoxyCore/SwiftUI/EpoxySwiftUILayoutMargins.swift

@@ -1,6 +1,7 @@
 // Created by eric_horacek on 10/8/21.
 // Copyright © 2021 Airbnb Inc. All rights reserved.
 
+#if canImport(SwiftUI)
 import SwiftUI
 
 // MARK: - View
@@ -49,3 +50,4 @@ private struct EpoxyLayoutMarginsPadding: ViewModifier {
     content.padding(epoxyLayoutMargins)
   }
 }
+#endif

package/Sources/Private/EmbeddedLibraries/EpoxyCore/SwiftUI/EpoxyableView+SwiftUIView.swift

@@ -1,6 +1,7 @@
 // Created by eric_horacek on 9/13/21.
 // Copyright © 2021 Airbnb Inc. All rights reserved.
 
+#if canImport(SwiftUI)
 import SwiftUI
 
 // MARK: - StyledView
@@ -170,3 +171,4 @@ extension StyledView
     }
   }
 }
+#endif

package/Sources/Private/EmbeddedLibraries/EpoxyCore/SwiftUI/LayoutUtilities/MeasuringViewRepresentable.swift

@@ -1,6 +1,7 @@
 // Created by eric_horacek on 6/22/22.
 // Copyright © 2022 Airbnb Inc. All rights reserved.
 
+#if canImport(SwiftUI)
 import SwiftUI
 
 // MARK: - MeasuringViewRepresentable
@@ -126,3 +127,4 @@ extension MeasuringViewRepresentable {
   #endif
 }
 #endif
+#endif

package/Sources/Private/EmbeddedLibraries/EpoxyCore/SwiftUI/LayoutUtilities/SwiftUIMeasurementContainer.swift

@@ -1,6 +1,7 @@
 // Created by Bryn Bodayle on 1/24/22.
 // Copyright © 2022 Airbnb Inc. All rights reserved.
 
+#if canImport(SwiftUI)
 import SwiftUI
 
 // MARK: - SwiftUIMeasurementContainer
@@ -450,3 +451,4 @@ extension CGSize {
       height: height == ViewType.noIntrinsicMetric ? fallback.height : height)
   }
 }
+#endif

package/Sources/Private/EmbeddedLibraries/EpoxyCore/SwiftUI/SwiftUIView.swift

@@ -1,6 +1,7 @@
 // Created by eric_horacek on 9/8/22.
 // Copyright © 2022 Airbnb Inc. All rights reserved.
 
+#if canImport(SwiftUI)
 import SwiftUI
 
 // MARK: - SwiftUIView
@@ -146,3 +147,4 @@ extension SwiftUIView {
     fileprivate(set) var storage: Storage
   }
 }
+#endif

package/Sources/Private/EmbeddedLibraries/EpoxyCore/SwiftUI/UIView+SwiftUIView.swift

@@ -1,6 +1,7 @@
 // Created by eric_horacek on 3/3/22.
 // Copyright © 2022 Airbnb Inc. All rights reserved.
 
+#if canImport(SwiftUI)
 import SwiftUI
 
 // MARK: - ViewTypeProtocol + swiftUIView
@@ -38,3 +39,4 @@ protocol ViewTypeProtocol: ViewType { }
 // MARK: - ViewType + ViewTypeProtocol
 
 extension ViewType: ViewTypeProtocol { }
+#endif

package/Sources/Private/EmbeddedLibraries/EpoxyCore/SwiftUI/UIViewConfiguringSwiftUIView.swift

@@ -1,6 +1,7 @@
 // Created by eric_horacek on 3/4/22.
 // Copyright © 2022 Airbnb Inc. All rights reserved.
 
+#if canImport(SwiftUI)
 import SwiftUI
 
 // MARK: - UIViewConfiguringSwiftUIView
@@ -41,3 +42,4 @@ extension UIViewConfiguringSwiftUIView {
     return copy
   }
 }
+#endif

package/Sources/Private/EmbeddedLibraries/EpoxyCore/Views/ViewType.swift

@@ -1,8 +1,8 @@
 // Created by Cal Stephens on 6/26/23.
 // Copyright © 2023 Airbnb Inc. All rights reserved.
 
+#if canImport(SwiftUI)
 import SwiftUI
-
 #if canImport(UIKit)
 import UIKit
 
@@ -49,3 +49,4 @@ extension ViewRepresentableType {
   typealias RepresentableViewType = NSViewType
 }
 #endif
+#endif

package/Sources/Private/EmbeddedLibraries/LRUCache/LRUCache.swift

@@ -0,0 +1,256 @@
+//
+//  LRUCache.swift
+//  LRUCache
+//
+//  Version 1.0.2
+//
+//  Created by Nick Lockwood on 05/08/2021.
+//  Copyright © 2021 Nick Lockwood. All rights reserved.
+//
+//  Distributed under the permissive MIT license
+//  Get the latest version from here:
+//
+//  https://github.com/nicklockwood/LRUCache
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+
+#if canImport(UIKit)
+import UIKit
+
+/// Notification that cache should be cleared
+let LRUCacheMemoryWarningNotification: NSNotification.Name =
+  UIApplication.didReceiveMemoryWarningNotification
+
+#else
+
+/// Notification that cache should be cleared
+let LRUCacheMemoryWarningNotification: NSNotification.Name =
+  .init("LRUCacheMemoryWarningNotification")
+
+#endif
+
+// MARK: - LRUCache
+
+final class LRUCache<Key: Hashable, Value> {
+
+  // MARK: Lifecycle
+
+  /// Initialize the cache with the specified `totalCostLimit` and `countLimit`
+  init(
+    totalCostLimit: Int = .max,
+    countLimit: Int = .max,
+    notificationCenter: NotificationCenter = .default)
+  {
+    self.totalCostLimit = totalCostLimit
+    self.countLimit = countLimit
+    self.notificationCenter = notificationCenter
+
+    token = notificationCenter.addObserver(
+      forName: LRUCacheMemoryWarningNotification,
+      object: nil,
+      queue: nil)
+    { [weak self] _ in
+      self?.removeAllValues()
+    }
+  }
+
+  deinit {
+    if let token {
+      notificationCenter.removeObserver(token)
+    }
+  }
+
+  // MARK: Internal
+
+  /// The current total cost of values in the cache
+  private(set) var totalCost = 0
+
+  /// The maximum total cost permitted
+  var totalCostLimit: Int {
+    didSet { clean() }
+  }
+
+  /// The maximum number of values permitted
+  var countLimit: Int {
+    didSet { clean() }
+  }
+
+  // MARK: Private
+
+  private var values: [Key: Container] = [:]
+  private unowned(unsafe) var head: Container?
+  private unowned(unsafe) var tail: Container?
+  private let lock: NSLock = .init()
+  private var token: AnyObject?
+  private let notificationCenter: NotificationCenter
+
+}
+
+extension LRUCache {
+  /// The number of values currently stored in the cache
+  var count: Int {
+    values.count
+  }
+
+  /// Is the cache empty?
+  var isEmpty: Bool {
+    values.isEmpty
+  }
+
+  /// Returns all values in the cache from oldest to newest
+  var allValues: [Value] {
+    lock.lock()
+    defer { lock.unlock() }
+    var values = [Value]()
+    var next = head
+    while let container = next {
+      values.append(container.value)
+      next = container.next
+    }
+    return values
+  }
+
+  /// Insert a value into the cache with optional `cost`
+  func setValue(_ value: Value?, forKey key: Key, cost: Int = 0) {
+    guard let value else {
+      removeValue(forKey: key)
+      return
+    }
+    lock.lock()
+    if let container = values[key] {
+      container.value = value
+      totalCost -= container.cost
+      container.cost = cost
+      remove(container)
+      append(container)
+    } else {
+      let container = Container(
+        value: value,
+        cost: cost,
+        key: key)
+      values[key] = container
+      append(container)
+    }
+    totalCost += cost
+    lock.unlock()
+    clean()
+  }
+
+  /// Remove a value  from the cache and return it
+  @discardableResult
+  func removeValue(forKey key: Key) -> Value? {
+    lock.lock()
+    defer { lock.unlock() }
+    guard let container = values.removeValue(forKey: key) else {
+      return nil
+    }
+    remove(container)
+    totalCost -= container.cost
+    return container.value
+  }
+
+  /// Fetch a value from the cache
+  func value(forKey key: Key) -> Value? {
+    lock.lock()
+    defer { lock.unlock() }
+    if let container = values[key] {
+      remove(container)
+      append(container)
+      return container.value
+    }
+    return nil
+  }
+
+  /// Remove all values from the cache
+  func removeAllValues() {
+    lock.lock()
+    values.removeAll()
+    head = nil
+    tail = nil
+    lock.unlock()
+  }
+}
+
+extension LRUCache {
+
+  // MARK: Fileprivate
+
+  fileprivate final class Container {
+
+    // MARK: Lifecycle
+
+    init(value: Value, cost: Int, key: Key) {
+      self.value = value
+      self.cost = cost
+      self.key = key
+    }
+
+    // MARK: Internal
+
+    var value: Value
+    var cost: Int
+    let key: Key
+    unowned(unsafe) var prev: Container?
+    unowned(unsafe) var next: Container?
+
+  }
+
+  // MARK: Private
+
+  // Remove container from list (must be called inside lock)
+  private func remove(_ container: Container) {
+    if head === container {
+      head = container.next
+    }
+    if tail === container {
+      tail = container.prev
+    }
+    container.next?.prev = container.prev
+    container.prev?.next = container.next
+    container.next = nil
+  }
+
+  // Append container to list (must be called inside lock)
+  private func append(_ container: Container) {
+    assert(container.next == nil)
+    if head == nil {
+      head = container
+    }
+    container.prev = tail
+    tail?.next = container
+    tail = container
+  }
+
+  // Remove expired values (must be called outside lock)
+  private func clean() {
+    lock.lock()
+    defer { lock.unlock() }
+    while
+      totalCost > totalCostLimit || count > countLimit,
+      let container = head
+    {
+      remove(container)
+      values.removeValue(forKey: container.key)
+      totalCost -= container.cost
+    }
+  }
+}

package/Sources/Private/EmbeddedLibraries/LRUCache/README.md

@@ -0,0 +1,24 @@
+## LRUCache
+
+This directory includes the source code of the LRUCache library, from the following release:
+https://github.com/nicklockwood/LRUCache/releases/tag/1.0.4
+
+Lottie is distributed via multiple package managers (SPM, Cocoapods, Carthage, and NPM),
+each with different packaging and compilation requirements. 
+
+Due to limitations of these package managers, we can't depend on / import 
+a separate LRUCache module / library. Instead, we include the source
+directly within the Lottie library and compile everything as a single unit.
+
+### Update instructions
+
+From time to time we may need to update to a more recent version of LRUCache.
+When doing this, follow these steps:
+
+ 1. Download the latest release from https://github.com/nicklockwood/LRUCache
+    and replace the source code in this directory with the updated code.
+
+ 2. Update the URL at the top of this file to indicate what release is being used.
+
+ 3. Change all of the `public` symbols defined in this module to instead be `internal`
+    to prevent Lottie from exposing any EpoxyCore APIs.