guard !data.isEmpty else { return nil }

var storage = Storage()

var index = data.startIndex

do {

while index < data.endIndex {

let majorType = CBOR.majorType(for: data[index])

switch majorType {

case .unsigned:

let unsigned = try decode(UInt64.self, from: data[index...])

try storage.append(unsigned.value)

index += unsigned.decodedBytes

case .negative:

let signed: (value: Any, decodedBytes: Int)

do {

let result = try decode(Int64.self, from: data[index...])

signed = (result.value, result.decodedBytes)

} catch let firstError {

do {

let result = try decode(CBOR.NegativeUInt64.self, from: data[index...])

signed = (result.value, result.decodedBytes)

} catch {

throw firstError

}

}

try storage.append(signed.value)

index += signed.decodedBytes

case .bytes:

let bytes = try decode(Data.self, from: data[index...])

try storage.append(bytes.value)

index += bytes.decodedBytes

case .string:

let string = try decode(String.self, from: data[index...])

try storage.append(string.value)

index += string.decodedBytes

case .array:

let additionalInfo = CBOR.additionalInfo(for: data[index])

if additionalInfo == 31 { // Indefinite length array

try storage.startUnkeyedContainer(ofLength: nil)

index += 1

} else {

let unsigned = try decode(UInt64.self, from: data[index...], knownMajorType: majorType)

try storage.startUnkeyedContainer(ofLength: unsigned.value)

index += unsigned.decodedBytes

}

case .map:

let additionalInfo = CBOR.additionalInfo(for: data[index])

if additionalInfo == 31 { // Indefinite length map

try storage.startKeyedContainer(ofLength: nil)

index += 1

} else {

let unsigned = try decode(UInt64.self, from: data[index...], knownMajorType: majorType)

try storage.startKeyedContainer(ofLength: unsigned.value)

index += unsigned.decodedBytes

}

case .tag:

if let tag = CBOR.Tag(bits: data[index...]) {

index += tag.bits.count

switch tag {

case .standardDateTime, .epochDateTime:

let date = try decode(Date.self, tag: tag, from: data[index...])

try storage.append(date.value)

index += date.decodedBytes

case .positiveBignum, .negativeBignum:

let bignum = try decode(CBOR.Bignum.self, tag: tag, from: data[index...])

try storage.append(bignum.value)

index += bignum.decodedBytes

case .decimalFraction:

let decimal = try decode(CBOR.DecimalFraction<Int64, Int64>.self, from: data[index...])

try storage.append(decimal.value)

index += decimal.decodedBytes

case .bigfloat:

let bigfloat = try decode(CBOR.Bigfloat<Int64, Int64>.self, from: data[index...])

try storage.append(bigfloat.value)

index += bigfloat.decodedBytes

case .base64URLConversion, .base64Conversion, .base16Conversion:

do {

let string = try decode(String.self, from: data[index...])

try storage.append(string.value)

index += string.decodedBytes

} catch {

do {

let bytes = try decode(Data.self, from: data[index...])

try storage.append(bytes.value)

index += bytes.decodedBytes

} catch {

throw CBOR.DecodingError.dataCorrupted(description: "Unable to decode string or data for tag \"\(tag.description)\"")

}

}

case .encodedCBORData:

let bytes = try decode(Data.self, from: data[index...])

try storage.append(bytes.value)

index += bytes.decodedBytes

case .uri:

let url = try decode(URL.self, from: data[index...])

try storage.append(url.value)

index += url.decodedBytes

case .base64URL, .base64, .regularExpression:

let string = try decode(String.self, from: data[index...])

let decodedString = try string.value.decodedStringValue()

if tag == .base64URL {

let data = Data(base64Encoded: decodedString.replacingOccurrences(of: "-", with: "+")

.replacingOccurrences(of: "_", with: "/")

.appending(String(repeating: "=", count: decodedString.count % 4)))

guard let validatedData = data else {

throw CBOR.DecodingError.dataCorrupted(description: "Invalid Base64-URL encoded string")

}

try storage.append(validatedData)

} else if tag == .base64 {

guard let data = Data(base64Encoded: decodedString) else {

throw CBOR.DecodingError.dataCorrupted(description: "Invalid Base64 encoded string")

}

try storage.append(data)

} else /* if tag == .regularExpression */ {

guard (try? NSRegularExpression(pattern: decodedString, options: [])) != nil else {

throw CBOR.DecodingError.dataCorrupted(description: "Invalid Regular Expression")

}

try storage.append(decodedString)

}

index += string.decodedBytes

case .mimeMessage:

let string = try decode(String.self, from: data[index...])

try storage.append(string.value)

index += string.decodedBytes

case .selfDescribedCBOR:

break // skip the tag and continue

}

} else {

let unsigned: UInt64

do {

unsigned = try decode(UInt64.self, from: data[index...], knownMajorType: .tag).value

} catch {

throw CBOR.DecodingError.dataCorrupted(description: "Invalid CBOR tag")

}

throw CBOR.DecodingError.dataCorrupted(description: "Invalid CBOR tag <\(unsigned)>")

}

case .additonal:

let additionalInfo = CBOR.additionalInfo(for: data[index])

switch additionalInfo {

case 0...19:

try storage.append(CBOR.SimpleValue(rawValue: additionalInfo))

index += 1

case 20:

try storage.append(false)

index += 1

case 21:

try storage.append(true)

index += 1

case 22:

try storage.append(CBOR.Null())

index += 1

case 23:

try storage.append(CBOR.Undefined())

index += 1

case 24:

let simple = try decode(CBOR.SimpleValue.self, from: data[index...])

try storage.append(simple.value)

index += simple.decodedBytes

case 25:

let half = try decode(Half.self, from: data[index...])

try storage.append(half.value)

index += half.decodedBytes

case 26:

let float = try decode(Float.self, from: data[index...])

try storage.append(float.value)

index += float.decodedBytes

case 27:

let double = try decode(Double.self, from: data[index...])

try storage.append(double.value)

index += double.decodedBytes

case 31: // Break

try storage.endCurrentContainer()

index += 1

default:

throw CBOR.DecodingError.dataCorrupted(description: "Invalid decoded value for major type 7 (\(additionalInfo))")

}

}

}

} catch let error as CBOR.DecodingError {

throw Swift.DecodingError(internalError: error, at: codingPath)

}

