import Foundation private final class CostUsageISO8601FormatterBox: @unchecked Sendable {    let lock = NSLock()    let withFractional: ISO8601DateFormatter = {        let fmt = ISO8601DateFormatter()        fmt.formatOptions = [.withInternetDateTime, .withFractionalSeconds]        return fmt    }()     let plain: ISO8601DateFormatter = {        let fmt = ISO8601DateFormatter()        fmt.formatOptions = [.withInternetDateTime]        return fmt    }()} private enum CostUsageTimestampParser {    static let box = CostUsageISO8601FormatterBox()     static func parseISO(_ text: String) -> Date? {        self.box.lock.lock()        defer { self.box.lock.unlock() }        return self.box.withFractional.date(from: text) ?? self.box.plain.date(from: text)    }} extension CostUsageScanner {    static func dateFromTimestamp(_ text: String) -> Date? {        CostUsageTimestampParser.parseISO(text)    }     static func dayKeyFromTimestamp(_ text: String) -> String? {        let bytes = Array(text.utf8)        guard bytes.count >= 20 else { return nil }        guard bytes[safe: 4] == 45, bytes[safe: 7] == 45 else { return nil }        guard let year = Self.parse4(bytes, at: 0),              let month = Self.parse2(bytes, at: 5),              let day = Self.parse2(bytes, at: 8) else { return nil }         var hour = 0        var minute = 0        var second = 0         if bytes[safe: 10] == 84 {            guard bytes.count >= 19 else { return nil }            guard bytes[safe: 13] == 58, bytes[safe: 16] == 58 else { return nil }            guard let parsedHour = Self.parse2(bytes, at: 11),                  let parsedMinute = Self.parse2(bytes, at: 14),                  let parsedSecond = Self.parse2(bytes, at: 17) else { return nil }            hour = parsedHour            minute = parsedMinute            second = parsedSecond        }         var tzIndex: Int?        var tzSign = 0        for idx in stride(from: bytes.count - 1, through: 11, by: -1) {            let byte = bytes[idx]            if byte == 90 {                tzIndex = idx                tzSign = 0                break            }            if byte == 43 {                tzIndex = idx                tzSign = 1                break            }            if byte == 45 {                tzIndex = idx                tzSign = -1                break            }        }         guard let tzStart = tzIndex else { return nil }        var offsetSeconds = 0        if tzSign != 0 {            let offsetStart = tzStart + 1            guard let hours = Self.parse2(bytes, at: offsetStart) else { return nil }            var minutes = 0            if bytes.count > offsetStart + 2 {                if bytes[safe: offsetStart + 2] == 58 {                    guard let parsedMinutes = Self.parse2(bytes, at: offsetStart + 3) else { return nil }                    minutes = parsedMinutes                } else if let parsedMinutes = Self.parse2(bytes, at: offsetStart + 2) {                    minutes = parsedMinutes                }            }            offsetSeconds = tzSign * ((hours * 3600) + (minutes * 60))        }         var comps = DateComponents()        comps.calendar = Calendar(identifier: .gregorian)        comps.timeZone = TimeZone(secondsFromGMT: offsetSeconds)        comps.year = year        comps.month = month        comps.day = day        comps.hour = hour        comps.minute = minute        comps.second = second         guard let date = comps.date else { return nil }        let local = Calendar.current.dateComponents([.year, .month, .day], from: date)        guard let localYear = local.year,              let localMonth = local.month,              let localDay = local.day else { return nil }        return String(format: "%04d-%02d-%02d", localYear, localMonth, localDay)    }     static func dayKeyFromParsedISO(_ text: String) -> String? {        guard let date = CostUsageTimestampParser.parseISO(text) else { return nil }        return CostUsageDayRange.dayKey(from: date)    }     private static func parse2(_ bytes: [UInt8], at index: Int) -> Int? {        guard let d0 = parseDigit(bytes[safe: index]),              let d1 = parseDigit(bytes[safe: index + 1]) else { return nil }        return d0 * 10 + d1    }     private static func parse4(_ bytes: [UInt8], at index: Int) -> Int? {        guard let d0 = parseDigit(bytes[safe: index]),              let d1 = parseDigit(bytes[safe: index + 1]),              let d2 = parseDigit(bytes[safe: index + 2]),              let d3 = parseDigit(bytes[safe: index + 3]) else { return nil }        return d0 * 1000 + d1 * 100 + d2 * 10 + d3    }     private static func parseDigit(_ byte: UInt8?) -> Int? {        guard let byte else { return nil }        guard byte >= 48, byte <= 57 else { return nil }        return Int(byte - 48)    }}