lottie-ios 3.4.4 → 4.0.0

package/Sources/Private/Model/DotLottie/Zip/ZipEntry+Serialization.swift

@@ -0,0 +1,189 @@
+//
+//  Entry+Serialization.swift
+//  ZIPFoundation
+//
+//  Copyright © 2017-2021 Thomas Zoechling, https://www.peakstep.com and the ZIP Foundation project authors.
+//  Released under the MIT License.
+//
+//  See https://github.com/weichsel/ZIPFoundation/blob/master/LICENSE for license information.
+//
+
+import Foundation
+
+extension ZipEntry.LocalFileHeader {
+
+  // MARK: Lifecycle
+
+  init?(data: Data, additionalDataProvider provider: (Int) throws -> Data) {
+    guard data.count == ZipEntry.LocalFileHeader.size else { return nil }
+    guard data.scanValue(start: 0) == localFileHeaderSignature else { return nil }
+    versionNeededToExtract = data.scanValue(start: 4)
+    generalPurposeBitFlag = data.scanValue(start: 6)
+    compressionMethod = data.scanValue(start: 8)
+    lastModFileTime = data.scanValue(start: 10)
+    lastModFileDate = data.scanValue(start: 12)
+    crc32 = data.scanValue(start: 14)
+    compressedSize = data.scanValue(start: 18)
+    uncompressedSize = data.scanValue(start: 22)
+    fileNameLength = data.scanValue(start: 26)
+    extraFieldLength = data.scanValue(start: 28)
+    let additionalDataLength = Int(fileNameLength) + Int(extraFieldLength)
+    guard let additionalData = try? provider(additionalDataLength) else { return nil }
+    guard additionalData.count == additionalDataLength else { return nil }
+    var subRangeStart = 0
+    var subRangeEnd = Int(fileNameLength)
+    fileNameData = additionalData.subdata(in: subRangeStart..<subRangeEnd)
+    subRangeStart += Int(fileNameLength)
+    subRangeEnd = subRangeStart + Int(extraFieldLength)
+    extraFieldData = additionalData.subdata(in: subRangeStart..<subRangeEnd)
+    if
+      let zip64ExtendedInformation = ZipEntry.ZIP64ExtendedInformation.scanForZIP64Field(
+        in: extraFieldData,
+        fields: validFields)
+    {
+      extraFields = [zip64ExtendedInformation]
+    }
+  }
+
+  // MARK: Internal
+
+  var data: Data {
+    var localFileHeaderSignature = localFileHeaderSignature
+    var versionNeededToExtract = versionNeededToExtract
+    var generalPurposeBitFlag = generalPurposeBitFlag
+    var compressionMethod = compressionMethod
+    var lastModFileTime = lastModFileTime
+    var lastModFileDate = lastModFileDate
+    var crc32 = crc32
+    var compressedSize = compressedSize
+    var uncompressedSize = uncompressedSize
+    var fileNameLength = fileNameLength
+    var extraFieldLength = extraFieldLength
+    var data = Data()
+    withUnsafePointer(to: &localFileHeaderSignature) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &versionNeededToExtract) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &generalPurposeBitFlag) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &compressionMethod) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &lastModFileTime) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &lastModFileDate) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &crc32) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &compressedSize) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &uncompressedSize) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &fileNameLength) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &extraFieldLength) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    data.append(fileNameData)
+    data.append(extraFieldData)
+    return data
+  }
+
+}
+
+extension ZipEntry.CentralDirectoryStructure {
+
+  // MARK: Lifecycle
+
+  init?(data: Data, additionalDataProvider provider: (Int) throws -> Data) {
+    guard data.count == ZipEntry.CentralDirectoryStructure.size else { return nil }
+    guard data.scanValue(start: 0) == centralDirectorySignature else { return nil }
+    versionMadeBy = data.scanValue(start: 4)
+    versionNeededToExtract = data.scanValue(start: 6)
+    generalPurposeBitFlag = data.scanValue(start: 8)
+    compressionMethod = data.scanValue(start: 10)
+    lastModFileTime = data.scanValue(start: 12)
+    lastModFileDate = data.scanValue(start: 14)
+    crc32 = data.scanValue(start: 16)
+    compressedSize = data.scanValue(start: 20)
+    uncompressedSize = data.scanValue(start: 24)
+    fileNameLength = data.scanValue(start: 28)
+    extraFieldLength = data.scanValue(start: 30)
+    fileCommentLength = data.scanValue(start: 32)
+    diskNumberStart = data.scanValue(start: 34)
+    internalFileAttributes = data.scanValue(start: 36)
+    externalFileAttributes = data.scanValue(start: 38)
+    relativeOffsetOfLocalHeader = data.scanValue(start: 42)
+    let additionalDataLength = Int(fileNameLength) + Int(extraFieldLength) + Int(fileCommentLength)
+    guard let additionalData = try? provider(additionalDataLength) else { return nil }
+    guard additionalData.count == additionalDataLength else { return nil }
+    var subRangeStart = 0
+    var subRangeEnd = Int(fileNameLength)
+    fileNameData = additionalData.subdata(in: subRangeStart..<subRangeEnd)
+    subRangeStart += Int(fileNameLength)
+    subRangeEnd = subRangeStart + Int(extraFieldLength)
+    extraFieldData = additionalData.subdata(in: subRangeStart..<subRangeEnd)
+    subRangeStart += Int(extraFieldLength)
+    subRangeEnd = subRangeStart + Int(fileCommentLength)
+    fileCommentData = additionalData.subdata(in: subRangeStart..<subRangeEnd)
+    if
+      let zip64ExtendedInformation = ZipEntry.ZIP64ExtendedInformation.scanForZIP64Field(
+        in: extraFieldData,
+        fields: validFields)
+    {
+      extraFields = [zip64ExtendedInformation]
+    }
+  }
+
+  // MARK: Internal
+
+  var data: Data {
+    var centralDirectorySignature = centralDirectorySignature
+    var versionMadeBy = versionMadeBy
+    var versionNeededToExtract = versionNeededToExtract
+    var generalPurposeBitFlag = generalPurposeBitFlag
+    var compressionMethod = compressionMethod
+    var lastModFileTime = lastModFileTime
+    var lastModFileDate = lastModFileDate
+    var crc32 = crc32
+    var compressedSize = compressedSize
+    var uncompressedSize = uncompressedSize
+    var fileNameLength = fileNameLength
+    var extraFieldLength = extraFieldLength
+    var fileCommentLength = fileCommentLength
+    var diskNumberStart = diskNumberStart
+    var internalFileAttributes = internalFileAttributes
+    var externalFileAttributes = externalFileAttributes
+    var relativeOffsetOfLocalHeader = relativeOffsetOfLocalHeader
+    var data = Data()
+    withUnsafePointer(to: &centralDirectorySignature) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &versionMadeBy) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &versionNeededToExtract) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &generalPurposeBitFlag) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &compressionMethod) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &lastModFileTime) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &lastModFileDate) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &crc32) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &compressedSize) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &uncompressedSize) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &fileNameLength) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &extraFieldLength) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &fileCommentLength) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &diskNumberStart) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &internalFileAttributes) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &externalFileAttributes) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &relativeOffsetOfLocalHeader) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    data.append(fileNameData)
+    data.append(extraFieldData)
+    data.append(fileCommentData)
+    return data
+  }
+
+}
+
+extension ZipEntry.DataDescriptor {
+  init?(data: Data, additionalDataProvider _: (Int) throws -> Data) {
+    guard data.count == Self.size else { return nil }
+    let signature: UInt32 = data.scanValue(start: 0)
+    // The DataDescriptor signature is not mandatory so we have to re-arrange the input data if it is missing.
+    var readOffset = 0
+    if signature == dataDescriptorSignature { readOffset = 4 }
+    crc32 = data.scanValue(start: readOffset)
+    readOffset += MemoryLayout<UInt32>.size
+    compressedSize = data.scanValue(start: readOffset)
+    readOffset += Self.memoryLengthOfSize
+    uncompressedSize = data.scanValue(start: readOffset)
+    // Our add(_ entry:) methods always maintain compressed & uncompressed
+    // sizes and so we don't need a data descriptor for newly added entries.
+    // Data descriptors of already existing entries are manually preserved
+    // when copying those entries to the tempArchive during remove(_ entry:).
+    self.data = Data()
+  }
+}