return try storage.finalize()

do {

guard !bytes.isEmpty else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: nil)

}

let type: Any.Type

let majorType = CBOR.majorType(for: bytes[bytes.startIndex])

let additionalInfo = CBOR.additionalInfo(for: bytes[bytes.startIndex])

switch majorType {

case .unsigned:

switch additionalInfo {

case 0...24: type = UInt8.self

case 25: type = UInt16.self

case 26: type = UInt32.self

case 27: type = UInt64.self

default: throw CBOR.DecodingError.dataCorrupted(description: "Invalid encoded length for expected unsigned integer")

}

case .negative:

switch additionalInfo {

case 0...24: type = Int8.self

case 25: type = Int16.self

case 26: type = Int32.self

case 27: type = Int64.self

default: throw CBOR.DecodingError.dataCorrupted(description: "Invalid encoded length for expected signed integer")

}

case .bytes:

switch additionalInfo {

case 0...27: type = Data.self

default: throw CBOR.DecodingError.dataCorrupted(description: "Invalid encoded byte length for expected data")

}

case .string:

switch additionalInfo {

case 0...27: type = String.self

default: throw CBOR.DecodingError.dataCorrupted(description: "Invalid encoded byte length for expected string")

}

case .array:

switch additionalInfo {

case 0...27: type = Array<Any>.self

default: throw CBOR.DecodingError.dataCorrupted(description: "Invalid encoded byte length for expected array")

}

case .map:

switch additionalInfo {

case 0...27: type = Dictionary<String, Any>.self

default: throw CBOR.DecodingError.dataCorrupted(description: "Invalid encoded byte length for expected map")

}

case .tag:

switch additionalInfo {

case 0, 1: type = Date.self

case 2, 3: type = Data.self

case 4, 5: type = Array<Int>.self

case 21...23: type = Data.self

case 24:

guard bytes.count > 1 else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: nil)

}

switch bytes[bytes.index(after: bytes.startIndex)] {

case 24: type = Data.self

case 32...36: type = String.self

default: throw CBOR.DecodingError.dataCorrupted(description: "Invalid encoded tag")

}

case 25:

guard bytes.count > 2 else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: nil)

}

switch (bytes[bytes.index(bytes.startIndex, offsetBy: 1)], bytes[bytes.index(bytes.startIndex, offsetBy: 2)]) {

case (0xD9, 0xF7): type = Data.self

default: throw CBOR.DecodingError.dataCorrupted(description: "Invalid encoded tag")

}

