@octane-xplat/lottie 0.0.1 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Private/EmbeddedLibraries/ZipFoundation/Archive+WritingDeprecated.swift

@@ -0,0 +1,95 @@
+//
+//  Archive+WritingDeprecated.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 Archive {
+
+  @available(
+    *,
+    deprecated,
+    message: "Please use `Int` for `bufferSize`."
+  )
+  func addEntry(
+    with path: String,
+    relativeTo baseURL: URL,
+    compressionMethod: CompressionMethod = .none,
+    bufferSize: UInt32,
+    progress: Progress? = nil
+  ) throws {
+    try addEntry(
+      with: path,
+      relativeTo: baseURL,
+      compressionMethod: compressionMethod,
+      bufferSize: Int(bufferSize),
+      progress: progress
+    )
+  }
+
+  @available(
+    *,
+    deprecated,
+    message: "Please use `Int` for `bufferSize`."
+  )
+  func addEntry(
+    with path: String,
+    fileURL: URL,
+    compressionMethod: CompressionMethod = .none,
+    bufferSize: UInt32,
+    progress: Progress? = nil
+  ) throws {
+    try addEntry(
+      with: path,
+      fileURL: fileURL,
+      compressionMethod: compressionMethod,
+      bufferSize: Int(bufferSize),
+      progress: progress
+    )
+  }
+
+  @available(
+    *,
+    deprecated,
+    message: "Please use `Int64` for `uncompressedSize` and provider `position`. `Int` for `bufferSize`."
+  )
+  func addEntry(
+    with path: String,
+    type: Entry.EntryType,
+    uncompressedSize: UInt32,
+    modificationDate: Date = Date(),
+    permissions: UInt16? = nil,
+    compressionMethod: CompressionMethod = .none,
+    bufferSize: Int = defaultWriteChunkSize,
+    progress: Progress? = nil,
+    provider: (_ position: Int, _ size: Int) throws -> Data
+  ) throws {
+    let newProvider: Provider = { try provider(Int($0), $1) }
+    try addEntry(
+      with: path,
+      type: type,
+      uncompressedSize: Int64(uncompressedSize),
+      modificationDate: modificationDate,
+      permissions: permissions,
+      compressionMethod: compressionMethod,
+      bufferSize: bufferSize,
+      progress: progress,
+      provider: newProvider
+    )
+  }
+
+  @available(
+    *,
+    deprecated,
+    message: "Please use `Int` for `bufferSize`."
+  )
+  func remove(_ entry: Entry, bufferSize: UInt32, progress: Progress? = nil) throws {
+    try remove(entry, bufferSize: Int(bufferSize), progress: progress)
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/EmbeddedLibraries/ZipFoundation/Archive+ZIP64.swift

@@ -0,0 +1,191 @@
+//
+//  Archive+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
+
+let zip64EOCDRecordStructSignature = 0x06064b50
+let zip64EOCDLocatorStructSignature = 0x07064b50
+
+// MARK: - ExtraFieldHeaderID
+
+enum ExtraFieldHeaderID: UInt16 {
+  case zip64ExtendedInformation = 0x0001
+}
+
+extension Archive {
+  struct ZIP64EndOfCentralDirectory {
+    let record: ZIP64EndOfCentralDirectoryRecord
+    let locator: ZIP64EndOfCentralDirectoryLocator
+  }
+
+  struct ZIP64EndOfCentralDirectoryRecord: DataSerializable {
+    static let size = 56
+
+    let zip64EOCDRecordSignature = UInt32(zip64EOCDRecordStructSignature)
+    let sizeOfZIP64EndOfCentralDirectoryRecord: UInt64
+    let versionMadeBy: UInt16
+    let versionNeededToExtract: UInt16
+    let numberOfDisk: UInt32
+    let numberOfDiskStart: UInt32
+    let totalNumberOfEntriesOnDisk: UInt64
+    let totalNumberOfEntriesInCentralDirectory: UInt64
+    let sizeOfCentralDirectory: UInt64
+    let offsetToStartOfCentralDirectory: UInt64
+    let zip64ExtensibleDataSector: Data
+  }
+
+  struct ZIP64EndOfCentralDirectoryLocator: DataSerializable {
+    static let size = 20
+
+    let zip64EOCDLocatorSignature = UInt32(zip64EOCDLocatorStructSignature)
+    let numberOfDiskWithZIP64EOCDRecordStart: UInt32
+    let relativeOffsetOfZIP64EOCDRecord: UInt64
+    let totalNumberOfDisk: UInt32
+  }
+}
+
+extension Archive.ZIP64EndOfCentralDirectoryRecord {
+
+  // MARK: Lifecycle
+
+  init?(data: Data, additionalDataProvider _: (Int) throws -> Data) {
+    guard data.count == Archive.ZIP64EndOfCentralDirectoryRecord.size else { return nil }
+    guard data.scanValue(start: 0) == zip64EOCDRecordSignature else { return nil }
+    sizeOfZIP64EndOfCentralDirectoryRecord = data.scanValue(start: 4)
+    versionMadeBy = data.scanValue(start: 12)
+    versionNeededToExtract = data.scanValue(start: 14)
+    // Version Needed to Extract: 4.5 - File uses ZIP64 format extensions
+    guard versionNeededToExtract >= Archive.Version.v45.rawValue else { return nil }
+    numberOfDisk = data.scanValue(start: 16)
+    numberOfDiskStart = data.scanValue(start: 20)
+    totalNumberOfEntriesOnDisk = data.scanValue(start: 24)
+    totalNumberOfEntriesInCentralDirectory = data.scanValue(start: 32)
+    sizeOfCentralDirectory = data.scanValue(start: 40)
+    offsetToStartOfCentralDirectory = data.scanValue(start: 48)
+    zip64ExtensibleDataSector = Data()
+  }
+
+  init(
+    record: Archive.ZIP64EndOfCentralDirectoryRecord,
+    numberOfEntriesOnDisk: UInt64,
+    numberOfEntriesInCD: UInt64,
+    sizeOfCentralDirectory: UInt64,
+    offsetToStartOfCD: UInt64
+  ) {
+    sizeOfZIP64EndOfCentralDirectoryRecord = record.sizeOfZIP64EndOfCentralDirectoryRecord
+    versionMadeBy = record.versionMadeBy
+    versionNeededToExtract = record.versionNeededToExtract
+    numberOfDisk = record.numberOfDisk
+    numberOfDiskStart = record.numberOfDiskStart
+    totalNumberOfEntriesOnDisk = numberOfEntriesOnDisk
+    totalNumberOfEntriesInCentralDirectory = numberOfEntriesInCD
+    self.sizeOfCentralDirectory = sizeOfCentralDirectory
+    offsetToStartOfCentralDirectory = offsetToStartOfCD
+    zip64ExtensibleDataSector = record.zip64ExtensibleDataSector
+  }
+
+  // MARK: Internal
+
+  var data: Data {
+    var zip64EOCDRecordSignature = zip64EOCDRecordSignature
+    var sizeOfZIP64EOCDRecord = sizeOfZIP64EndOfCentralDirectoryRecord
+    var versionMadeBy = versionMadeBy
+    var versionNeededToExtract = versionNeededToExtract
+    var numberOfDisk = numberOfDisk
+    var numberOfDiskStart = numberOfDiskStart
+    var totalNumberOfEntriesOnDisk = totalNumberOfEntriesOnDisk
+    var totalNumberOfEntriesInCD = totalNumberOfEntriesInCentralDirectory
+    var sizeOfCD = sizeOfCentralDirectory
+    var offsetToStartOfCD = offsetToStartOfCentralDirectory
+    var data = Data()
+    withUnsafePointer(to: &zip64EOCDRecordSignature) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &sizeOfZIP64EOCDRecord) { 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: &numberOfDisk) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &numberOfDiskStart) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &totalNumberOfEntriesOnDisk) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &totalNumberOfEntriesInCD) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &sizeOfCD) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &offsetToStartOfCD) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    data.append(zip64ExtensibleDataSector)
+    return data
+  }
+
+}
+
+extension Archive.ZIP64EndOfCentralDirectoryLocator {
+
+  // MARK: Lifecycle
+
+  init?(data: Data, additionalDataProvider _: (Int) throws -> Data) {
+    guard data.count == Archive.ZIP64EndOfCentralDirectoryLocator.size else { return nil }
+    guard data.scanValue(start: 0) == zip64EOCDLocatorSignature else { return nil }
+    numberOfDiskWithZIP64EOCDRecordStart = data.scanValue(start: 4)
+    relativeOffsetOfZIP64EOCDRecord = data.scanValue(start: 8)
+    totalNumberOfDisk = data.scanValue(start: 16)
+  }
+
+  init(locator: Archive.ZIP64EndOfCentralDirectoryLocator, offsetOfZIP64EOCDRecord: UInt64) {
+    numberOfDiskWithZIP64EOCDRecordStart = locator.numberOfDiskWithZIP64EOCDRecordStart
+    relativeOffsetOfZIP64EOCDRecord = offsetOfZIP64EOCDRecord
+    totalNumberOfDisk = locator.totalNumberOfDisk
+  }
+
+  // MARK: Internal
+
+  var data: Data {
+    var zip64EOCDLocatorSignature = zip64EOCDLocatorSignature
+    var numberOfDiskWithZIP64EOCD = numberOfDiskWithZIP64EOCDRecordStart
+    var offsetOfZIP64EOCDRecord = relativeOffsetOfZIP64EOCDRecord
+    var totalNumberOfDisk = totalNumberOfDisk
+    var data = Data()
+    withUnsafePointer(to: &zip64EOCDLocatorSignature) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &numberOfDiskWithZIP64EOCD) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &offsetOfZIP64EOCDRecord) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &totalNumberOfDisk) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    return data
+  }
+
+}
+
+extension Archive.ZIP64EndOfCentralDirectory {
+  var data: Data {
+    record.data + locator.data
+  }
+}
+
+/// Properties that represent the maximum value of each field
+var maxUInt32 = UInt32.max
+var maxUInt16 = UInt16.max
+
+var maxCompressedSize: UInt32 {
+  maxUInt32
+}
+
+var maxUncompressedSize: UInt32 {
+  maxUInt32
+}
+
+var maxOffsetOfLocalFileHeader: UInt32 {
+  maxUInt32
+}
+
+var maxOffsetOfCentralDirectory: UInt32 {
+  maxUInt32
+}
+
+var maxSizeOfCentralDirectory: UInt32 {
+  maxUInt32
+}
+
+var maxTotalNumberOfEntries: UInt16 {
+  maxUInt16
+}

