@octane-xplat/lottie 0.0.1 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Private/EmbeddedLibraries/ZipFoundation/Data+Serialization.swift

@@ -0,0 +1,146 @@
+//
+//  Data+Serialization.swift
+//  ZIPFoundation
+//
+//  Copyright © 2017-2025 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
+
+#if os(Android)
+typealias FILEPointer = OpaquePointer
+#else
+typealias FILEPointer = UnsafeMutablePointer<FILE>
+#endif
+
+// MARK: - DataSerializable
+
+protocol DataSerializable {
+  init?(data: Data, additionalDataProvider: (Int) throws -> Data)
+
+  static var size: Int { get }
+
+  var data: Data { get }
+}
+
+extension Data {
+  enum DataError: Error {
+    case unreadableFile
+    case unwritableFile
+  }
+
+  static func readStruct<T: DataSerializable>(from file: FILEPointer, at offset: UInt64)
+    -> T?
+  {
+    guard offset <= .max else { return nil }
+    fseeko(file, off_t(offset), SEEK_SET)
+    guard let data = try? readChunk(of: T.size, from: file) else {
+      return nil
+    }
+    return T(data: data, additionalDataProvider: { additionalDataSize -> Data in
+      return try self.readChunk(of: additionalDataSize, from: file)
+    })
+  }
+
+  static func consumePart(
+    of size: Int64,
+    chunkSize: Int,
+    skipCRC32: Bool = false,
+    provider: Provider,
+    consumer: Consumer
+  ) throws -> CRC32 {
+    var checksum = CRC32(0)
+    guard size > 0 else {
+      try consumer(Data())
+      return checksum
+    }
+
+    let readInOneChunk = (size < chunkSize)
+    var chunkSize = readInOneChunk ? Int(size) : chunkSize
+    var bytesRead: Int64 = 0
+    while bytesRead < size {
+      let remainingSize = size - bytesRead
+      chunkSize = remainingSize < chunkSize ? Int(remainingSize) : chunkSize
+      let data = try provider(bytesRead, chunkSize)
+      try consumer(data)
+      if !skipCRC32 {
+        checksum = data.crc32(checksum: checksum)
+      }
+      bytesRead += Int64(chunkSize)
+    }
+    return checksum
+  }
+
+  static func readChunk(of size: Int, from file: FILEPointer) throws -> Data {
+    let alignment = MemoryLayout<UInt>.alignment
+    #if swift(>=4.1)
+    let bytes = UnsafeMutableRawPointer.allocate(byteCount: size, alignment: alignment)
+    #else
+    let bytes = UnsafeMutableRawPointer.allocate(bytes: size, alignedTo: alignment)
+    #endif
+    let bytesRead = fread(bytes, 1, size, file)
+    let error = ferror(file)
+    if error > 0 {
+      bytes.deallocate()
+      throw DataError.unreadableFile
+    }
+    #if swift(>=4.1)
+    return Data(bytesNoCopy: bytes, count: bytesRead, deallocator: .custom { buf, _ in buf.deallocate() })
+    #else
+    let deallocator = Deallocator.custom { buf, _ in buf.deallocate(bytes: size, alignedTo: 1) }
+    return Data(bytesNoCopy: bytes, count: bytesRead, deallocator: deallocator)
+    #endif
+  }
+
+  static func write(chunk: Data, to file: FILEPointer) throws -> Int {
+    var sizeWritten = 0
+    chunk.withUnsafeBytes { rawBufferPointer in
+      if let baseAddress = rawBufferPointer.baseAddress, rawBufferPointer.count > 0 {
+        let pointer = baseAddress.assumingMemoryBound(to: UInt8.self)
+        sizeWritten = fwrite(pointer, 1, chunk.count, file)
+      }
+    }
+    let error = ferror(file)
+    if error > 0 {
+      throw DataError.unwritableFile
+    }
+    return sizeWritten
+  }
+
+  static func writeLargeChunk(
+    _ chunk: Data,
+    size: UInt64,
+    bufferSize: Int,
+    to file: FILEPointer
+  ) throws -> UInt64 {
+    var sizeWritten: UInt64 = 0
+    chunk.withUnsafeBytes { rawBufferPointer in
+      if let baseAddress = rawBufferPointer.baseAddress, rawBufferPointer.count > 0 {
+        let pointer = baseAddress.assumingMemoryBound(to: UInt8.self)
+
+        while sizeWritten < size {
+          let remainingSize = size - sizeWritten
+          let chunkSize = Swift.min(Int(remainingSize), bufferSize)
+          let curPointer = pointer.advanced(by: Int(sizeWritten))
+          fwrite(curPointer, 1, chunkSize, file)
+          sizeWritten += UInt64(chunkSize)
+        }
+      }
+    }
+    let error = ferror(file)
+    if error > 0 {
+      throw DataError.unwritableFile
+    }
+    return sizeWritten
+  }
+
+  func scanValue<T>(start: Int) -> T {
+    withUnsafeBytes {
+      $0.loadUnaligned(fromByteOffset: start, as: T.self)
+    }
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/EmbeddedLibraries/ZipFoundation/Date+ZIP.swift

@@ -0,0 +1,101 @@
+//
+//  Date+ZIP.swift
+//  ZIPFoundation
+//
+//  Created by Thomas Zoechling on 20.12.22.
+//
+
+import Foundation
+
+extension Date {
+
+  // MARK: Lifecycle
+
+  init(dateTime: (UInt16, UInt16)) {
+    var msdosDateTime = Int(dateTime.0)
+    msdosDateTime <<= 16
+    msdosDateTime |= Int(dateTime.1)
+    var unixTime = tm()
+    unixTime.tm_sec = Int32((msdosDateTime & 31) * 2)
+    unixTime.tm_min = Int32((msdosDateTime >> 5) & 63)
+    unixTime.tm_hour = Int32((Int(dateTime.1) >> 11) & 31)
+    unixTime.tm_mday = Int32((msdosDateTime >> 16) & 31)
+    unixTime.tm_mon = Int32((msdosDateTime >> 21) & 15)
+    unixTime.tm_mon -= 1 // UNIX time struct month entries are zero based.
+    unixTime.tm_year = Int32(1980 + (msdosDateTime >> 25))
+    unixTime.tm_year -= 1900 // UNIX time structs count in "years since 1900".
+    let time = timegm(&unixTime)
+    self = Date(timeIntervalSince1970: TimeInterval(time))
+  }
+
+  init(timespec: timespec) {
+    let seconds = 1.0e-9 * Double(timespec.tv_nsec)
+    let timeIntervalSince1970 = TimeInterval(timespec.tv_sec)
+    let absoluteTimeIntervalSince1970 = Constants.absoluteTimeIntervalSince1970
+    self.init(timeIntervalSinceReferenceDate: (timeIntervalSince1970 - absoluteTimeIntervalSince1970) + seconds)
+  }
+
+  // MARK: Internal
+
+  var fileModificationDateTime: (UInt16, UInt16) {
+    (fileModificationDate, fileModificationTime)
+  }
+
+  var fileModificationDate: UInt16 {
+    var time = time_t(timeIntervalSince1970)
+    guard let unixTime = gmtime(&time) else {
+      return 0
+    }
+    var year = unixTime.pointee.tm_year + 1900 // UNIX time structs count in "years since 1900".
+    // ZIP uses the MSDOS date format which has a valid range of 1980 - 2099.
+    year = year >= 1980 ? year : 1980
+    year = year <= 2099 ? year : 2099
+    let month = unixTime.pointee.tm_mon + 1 // UNIX time struct month entries are zero based.
+    let day = unixTime.pointee.tm_mday
+    return UInt16(day + (month * 32) + ((year - 1980) * 512))
+  }
+
+  var fileModificationTime: UInt16 {
+    var time = time_t(timeIntervalSince1970)
+    guard let unixTime = gmtime(&time) else {
+      return 0
+    }
+    let hour = unixTime.pointee.tm_hour
+    let minute = unixTime.pointee.tm_min
+    let second = unixTime.pointee.tm_sec
+    return UInt16((second / 2) + (minute * 32) + (hour * 2048))
+  }
+
+}
+
+// MARK: - Date.Constants
+
+extension Date {
+
+  fileprivate enum Constants {
+    #if os(macOS) || os(iOS) || os(tvOS) || os(visionOS) || os(watchOS)
+    static let absoluteTimeIntervalSince1970 = kCFAbsoluteTimeIntervalSince1970
+    #else
+    static let absoluteTimeIntervalSince1970 = 978307200.0
+    #endif
+  }
+}
+
+extension stat {
+
+  var lastAccessDate: Date {
+    #if os(macOS) || os(iOS) || os(tvOS) || os(visionOS) || os(watchOS)
+    return Date(timespec: st_atimespec)
+    #else
+    return Date(timespec: st_atim)
+    #endif
+  }
+}
+
+extension timeval {
+
+  init(timeIntervalSince1970: TimeInterval) {
+    let (integral, fractional) = modf(timeIntervalSince1970)
+    self.init(tv_sec: time_t(integral), tv_usec: suseconds_t(1.0e6 * fractional))
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/EmbeddedLibraries/ZipFoundation/Entry+Serialization.swift

@@ -0,0 +1,191 @@
+//
+//  Entry+Serialization.swift
+//  ZIPFoundation
+//
+//  Copyright © 2017-2025 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 Entry.LocalFileHeader {
+
+  // MARK: Lifecycle
+
+  init?(data: Data, additionalDataProvider provider: (Int) throws -> Data) {
+    guard data.count == Entry.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 = Entry.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 Entry.CentralDirectoryStructure {
+
+  // MARK: Lifecycle
+
+  init?(data: Data, additionalDataProvider provider: (Int) throws -> Data) {
+    guard data.count == Entry.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 = Entry.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 Entry.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/platforms/macos/src/vendor/Lottie/Private/EmbeddedLibraries/ZipFoundation/Entry+ZIP64.swift

@@ -0,0 +1,170 @@
+//
+//  Entry+ZIP64.swift
+//  ZIPFoundation
+//
+//  Copyright © 2017-2025 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 }
+}
+
+extension Entry {
+
+  enum EntryError: Error {
+    case missingPermissionsAttributeError
+    case missingModificationDateAttributeError
+  }
+
+  struct ZIP64ExtendedInformation: ExtensibleDataField {
+    static let headerSize: UInt16 = 4
+
+    let headerID: UInt16 = ExtraFieldHeaderID.zip64ExtendedInformation.rawValue
+    let dataSize: UInt16
+    let uncompressedSize: UInt64
+    let compressedSize: UInt64
+    let relativeOffsetOfLocalHeader: UInt64
+    let diskNumberStart: UInt32
+  }
+
+  var zip64ExtendedInformation: ZIP64ExtendedInformation? {
+    centralDirectoryStructure.zip64ExtendedInformation
+  }
+}
+
+typealias Field = Entry.ZIP64ExtendedInformation.Field
+
+extension Entry.LocalFileHeader {
+  var validFields: [Field] {
+    var fields = [Field]()
+    if uncompressedSize == .max { fields.append(.uncompressedSize) }
+    if compressedSize == .max { fields.append(.compressedSize) }
+    return fields
+  }
+}
+
+extension Entry.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: Entry.ZIP64ExtendedInformation? {
+    extraFields?.compactMap { $0 as? Entry.ZIP64ExtendedInformation }.first
+  }
+}
+
+extension Entry.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: BinaryInteger>(of field: Field) -> T {
+      if fields.contains(field), readOffset + field.size <= data.count {
+        defer { readOffset += MemoryLayout<T>.size }
+
+        return data.scanValue(start: readOffset)
+      } else {
+        return 0
+      }
+    }
+
+    dataSize = data.scanValue(start: 2)
+    uncompressedSize = value(of: .uncompressedSize)
+    compressedSize = value(of: .compressedSize)
+    relativeOffsetOfLocalHeader = value(of: .relativeOffsetOfLocalHeader)
+    diskNumberStart = value(of: .diskNumberStart)
+  }
+
+  init?(zip64ExtendedInformation: Entry.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 >= maxOffsetOfLocalFileHeader ? 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:
+        8
+      case .diskNumberStart:
+        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]) -> Entry.ZIP64ExtendedInformation? {
+    guard data.isEmpty == false else { return nil }
+    var offset = 0
+    var headerID: UInt16
+    var dataSize: UInt16
+    let extraFieldLength = data.count
+    let headerSize = Int(Entry.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 Entry.ZIP64ExtendedInformation(data: data.subdata(in: offset..<nextOffset), fields: fields)
+      }
+      offset = nextOffset
+    }
+    return nil
+  }
+}