default:

throw CBOR.DecodingError.dataCorrupted(description: "Invalid encoded tag")

}

case .additonal:

switch additionalInfo {

case 0...19: type = CBOR.SimpleValue.self

case 20, 21: type = Bool.self

case 22: type = CBOR.Null.self

case 23: type = CBOR.Undefined.self

case 24: type = CBOR.SimpleValue.self

case 25, 26: type = Float.self

case 27: type = Double.self

case 31: type = CBOR.Break.self

default: throw CBOR.DecodingError.dataCorrupted(description: "Invalid encoded data type")

}

}

return type

} catch let error as CBOR.DecodingError {

throw Swift.DecodingError(internalError: error, at: [])

}

guard !data.isEmpty else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

let majorType = CBOR.majorType(for: data[data.startIndex])

guard majorType == .string else {

throw CBOR.DecodingError.typeMismatch(expected: [type], actual: try self.type(for: data))

}

let additionalInfo = CBOR.additionalInfo(for: data[data.startIndex])

let result: (value: CBORDecodedString, decodedBytes: Int)

if additionalInfo == 31 {

// Indefinite length string

guard data.count > 1 else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

var index = data.index(after: data.startIndex)

var resultString = CBOR.IndefiniteLengthString()

while true {

guard index < data.endIndex else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

guard data[index] != CBOR.Bits.break.rawValue else {

index = data.index(after: index) // for the `break` byte

break

}

let count = try decode(UInt64.self, from: Data(data[index...]), knownMajorType: majorType)

if count.value == 0 {

resultString.chunks.append(Data())

index += count.decodedBytes

} else {

guard let nextIndex = data.index(index, offsetBy: count.decodedBytes + Int(count.value), limitedBy: data.endIndex), data.endIndex > nextIndex else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

let utf8Data = Data(data[data.index(index, offsetBy: count.decodedBytes) ..< nextIndex])

resultString.chunks.append(utf8Data)

index = nextIndex

}

}

result = (resultString, data.distance(from: data.startIndex, to: index))

} else {

// Definite length string

let count = try decode(UInt64.self, from: data, knownMajorType: majorType)

if count.value == 0 {

result = ("", count.decodedBytes)

} else {

guard let nextIndex = data.index(data.startIndex, offsetBy: Int(count.value + UInt64(count.decodedBytes)), limitedBy: data.endIndex), data.endIndex >= nextIndex else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

let utf8Data = Data(data[data.index(data.startIndex, offsetBy: count.decodedBytes) ..< nextIndex])

guard let string = String(data: utf8Data, encoding: .utf8) else {

throw CBOR.DecodingError.invalidUTF8String

}

result = (string, count.decodedBytes + Int(count.value))

}

}

return result

guard !data.isEmpty else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

let majorType = CBOR.majorType(for: data[data.startIndex])

guard majorType == .bytes else {

throw CBOR.DecodingError.typeMismatch(expected: [type], actual: try self.type(for: data))

}

let additionalInfo = CBOR.additionalInfo(for: data[data.startIndex])

let result: (value: CBORDecodedData, decodedBytes: Int)

if additionalInfo == 31 {

// Indefinite length byte data

guard data.count > 1 else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

var index = data.index(after: data.startIndex)

var resultData = CBOR.IndefiniteLengthData()

repeat {

guard index < data.endIndex else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

guard data[index] != CBOR.Bits.break.rawValue else {

index = data.index(after: index) // for the `break` byte

break

}

let decoded = try decode(type, from: Data(data[index...]))

resultData.chunks.append(decoded.value.decodedDataValue())

index = data.index(index, offsetBy: decoded.decodedBytes)

} while true

result = (resultData, data.distance(from: data.startIndex, to: index))

} else {

// Definite length byte data

let count = try decode(UInt64.self, from: data, knownMajorType: majorType)

if count.value == 0 {

result = (Data(), count.decodedBytes)

} else {

guard let nextIndex = data.index(data.startIndex, offsetBy: count.decodedBytes + Int(count.value), limitedBy: data.endIndex), data.endIndex >= nextIndex else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

result = (data[data.index(data.startIndex, offsetBy: count.decodedBytes) ..< nextIndex], count.decodedBytes + Int(count.value))

}

}

return result

precondition(tag == .standardDateTime || tag == .epochDateTime)

guard !data.isEmpty else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

let result: (value: Date, decodedBytes: Int)