package/platforms/macos/src/vendor/Lottie/Private/EmbeddedLibraries/ZipFoundation/Archive.swift

@@ -0,0 +1,404 @@
+//
+//  Archive.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
+
+/// The default chunk size when reading entry data from an archive.
+let defaultReadChunkSize = Int(16 * 1024)
+/// The default chunk size when writing entry data to an archive.
+let defaultWriteChunkSize = defaultReadChunkSize
+/// The default permissions for newly added entries.
+let defaultFilePermissions = UInt16(0o644)
+/// The default permissions for newly added directories.
+let defaultDirectoryPermissions = UInt16(0o755)
+let defaultPOSIXBufferSize = defaultReadChunkSize
+let defaultDirectoryUnitCount = Int64(1)
+let minEndOfCentralDirectoryOffset = Int64(22)
+let endOfCentralDirectoryStructSignature = 0x06054b50
+let localFileHeaderStructSignature = 0x04034b50
+let dataDescriptorStructSignature = 0x08074b50
+let centralDirectoryStructSignature = 0x02014b50
+let memoryURLScheme = "memory"
+
+// MARK: - Archive
+
+/// A sequence of uncompressed or compressed ZIP entries.
+///
+/// You use an `Archive` to create, read or update ZIP files.
+/// To read an existing ZIP file, you have to pass in an existing file `URL` and `AccessMode.read`:
+///
+///     var archiveURL = URL(fileURLWithPath: "/path/file.zip")
+///     var archive = Archive(url: archiveURL, accessMode: .read)
+///
+/// An `Archive` is a sequence of entries. You can
+/// iterate over an archive using a `for`-`in` loop to get access to individual `Entry` objects:
+///
+///     for entry in archive {
+///         print(entry.path)
+///     }
+///
+/// Each `Entry` in an `Archive` is represented by its `path`. You can
+/// use `path` to retrieve the corresponding `Entry` from an `Archive` via subscripting:
+///
+///     let entry = archive['/path/file.txt']
+///
+/// To create a new `Archive`, pass in a non-existing file URL and `AccessMode.create`. To modify an
+/// existing `Archive` use `AccessMode.update`:
+///
+///     var archiveURL = URL(fileURLWithPath: "/path/file.zip")
+///     var archive = Archive(url: archiveURL, accessMode: .update)
+///     try archive?.addEntry("test.txt", relativeTo: baseURL, compressionMethod: .deflate)
+final class Archive: Sequence {
+
+  // MARK: Lifecycle
+
+  /// Initializes a new ZIP `Archive`.
+  ///
+  /// You can use this initalizer to create new archive files or to read and update existing ones.
+  /// The `mode` parameter indicates the intended usage of the archive: `.read`, `.create` or `.update`.
+  /// - Parameters:
+  ///   - url: File URL to the receivers backing file.
+  ///   - mode: Access mode of the receiver.
+  ///   - pathEncoding: Encoding for entry paths. Overrides the encoding specified in the archive.
+  ///                   This encoding is only used when _decoding_ paths from the receiver.
+  ///                   Paths of entries added with `addEntry` are always UTF-8 encoded.
+  /// - Returns: An archive initialized with a backing file at the passed in file URL and the given access mode
+  ///   or `nil` if the following criteria are not met:
+  /// - Note:
+  ///   - The file URL _must_ point to an existing file for `AccessMode.read`.
+  ///   - The file URL _must_ point to a non-existing file for `AccessMode.create`.
+  ///   - The file URL _must_ point to an existing file for `AccessMode.update`.
+  init(url: URL, accessMode mode: AccessMode, pathEncoding: String.Encoding? = nil) throws {
+    self.url = url
+    accessMode = mode
+    self.pathEncoding = pathEncoding
+    let config = try Archive.makeBackingConfiguration(for: url, mode: mode)
+    archiveFile = config.file
+    endOfCentralDirectoryRecord = config.endOfCentralDirectoryRecord
+    zip64EndOfCentralDirectory = config.zip64EndOfCentralDirectory
+    setvbuf(archiveFile, nil, _IOFBF, Int(defaultPOSIXBufferSize))
+  }
+
+  deinit {
+    fclose(self.archiveFile)
+  }
+
+  // MARK: Internal
+
+  typealias LocalFileHeader = Entry.LocalFileHeader
+  typealias DataDescriptor = Entry.DefaultDataDescriptor
+  typealias ZIP64DataDescriptor = Entry.ZIP64DataDescriptor
+  typealias CentralDirectoryStructure = Entry.CentralDirectoryStructure
+
+  /// An error that occurs during reading, creating or updating a ZIP file.
+  enum ArchiveError: Error {
+    /// Thrown when an archive file is either damaged or inaccessible.
+    case unreadableArchive
+    /// Thrown when an archive is either opened with AccessMode.read or the destination file is unwritable.
+    case unwritableArchive
+    /// Thrown when the path of an `Entry` cannot be stored in an archive.
+    case invalidEntryPath
+    /// Thrown when an `Entry` can't be stored in the archive with the proposed compression method.
+    case invalidCompressionMethod
+    /// Thrown when the stored checksum of an `Entry` doesn't match the checksum during reading.
+    case invalidCRC32
+    /// Thrown when an extract, add or remove operation was canceled.
+    case cancelledOperation
+    /// Thrown when an extract operation was called with zero or negative `bufferSize` parameter.
+    case invalidBufferSize
+    /// Thrown when uncompressedSize/compressedSize exceeds `Int64.max` (Imposed by file API).
+    case invalidEntrySize
+    /// Thrown when the offset of local header data exceeds `Int64.max` (Imposed by file API).
+    case invalidLocalHeaderDataOffset
+    /// Thrown when the size of local header exceeds `Int64.max` (Imposed by file API).
+    case invalidLocalHeaderSize
+    /// Thrown when the offset of central directory exceeds `Int64.max` (Imposed by file API).
+    case invalidCentralDirectoryOffset
+    /// Thrown when the size of central directory exceeds `UInt64.max` (Imposed by ZIP specification).
+    case invalidCentralDirectorySize
+    /// Thrown when number of entries in central directory exceeds `UInt64.max` (Imposed by ZIP specification).
+    case invalidCentralDirectoryEntryCount
+    /// Thrown when an archive does not contain the required End of Central Directory Record.
+    case missingEndOfCentralDirectoryRecord
+    /// Thrown when an entry contains a symlink pointing to a path outside the destination directory.
+    case uncontainedSymlink
+  }
+
+  /// The access mode for an `Archive`.
+  enum AccessMode: UInt {
+    /// Indicates that a newly instantiated `Archive` should create its backing file.
+    case create
+    /// Indicates that a newly instantiated `Archive` should read from an existing backing file.
+    case read
+    /// Indicates that a newly instantiated `Archive` should update an existing backing file.
+    case update
+
+    /// Indicates that the archive can be written to.
+    var isWritable: Bool {
+      self != .read
+    }
+  }
+
+  /// The version of an `Archive`
+  enum Version: UInt16 {
+    /// The minimum version for deflate compressed archives
+    case v20 = 20
+    /// The minimum version for archives making use of ZIP64 extensions
+    case v45 = 45
+  }
+
+  struct EndOfCentralDirectoryRecord: DataSerializable {
+    static let size = 22
+
+    let endOfCentralDirectorySignature = UInt32(endOfCentralDirectoryStructSignature)
+    let numberOfDisk: UInt16
+    let numberOfDiskStart: UInt16
+    let totalNumberOfEntriesOnDisk: UInt16
+    let totalNumberOfEntriesInCentralDirectory: UInt16
+    let sizeOfCentralDirectory: UInt32
+    let offsetToStartOfCentralDirectory: UInt32
+    let zipFileCommentLength: UInt16
+    let zipFileCommentData: Data
+  }
+
+  /// URL of an Archive's backing file.
+  let url: URL
+  /// Access mode for an archive file.
+  let accessMode: AccessMode
+  var endOfCentralDirectoryRecord: EndOfCentralDirectoryRecord
+  var zip64EndOfCentralDirectory: ZIP64EndOfCentralDirectory?
+  var pathEncoding: String.Encoding?
+
+  #if swift(>=5.0)
+  var memoryFile: MemoryFile?
+
+  /// Initializes a new in-memory ZIP `Archive`.
+  ///
+  /// You can use this initalizer to create new in-memory archive files or to read and update existing ones.
+  ///
+  /// - Parameters:
+  ///   - data: `Data` object used as backing for in-memory archives.
+  ///   - mode: Access mode of the receiver.
+  ///   - pathEncoding: Encoding for entry paths. Overrides the encoding specified in the archive.
+  ///                   This encoding is only used when _decoding_ paths from the receiver.
+  ///                   Paths of entries added with `addEntry` are always UTF-8 encoded.
+  /// - Returns: An in-memory archive initialized with passed in backing data.
+  /// - Note:
+  ///   - The backing `data` _must_ contain a valid ZIP archive for `AccessMode.read` and `AccessMode.update`.
+  ///   - The backing `data` _must_ be empty (or omitted) for `AccessMode.create`.
+  init(data: Data = Data(), accessMode mode: AccessMode, pathEncoding: String.Encoding? = nil) throws {
+    let url = URL(string: "\(memoryURLScheme)://")!
+    self.url = url
+    accessMode = mode
+    self.pathEncoding = pathEncoding
+    let config = try Archive.makeBackingConfiguration(for: data, mode: mode)
+    archiveFile = config.file
+    memoryFile = config.memoryFile
+    endOfCentralDirectoryRecord = config.endOfCentralDirectoryRecord
+    zip64EndOfCentralDirectory = config.zip64EndOfCentralDirectory
+  }
+  #endif
+
+  var archiveFile: FILEPointer {
+    willSet {
+      fclose(archiveFile)
+    }
+  }
+
+  var totalNumberOfEntriesInCentralDirectory: UInt64 {
+    zip64EndOfCentralDirectory?.record.totalNumberOfEntriesInCentralDirectory
+      ?? UInt64(endOfCentralDirectoryRecord.totalNumberOfEntriesInCentralDirectory)
+  }
+
+  var sizeOfCentralDirectory: UInt64 {
+    zip64EndOfCentralDirectory?.record.sizeOfCentralDirectory
+      ?? UInt64(endOfCentralDirectoryRecord.sizeOfCentralDirectory)
+  }
+
+  var offsetToStartOfCentralDirectory: UInt64 {
+    zip64EndOfCentralDirectory?.record.offsetToStartOfCentralDirectory
+      ?? UInt64(endOfCentralDirectoryRecord.offsetToStartOfCentralDirectory)
+  }
+
+  static func scanForEndOfCentralDirectoryRecord(in file: FILEPointer)
+    -> EndOfCentralDirectoryStructure?
+  {
+    var eocdOffset: UInt64 = 0
+    var index = minEndOfCentralDirectoryOffset
+    fseeko(file, 0, SEEK_END)
+    let archiveLength = Int64(ftello(file))
+    guard archiveLength >= 0 else { return nil }
+
+    while eocdOffset == 0, index <= archiveLength {
+      fseeko(file, off_t(archiveLength - index), SEEK_SET)
+      var potentialDirectoryEndTag = UInt32()
+      fread(&potentialDirectoryEndTag, 1, MemoryLayout<UInt32>.size, file)
+      if potentialDirectoryEndTag == UInt32(endOfCentralDirectoryStructSignature) {
+        eocdOffset = UInt64(archiveLength - index)
+        guard let eocd: EndOfCentralDirectoryRecord = Data.readStruct(from: file, at: eocdOffset) else {
+          return nil
+        }
+        let zip64EOCD = scanForZIP64EndOfCentralDirectory(in: file, eocdOffset: eocdOffset)
+        return (eocd, zip64EOCD)
+      }
+      index += 1
+    }
+    return nil
+  }
+
+  func makeIterator() -> AnyIterator<Entry> {
+    let totalNumberOfEntriesInCD = totalNumberOfEntriesInCentralDirectory
+    var directoryIndex = offsetToStartOfCentralDirectory
+    var index = 0
+    return AnyIterator {
+      guard index < totalNumberOfEntriesInCD else { return nil }
+      guard
+        let centralDirStruct: CentralDirectoryStructure = Data.readStruct(
+          from: self.archiveFile,
+          at: directoryIndex
+        )
+      else {
+        return nil
+      }
+      let offset = UInt64(centralDirStruct.effectiveRelativeOffsetOfLocalHeader)
+      guard
+        let localFileHeader: LocalFileHeader = Data.readStruct(
+          from: self.archiveFile,
+          at: offset
+        )
+      else { return nil }
+      var dataDescriptor: DataDescriptor?
+      var zip64DataDescriptor: ZIP64DataDescriptor?
+      if centralDirStruct.usesDataDescriptor {
+        let additionalSize = UInt64(localFileHeader.fileNameLength) + UInt64(localFileHeader.extraFieldLength)
+        let isCompressed = centralDirStruct.compressionMethod != CompressionMethod.none.rawValue
+        let dataSize = isCompressed
+          ? centralDirStruct.effectiveCompressedSize
+          : centralDirStruct.effectiveUncompressedSize
+        let descriptorPosition = offset + UInt64(LocalFileHeader.size) + additionalSize + dataSize
+        if centralDirStruct.isZIP64 {
+          zip64DataDescriptor = Data.readStruct(from: self.archiveFile, at: descriptorPosition)
+        } else {
+          dataDescriptor = Data.readStruct(from: self.archiveFile, at: descriptorPosition)
+        }
+      }
+      defer {
+        directoryIndex += UInt64(CentralDirectoryStructure.size)
+        directoryIndex += UInt64(centralDirStruct.fileNameLength)
+        directoryIndex += UInt64(centralDirStruct.extraFieldLength)
+        directoryIndex += UInt64(centralDirStruct.fileCommentLength)
+        index += 1
+      }
+      return Entry(
+        centralDirectoryStructure: centralDirStruct,
+        localFileHeader: localFileHeader,
+        dataDescriptor: dataDescriptor,
+        zip64DataDescriptor: zip64DataDescriptor
+      )
+    }
+  }
+
+  /// Retrieve the ZIP `Entry` with the given `path` from the receiver.
+  ///
+  /// - Note: The ZIP file format specification does not enforce unique paths for entries.
+  ///   Therefore an archive can contain multiple entries with the same path. This method
+  ///   always returns the first `Entry` with the given `path`.
+  ///
+  /// - Parameter path: A relative file path identifying the corresponding `Entry`.
+  /// - Returns: An `Entry` with the given `path`. Otherwise, `nil`.
+  subscript(path: String) -> Entry? {
+    if let encoding = pathEncoding {
+      return first { $0.path(using: encoding) == path }
+    }
+    return first { $0.path == path }
+  }
+
+  // MARK: Private
+
+  private static func scanForZIP64EndOfCentralDirectory(in file: FILEPointer, eocdOffset: UInt64)
+    -> ZIP64EndOfCentralDirectory?
+  {
+    guard UInt64(ZIP64EndOfCentralDirectoryLocator.size) < eocdOffset else { return nil }
+
+    let locatorOffset = eocdOffset - UInt64(ZIP64EndOfCentralDirectoryLocator.size)
+    guard UInt64(ZIP64EndOfCentralDirectoryRecord.size) < locatorOffset else { return nil }
+
+    let recordOffset = locatorOffset - UInt64(ZIP64EndOfCentralDirectoryRecord.size)
+    guard
+      let locator: ZIP64EndOfCentralDirectoryLocator = Data.readStruct(from: file, at: locatorOffset),
+      let record: ZIP64EndOfCentralDirectoryRecord = Data.readStruct(from: file, at: recordOffset)
+    else {
+      return nil
+    }
+    return ZIP64EndOfCentralDirectory(record: record, locator: locator)
+  }
+}
+
+extension Archive.EndOfCentralDirectoryRecord {
+
+  // MARK: Lifecycle
+
+  init?(data: Data, additionalDataProvider provider: (Int) throws -> Data) {
+    guard data.count == Archive.EndOfCentralDirectoryRecord.size else { return nil }
+    guard data.scanValue(start: 0) == endOfCentralDirectorySignature else { return nil }
+    numberOfDisk = data.scanValue(start: 4)
+    numberOfDiskStart = data.scanValue(start: 6)
+    totalNumberOfEntriesOnDisk = data.scanValue(start: 8)
+    totalNumberOfEntriesInCentralDirectory = data.scanValue(start: 10)
+    sizeOfCentralDirectory = data.scanValue(start: 12)
+    offsetToStartOfCentralDirectory = data.scanValue(start: 16)
+    zipFileCommentLength = data.scanValue(start: 20)
+    guard let commentData = try? provider(Int(zipFileCommentLength)) else { return nil }
+    guard commentData.count == Int(zipFileCommentLength) else { return nil }
+    zipFileCommentData = commentData
+  }
+
+  init(
+    record: Archive.EndOfCentralDirectoryRecord,
+    numberOfEntriesOnDisk: UInt16,
+    numberOfEntriesInCentralDirectory: UInt16,
+    updatedSizeOfCentralDirectory: UInt32,
+    startOfCentralDirectory: UInt32
+  ) {
+    numberOfDisk = record.numberOfDisk
+    numberOfDiskStart = record.numberOfDiskStart
+    totalNumberOfEntriesOnDisk = numberOfEntriesOnDisk
+    totalNumberOfEntriesInCentralDirectory = numberOfEntriesInCentralDirectory
+    sizeOfCentralDirectory = updatedSizeOfCentralDirectory
+    offsetToStartOfCentralDirectory = startOfCentralDirectory
+    zipFileCommentLength = record.zipFileCommentLength
+    zipFileCommentData = record.zipFileCommentData
+  }
+
+  // MARK: Internal
+
+  var data: Data {
+    var endOfCDSignature = endOfCentralDirectorySignature
+    var numberOfDisk = numberOfDisk
+    var numberOfDiskStart = numberOfDiskStart
+    var totalNumberOfEntriesOnDisk = totalNumberOfEntriesOnDisk
+    var totalNumberOfEntriesInCD = totalNumberOfEntriesInCentralDirectory
+    var sizeOfCentralDirectory = sizeOfCentralDirectory
+    var offsetToStartOfCD = offsetToStartOfCentralDirectory
+    var zipFileCommentLength = zipFileCommentLength
+    var data = Data()
+    withUnsafePointer(to: &endOfCDSignature) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &numberOfDisk) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &numberOfDiskStart) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &totalNumberOfEntriesOnDisk) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &totalNumberOfEntriesInCD) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &sizeOfCentralDirectory) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &offsetToStartOfCD) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    withUnsafePointer(to: &zipFileCommentLength) { data.append(UnsafeBufferPointer(start: $0, count: 1)) }
+    data.append(zipFileCommentData)
+    return data
+  }
+
+}