package/Sources/Private/Model/DotLottie/Zip/ZipEntry+ZIP64.swift

@@ -0,0 +1,179 @@
+//
+//  Entry+ZIP64.swift
+//  ZIPFoundation
+//
+//  Copyright © 2017-2021 Thomas Zoechling, https://www.peakstep.com and the ZIP Foundation project authors.
+//  Released under the MIT License.
+//
+//  See https://github.com/weichsel/ZIPFoundation/blob/master/LICENSE for license information.
+//
+
+import Foundation
+
+// MARK: - ExtensibleDataField
+
+protocol ExtensibleDataField {
+  var headerID: UInt16 { get }
+  var dataSize: UInt16 { get }
+}
+
+// MARK: - ExtraFieldHeaderID
+
+private enum ExtraFieldHeaderID: UInt16 {
+  case zip64ExtendedInformation = 0x0001
+}
+
+extension ZipEntry {
+  enum EntryError: Error {
+    case invalidDataError
+  }
+
+  struct ZIP64ExtendedInformation: ExtensibleDataField {
+    let headerID: UInt16 = ExtraFieldHeaderID.zip64ExtendedInformation.rawValue
+    let dataSize: UInt16
+    static let headerSize: UInt16 = 4
+    let uncompressedSize: UInt64
+    let compressedSize: UInt64
+    let relativeOffsetOfLocalHeader: UInt64
+    let diskNumberStart: UInt32
+  }
+
+  var zip64ExtendedInformation: ZIP64ExtendedInformation? {
+    centralDirectoryStructure.zip64ExtendedInformation
+  }
+}
+
+typealias Field = ZipEntry.ZIP64ExtendedInformation.Field
+
+extension ZipEntry.LocalFileHeader {
+  var validFields: [Field] {
+    var fields: [Field] = []
+    if uncompressedSize == .max { fields.append(.uncompressedSize) }
+    if compressedSize == .max { fields.append(.compressedSize) }
+    return fields
+  }
+}
+
+extension ZipEntry.CentralDirectoryStructure {
+  var validFields: [Field] {
+    var fields: [Field] = []
+    if uncompressedSize == .max { fields.append(.uncompressedSize) }
+    if compressedSize == .max { fields.append(.compressedSize) }
+    if relativeOffsetOfLocalHeader == .max { fields.append(.relativeOffsetOfLocalHeader) }
+    if diskNumberStart == .max { fields.append(.diskNumberStart) }
+    return fields
+  }
+
+  var zip64ExtendedInformation: ZipEntry.ZIP64ExtendedInformation? {
+    extraFields?.compactMap { $0 as? ZipEntry.ZIP64ExtendedInformation }.first
+  }
+}
+
+extension ZipEntry.ZIP64ExtendedInformation {
+
+  // MARK: Lifecycle
+
+  init?(data: Data, fields: [Field]) {
+    let headerLength = 4
+    guard fields.reduce(0, { $0 + $1.size }) + headerLength == data.count else { return nil }
+    var readOffset = headerLength
+    func value<T>(of field: Field) throws -> T where T: BinaryInteger {
+      if fields.contains(field) {
+        defer {
+          readOffset += MemoryLayout<T>.size
+        }
+        guard readOffset + field.size <= data.count else {
+          throw ZipEntry.EntryError.invalidDataError
+        }
+        return data.scanValue(start: readOffset)
+      } else {
+        return 0
+      }
+    }
+    do {
+      dataSize = data.scanValue(start: 2)
+      uncompressedSize = try value(of: .uncompressedSize)
+      compressedSize = try value(of: .compressedSize)
+      relativeOffsetOfLocalHeader = try value(of: .relativeOffsetOfLocalHeader)
+      diskNumberStart = try value(of: .diskNumberStart)
+    } catch {
+      return nil
+    }
+  }
+
+  init?(zip64ExtendedInformation: ZipEntry.ZIP64ExtendedInformation?, offset: UInt64) {
+    // Only used when removing entry, if no ZIP64 extended information exists,
+    // then this information will not be newly added either
+    guard let existingInfo = zip64ExtendedInformation else { return nil }
+    relativeOffsetOfLocalHeader = offset >= UInt32.max ? offset : 0
+    uncompressedSize = existingInfo.uncompressedSize
+    compressedSize = existingInfo.compressedSize
+    diskNumberStart = existingInfo.diskNumberStart
+    let tempDataSize = [relativeOffsetOfLocalHeader, uncompressedSize, compressedSize]
+      .filter { $0 != 0 }
+      .reduce(UInt16(0)) { $0 + UInt16(MemoryLayout.size(ofValue: $1)) }
+    dataSize = tempDataSize + (diskNumberStart > 0 ? UInt16(MemoryLayout.size(ofValue: diskNumberStart)) : 0)
+    if dataSize == 0 { return nil }
+  }
+
+  // MARK: Internal
+
+  enum Field {
+    case uncompressedSize
+    case compressedSize
+    case relativeOffsetOfLocalHeader
+    case diskNumberStart
+
+    var size: Int {
+      switch self {
+      case .uncompressedSize, .compressedSize, .relativeOffsetOfLocalHeader:
+        return 8
+      case .diskNumberStart:
+        return 4
+      }
+    }
+  }
+
+  var data: Data {
+    var headerID = headerID
+    var dataSize = dataSize
+    var uncompressedSize = uncompressedSize
+    var compressedSize = compressedSize
+    var relativeOffsetOfLFH = relativeOffsetOfLocalHeader
+    var diskNumberStart = diskNumberStart
+    var data = Data()
+    withUnsafePointer(to: &headerID) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &dataSize) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    if uncompressedSize != 0 || compressedSize != 0 {
+      withUnsafePointer(to: &uncompressedSize) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+      withUnsafePointer(to: &compressedSize) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    }
+    if relativeOffsetOfLocalHeader != 0 {
+      withUnsafePointer(to: &relativeOffsetOfLFH) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    }
+    if diskNumberStart != 0 {
+      withUnsafePointer(to: &diskNumberStart) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    }
+    return data
+  }
+
+  static func scanForZIP64Field(in data: Data, fields: [Field]) -> ZipEntry.ZIP64ExtendedInformation? {
+    guard data.isEmpty == false else { return nil }
+    var offset = 0
+    var headerID: UInt16
+    var dataSize: UInt16
+    let extraFieldLength = data.count
+    let headerSize = Int(ZipEntry.ZIP64ExtendedInformation.headerSize)
+    while offset < extraFieldLength - headerSize {
+      headerID = data.scanValue(start: offset)
+      dataSize = data.scanValue(start: offset + 2)
+      let nextOffset = offset + headerSize + Int(dataSize)
+      guard nextOffset <= extraFieldLength else { return nil }
+      if headerID == ExtraFieldHeaderID.zip64ExtendedInformation.rawValue {
+        return ZipEntry.ZIP64ExtendedInformation(data: data.subdata(in: offset..<nextOffset), fields: fields)
+      }
+      offset = nextOffset
+    }
+    return nil
+  }
+}