if tag == .standardDateTime { // RFC3339

let dateString = try decode(String.self, from: data)

let formatter = DateFormatter()

formatter.locale = Locale(identifier: "en_US_POSIX")

formatter.dateFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'"

formatter.timeZone = TimeZone(secondsFromGMT: 0)

guard let date = formatter.date(from: try dateString.value.decodedStringValue()) else {

throw CBOR.DecodingError.invalidRFC3339DateString

}

result = (date, dateString.decodedBytes)

} else /* if tag == .epochDateTime */ { // Epoch

do {

let timeInterval = try decode(Double.self, from: data)

result = (Date(timeIntervalSince1970: TimeInterval(timeInterval.value)), timeInterval.decodedBytes)

} catch {

do {

let timeInterval = try decode(Int64.self, from: data)

result = (Date(timeIntervalSince1970: TimeInterval(timeInterval.value)), timeInterval.decodedBytes)

} catch {

do {

let timeInterval = try decode(UInt64.self, from: data)

result = (Date(timeIntervalSince1970: TimeInterval(timeInterval.value)), timeInterval.decodedBytes)

} catch {

throw CBOR.DecodingError.typeMismatch(expected: [TimeInterval.self, Int.self, UInt.self], actual: try self.type(for: data))

}

}

}

}

return result

guard !data.isEmpty else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

let majorType = CBOR.majorType(for: data[data.startIndex])

guard majorType == .string else {

throw CBOR.DecodingError.typeMismatch(expected: [type], actual: try self.type(for: data))

}

let string = try decode(String.self, from: data)

guard let url = URL(string: try string.value.decodedStringValue()) else {

throw CBOR.DecodingError.dataCorrupted(description: "Invalid URL string.")

}

return (url, string.decodedBytes)

guard !data.isEmpty else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

let majorType = CBOR.majorType(for: data[data.startIndex])

guard majorType == .negative else {

throw CBOR.DecodingError.typeMismatch(expected: [type], actual: try self.type(for: data))

}

let unsigned = try decode(UInt64.self, from: data, knownMajorType: majorType)

return (CBOR.NegativeUInt64(rawValue: unsigned.value == .max ? .min : (unsigned.value + 1)), unsigned.decodedBytes)

guard !data.isEmpty else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

let majorType = CBOR.majorType(for: data[data.startIndex])

guard majorType == .additonal else {

throw CBOR.DecodingError.typeMismatch(expected: [type], actual: try self.type(for: data))

}

let additionalInfo = CBOR.additionalInfo(for: data[data.startIndex])

let result: (value: CBOR.SimpleValue, decodedBytes: Int)

switch additionalInfo {

case 24:

guard data.count > 1 else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

result = (CBOR.SimpleValue(rawValue: data[data.index(after: data.startIndex)]), 2)

default:

throw CBOR.DecodingError.typeMismatch(expected: [type], actual: try self.type(for: data))

}

return result

precondition(tag == .positiveBignum || tag == .negativeBignum)

guard !data.isEmpty else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

let bytes = try decode(Data.self, from: data)

return (CBOR.Bignum(isPositive: tag == .positiveBignum, content: bytes.value.decodedDataValue()), bytes.decodedBytes)

guard !data.isEmpty else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

let header = data[data.startIndex]

let majorType = CBOR.majorType(for: data[data.startIndex])

guard majorType == .additonal else {

throw CBOR.DecodingError.typeMismatch(expected: [type], actual: try self.type(for: data))

}

let result: (value: T, decodedBytes: Int)

