             }
         }
 
-        @inlinable mutating func parseEscapeSequence() throws -> (String, Int) {
+        mutating func parseEscapeSequence() throws -> (String, Int) {
             guard let (byte, index) = read() else {
                 throw JSONError.unexpectedEndOfFile
             }

    }
}

// MARK: - Protocol conformances -

// MARK: Equatable

extension JSONValue: Equatable {
    @usableFromInline
    static func == (lhs: JSONValue, rhs: JSONValue) -> Bool {
        switch (lhs, rhs) {
        case (.null, .null):
            return true
        case (.bool(let lhs), .bool(let rhs)):
            return lhs == rhs
        case (.number(let lhs), .number(let rhs)):
            return lhs == rhs
        case (.string(let lhs), .string(let rhs)):
            return lhs == rhs
        case (.array(let lhs), .array(let rhs)):
            guard lhs.count == rhs.count else {
                return false
            }

            var lhsiterator = lhs.makeIterator()
            var rhsiterator = rhs.makeIterator()

            while let lhs = lhsiterator.next(), let rhs = rhsiterator.next() {
                if lhs == rhs {
                    continue
                }
                return false
            }

            return true
        case (.object(let lhs), .object(let rhs)):
            guard lhs.count == rhs.count else {
                return false
            }

            var lhsiterator = lhs.makeIterator()

            while let (lhskey, lhsvalue) = lhsiterator.next() {
                guard let rhsvalue = rhs[lhskey] else {
                    return false
                }

                if lhsvalue == rhsvalue {
                    continue
                }
                return false
            }

            return true
        default:
            return false
        }
    }
}

extension JSONValue {
    func toObjcRepresentation(options: JSONSerialization.ReadingOptions) throws -> Any {
        switch self {
        case .array(let values):

        // can be removed as soon https://bugs.swift.org/browse/SR-12126 and
        // https://bugs.swift.org/browse/SR-12125 has landed.
        // Thanks @weissi for making my code fast!
        func makeStringFast<Bytes: Collection>(_ bytes: Bytes) -> String where Bytes.Element == UInt8 {
            if let string = bytes.withContiguousStorageIfAvailable({ String(decoding: $0, as: Unicode.UTF8.self) }) {
                return string
            } else {