package/Sources/Private/Model/DotLottie/Zip/ZipEntry.swift

@@ -0,0 +1,227 @@
+//
+//  Entry.swift
+//  ZIPFoundation
+//
+//  Copyright © 2017-2021 Thomas Zoechling, https://www.peakstep.com and the ZIP Foundation project authors.
+//  Released under the MIT License.
+//
+//  See https://github.com/weichsel/ZIPFoundation/blob/master/LICENSE for license information.
+//
+
+import CoreFoundation
+import Foundation
+
+// MARK: - ZipEntry
+
+/// A value that represents a file, a directory or a symbolic link within a ZIP `Archive`.
+///
+/// You can retrieve instances of `Entry` from an `Archive` via subscripting or iteration.
+/// Entries are identified by their `path`.
+struct ZipEntry: Equatable {
+
+  // MARK: Lifecycle
+
+  init?(
+    centralDirectoryStructure: CentralDirectoryStructure,
+    localFileHeader: LocalFileHeader,
+    dataDescriptor: DefaultDataDescriptor? = nil,
+    zip64DataDescriptor: ZIP64DataDescriptor? = nil)
+  {
+    // We currently don't support encrypted archives
+    guard !centralDirectoryStructure.isEncrypted else { return nil }
+    self.centralDirectoryStructure = centralDirectoryStructure
+    self.localFileHeader = localFileHeader
+    self.dataDescriptor = dataDescriptor
+    self.zip64DataDescriptor = zip64DataDescriptor
+  }
+
+  // MARK: Internal
+
+  struct LocalFileHeader: DataSerializable {
+    let localFileHeaderSignature = UInt32(localFileHeaderStructSignature)
+    let versionNeededToExtract: UInt16
+    let generalPurposeBitFlag: UInt16
+    let compressionMethod: UInt16
+    let lastModFileTime: UInt16
+    let lastModFileDate: UInt16
+    let crc32: UInt32
+    let compressedSize: UInt32
+    let uncompressedSize: UInt32
+    let fileNameLength: UInt16
+    let extraFieldLength: UInt16
+    static let size = 30
+    let fileNameData: Data
+    let extraFieldData: Data
+    var extraFields: [ExtensibleDataField]?
+  }
+
+  struct DataDescriptor<T: BinaryInteger>: DataSerializable {
+    let data: Data
+    let dataDescriptorSignature = UInt32(dataDescriptorStructSignature)
+    let crc32: UInt32
+    // For normal archives, the compressed and uncompressed sizes are 4 bytes each.
+    // For ZIP64 format archives, the compressed and uncompressed sizes are 8 bytes each.
+    let compressedSize: T
+    let uncompressedSize: T
+    static var memoryLengthOfSize: Int { MemoryLayout<T>.size }
+    static var size: Int { memoryLengthOfSize * 2 + 8 }
+  }
+
+  typealias DefaultDataDescriptor = DataDescriptor<UInt32>
+  typealias ZIP64DataDescriptor = DataDescriptor<UInt64>
+
+  struct CentralDirectoryStructure: DataSerializable {
+    static let size = 46
+
+    let centralDirectorySignature = UInt32(centralDirectoryStructSignature)
+    let versionMadeBy: UInt16
+    let versionNeededToExtract: UInt16
+    let generalPurposeBitFlag: UInt16
+    let compressionMethod: UInt16
+    let lastModFileTime: UInt16
+    let lastModFileDate: UInt16
+    let crc32: UInt32
+    let compressedSize: UInt32
+    let uncompressedSize: UInt32
+    let fileNameLength: UInt16
+    let extraFieldLength: UInt16
+    let fileCommentLength: UInt16
+    let diskNumberStart: UInt16
+    let internalFileAttributes: UInt16
+    let externalFileAttributes: UInt32
+    let relativeOffsetOfLocalHeader: UInt32
+    let fileNameData: Data
+    let extraFieldData: Data
+    let fileCommentData: Data
+
+    var extraFields: [ExtensibleDataField]?
+
+    var usesDataDescriptor: Bool { (generalPurposeBitFlag & (1 << 3)) != 0 }
+    var usesUTF8PathEncoding: Bool { (generalPurposeBitFlag & (1 << 11)) != 0 }
+    var isEncrypted: Bool { (generalPurposeBitFlag & (1 << 0)) != 0 }
+    var isZIP64: Bool {
+      // If ZIP64 extended information is existing, try to treat cd as ZIP64 format
+      // even if the version needed to extract is lower than 4.5
+      UInt8(truncatingIfNeeded: versionNeededToExtract) >= 45 || zip64ExtendedInformation != nil
+    }
+  }
+
+  static let localFileHeaderStructSignature = 0x04034b50
+  static let dataDescriptorStructSignature = 0x08074b50
+  static let centralDirectoryStructSignature = 0x02014b50
+
+  let centralDirectoryStructure: CentralDirectoryStructure
+  let localFileHeader: LocalFileHeader
+  let dataDescriptor: DefaultDataDescriptor?
+  let zip64DataDescriptor: ZIP64DataDescriptor?
+
+  /// The `path` of the receiver within a ZIP `Archive`.
+  var path: String {
+    let dosLatinUS = 0x400
+    let dosLatinUSEncoding = CFStringEncoding(dosLatinUS)
+    let dosLatinUSStringEncoding = CFStringConvertEncodingToNSStringEncoding(dosLatinUSEncoding)
+    let codepage437 = String.Encoding(rawValue: dosLatinUSStringEncoding)
+    let encoding = centralDirectoryStructure.usesUTF8PathEncoding ? .utf8 : codepage437
+    return self.path(using: encoding)
+  }
+
+  /// The file attributes of the receiver as key/value pairs.
+  ///
+  /// Contains the modification date and file permissions.
+  var fileAttributes: [FileAttributeKey: Any] {
+    FileManager.attributes(from: self)
+  }
+
+  /// The `CRC32` checksum of the receiver.
+  ///
+  /// - Note: Always returns `0` for entries of type `EntryType.directory`.
+  var checksum: UInt32 {
+    if centralDirectoryStructure.usesDataDescriptor {
+      return zip64DataDescriptor?.crc32 ?? dataDescriptor?.crc32 ?? 0
+    }
+    return centralDirectoryStructure.crc32
+  }
+
+  /// Indicates whether or not the receiver is compressed.
+  var isCompressed: Bool {
+    localFileHeader.compressionMethod != 0
+  }
+
+  /// The size of the receiver's compressed data.
+  var compressedSize: UInt64 {
+    if centralDirectoryStructure.isZIP64 {
+      return zip64DataDescriptor?.compressedSize ?? centralDirectoryStructure.effectiveCompressedSize
+    }
+    return UInt64(dataDescriptor?.compressedSize ?? centralDirectoryStructure.compressedSize)
+  }
+
+  /// The size of the receiver's uncompressed data.
+  var uncompressedSize: UInt64 {
+    if centralDirectoryStructure.isZIP64 {
+      return zip64DataDescriptor?.uncompressedSize ?? centralDirectoryStructure.effectiveUncompressedSize
+    }
+    return UInt64(dataDescriptor?.uncompressedSize ?? centralDirectoryStructure.uncompressedSize)
+  }
+
+  /// The combined size of the local header, the data and the optional data descriptor.
+  var localSize: UInt64 {
+    let localFileHeader = localFileHeader
+    var extraDataLength = Int(localFileHeader.fileNameLength)
+    extraDataLength += Int(localFileHeader.extraFieldLength)
+    var size = UInt64(LocalFileHeader.size + extraDataLength)
+    size += isCompressed ? compressedSize : uncompressedSize
+    if centralDirectoryStructure.isZIP64 {
+      size += zip64DataDescriptor != nil ? UInt64(ZIP64DataDescriptor.size) : 0
+    } else {
+      size += dataDescriptor != nil ? UInt64(DefaultDataDescriptor.size) : 0
+    }
+    return size
+  }
+
+  var dataOffset: UInt64 {
+    var dataOffset = centralDirectoryStructure.effectiveRelativeOffsetOfLocalHeader
+    dataOffset += UInt64(LocalFileHeader.size)
+    dataOffset += UInt64(localFileHeader.fileNameLength)
+    dataOffset += UInt64(localFileHeader.extraFieldLength)
+    return dataOffset
+  }
+
+  static func == (lhs: ZipEntry, rhs: ZipEntry) -> Bool {
+    lhs.path == rhs.path
+      && lhs.localFileHeader.crc32 == rhs.localFileHeader.crc32
+      && lhs.centralDirectoryStructure.effectiveRelativeOffsetOfLocalHeader
+      == rhs.centralDirectoryStructure.effectiveRelativeOffsetOfLocalHeader
+  }
+
+  /// Returns the `path` of the receiver within a ZIP `Archive` using a given encoding.
+  ///
+  /// - Parameters:
+  ///   - encoding: `String.Encoding`
+  func path(using encoding: String.Encoding) -> String {
+    String(data: centralDirectoryStructure.fileNameData, encoding: encoding) ?? ""
+  }
+
+}
+
+extension ZipEntry.CentralDirectoryStructure {
+  var effectiveCompressedSize: UInt64 {
+    if isZIP64, let compressedSize = zip64ExtendedInformation?.compressedSize, compressedSize > 0 {
+      return compressedSize
+    }
+    return UInt64(compressedSize)
+  }
+
+  var effectiveUncompressedSize: UInt64 {
+    if isZIP64, let uncompressedSize = zip64ExtendedInformation?.uncompressedSize, uncompressedSize > 0 {
+      return uncompressedSize
+    }
+    return UInt64(uncompressedSize)
+  }
+
+  var effectiveRelativeOffsetOfLocalHeader: UInt64 {
+    if isZIP64, let offset = zip64ExtendedInformation?.relativeOffsetOfLocalHeader, offset > 0 {
+      return offset
+    }
+    return UInt64(relativeOffsetOfLocalHeader)
+  }
+}