if header == CBOR.Bits.half.rawValue { // Half

if data.count >= 3 {

// swiftlint:disable force_unwrapping

let half = data[data.index(data.startIndex, offsetBy: 1) ..< data.index(data.startIndex, offsetBy: 3)].reversed().withUnsafeBytes { $0.bindMemory(to: Half.self).baseAddress!.pointee }

// swiftlint:enable force_unwrapping

if half.isNaN {

if half.isSignalingNaN {

result = (.signalingNaN, 3)

} else {

result = (.nan, 3)

}

} else if half.isInfinite {

if half.sign == .minus {

result = (-.infinity, 3)

} else {

result = (.infinity, 3)

}

} else if let value = T(exactly: half) {

result = (value, 3)

} else {

throw CBOR.DecodingError.dataCorrupted(description: "Decoded number <\(half)> does not fit in \(type).")

}

} else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

} else if header == CBOR.Bits.float.rawValue { // Single

if data.count >= 5 {

// swiftlint:disable force_unwrapping

let float = data[data.index(data.startIndex, offsetBy: 1) ..< data.index(data.startIndex, offsetBy: 5)].reversed().withUnsafeBytes { $0.bindMemory(to: Float.self).baseAddress!.pointee }

// swiftlint:enable force_unwrapping

if float.isNaN {

if float.isSignalingNaN {

result = (.signalingNaN, 5)

} else {

result = (.nan, 5)

}

} else if float.isInfinite {

if float.sign == .minus {

result = (-.infinity, 5)

} else {

result = (.infinity, 5)

}

} else if let value = T(exactly: float) {

result = (value, 5)

} else {

throw CBOR.DecodingError.dataCorrupted(description: "Decoded number <\(float)> does not fit in \(type).")

}

} else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

} else if header == CBOR.Bits.double.rawValue { // Double

if data.count >= 9 {

// swiftlint:disable force_unwrapping

let double = data[data.index(data.startIndex, offsetBy: 1) ..< data.index(data.startIndex, offsetBy: 9)].reversed().withUnsafeBytes { $0.bindMemory(to: Double.self).baseAddress!.pointee }

// swiftlint:enable force_unwrapping

if double.isNaN {

if double.isSignalingNaN {

result = (.signalingNaN, 9)

} else {

result = (.nan, 9)

}

} else if double.isInfinite {

if double.sign == .minus {

result = (-.infinity, 9)

} else {

result = (.infinity, 9)

}

} else if let value = T(exactly: double) {

result = (value, 9)

} else {

throw CBOR.DecodingError.dataCorrupted(description: "Decoded number <\(double)> does not fit in \(type).")

}

} else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

} else {

throw CBOR.DecodingError.typeMismatch(expected: [type], actual: try self.type(for: data))

}

return result

guard !data.isEmpty else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

let majorType = CBOR.majorType(for: data[data.startIndex])

guard majorType == knownMajorType else {

throw CBOR.DecodingError.typeMismatch(expected: [type], actual: try self.type(for: data))

}

let additionalInfo = CBOR.additionalInfo(for: data[data.startIndex])

let result: (value: T?, decodedBytes: Int)

if additionalInfo <= 23 {

result = (T(exactly: additionalInfo), 1)

} else if additionalInfo == 24 {

if data.count >= 2 {

result = (T(exactly: data[data.index(data.startIndex, offsetBy: 1)]), 2)

} else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

} else if additionalInfo == 25 {

if data.count >= 3 {

result = (T(exactly: UInt16(data[data.index(data.startIndex, offsetBy: 1)]) << 8 |

UInt16(data[data.index(data.startIndex, offsetBy: 2)])), 3)

} else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

} else if additionalInfo == 26 {

if data.count >= 5 {

let upper = UInt32(data[data.index(data.startIndex, offsetBy: 1)]) << 24 |

UInt32(data[data.index(data.startIndex, offsetBy: 2)]) << 16

let lower = UInt32(data[data.index(data.startIndex, offsetBy: 3)]) << 8 |

UInt32(data[data.index(data.startIndex, offsetBy: 4)])

result = (T(exactly: upper | lower), 5)

} else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

} else if additionalInfo == 27 {

if data.count >= 9 {

let upper: UInt64, lower: UInt64

do {

let upper1 = UInt64(data[data.index(data.startIndex, offsetBy: 1)]) << 56 |

UInt64(data[data.index(data.startIndex, offsetBy: 2)]) << 48

let upper2 = UInt64(data[data.index(data.startIndex, offsetBy: 3)]) << 40 |

UInt64(data[data.index(data.startIndex, offsetBy: 4)]) << 32

upper = upper1 | upper2

}

do {

let lower1 = UInt64(data[data.index(data.startIndex, offsetBy: 5)]) << 24 |

UInt64(data[data.index(data.startIndex, offsetBy: 6)]) << 16

let lower2 = UInt64(data[data.index(data.startIndex, offsetBy: 7)]) << 8 |

UInt64(data[data.index(data.startIndex, offsetBy: 8)])

lower = lower1 | lower2

}

result = (T(exactly: upper | lower), 9)

} else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

} else {

throw CBOR.DecodingError.insufficientEncodedBytes(expected: type)

}

guard let value = result.value else {

throw CBOR.DecodingError.dataCorrupted(description: "Decoded number does not fit in \(type).")

}

return (value, result.decodedBytes)