package/Sources/Private/Model/Extensions/Bundle.swift

@@ -19,6 +19,22 @@ extension Bundle {
     return nil
     #endif
   }
+
+  func dotLottieData(_ name: String, subdirectory: String? = nil) throws -> Data? {
+    // Check for files in the bundle at the given path
+    let name = name.removingDotLottieSuffix()
+    if let url = url(forResource: name, withExtension: "lottie", subdirectory: subdirectory) {
+      return try Data(contentsOf: url)
+    }
+
+    // Check for data assets (not available on macOS)
+    #if os(iOS) || os(tvOS) || os(watchOS) || targetEnvironment(macCatalyst)
+    let assetKey = subdirectory != nil ? "\(subdirectory ?? "")/\(name)" : name
+    return NSDataAsset(name: assetKey, bundle: self)?.data
+    #else
+    return nil
+    #endif
+  }
 }
 
 extension String {
@@ -31,4 +47,14 @@ extension String {
 
     return (self as NSString).deletingPathExtension
   }
+
+  fileprivate func removingDotLottieSuffix() -> String {
+    // Allow filenames to be passed with a ".lottie" extension (but not other extensions)
+    // to keep the behavior from Lottie 2.x - instead of failing to load the file
+    guard hasSuffix(".lottie") else {
+      return self
+    }
+
+    return (self as NSString).deletingPathExtension
+  }
 }

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,