Adopted Span and MutableSpan for buffers across the library to adapt to Swift 6.4.

Sources/PlaydateKit/Graphics/Classes/Bitmap.swift

@@ -39,14 +39,42 @@ extension Graphics {
 
         // MARK: Properties
 
-        /// The bitmap's dimensions, row stride, and raw storage.
+        /// The bitmap's dimensions and row stride.
         public var data: Data {
+            let raw = rawData()
+            return Data(width: raw.width, height: raw.height, rowBytes: raw.rowBytes,
+                        hasMask: raw.mask != nil)
+        }
+
+        /// Calls `body` with the bitmap's pixel data: one bit per pixel,
+        /// `height` rows of `rowBytes` bytes each.
+        public func withPixelData<Result, Failure: Error>(
+            _ body: (inout MutableSpan<UInt8>) throws(Failure) -> Result
+        ) throws(Failure) -> Result {
+            let raw = rawData()
+            var span = UnsafeMutableBufferPointer(
+                start: raw.data, count: raw.data == nil ? 0 : raw.height * raw.rowBytes).mutableSpan
+            return try body(&span)
+        }
+
+        /// Calls `body` with the bitmap's mask data, laid out like the pixel
+        /// data. Returns `nil` if the bitmap has no mask.
+        public func withMaskData<Result, Failure: Error>(
+            _ body: (inout MutableSpan<UInt8>) throws(Failure) -> Result
+        ) throws(Failure) -> Result? {
+            let raw = rawData()
+            guard let mask = raw.mask else { return nil }
+            var span = UnsafeMutableBufferPointer(start: mask, count: raw.height * raw.rowBytes).mutableSpan
+            return try body(&span)
+        }
+
+        private func rawData() -> (width: Int, height: Int, rowBytes: Int,
+                                   mask: UnsafeMutablePointer<UInt8>?, data: UnsafeMutablePointer<UInt8>?) {
             var width: Int32 = 0, height: Int32 = 0, rowBytes: Int32 = 0
             var mask: UnsafeMutablePointer<UInt8>?
             var data: UnsafeMutablePointer<UInt8>?
             gfx.pointee.getBitmapData.unsafelyUnwrapped(pointer, &width, &height, &rowBytes, &mask, &data)
-            return Data(width: Int(width), height: Int(height), rowBytes: Int(rowBytes),
-                        mask: mask, data: data)
+            return (Int(width), Int(height), Int(rowBytes), mask, data)
         }
 
         /// Cached dimensions, so `width`/`height` don't pay a full
@@ -56,8 +84,8 @@ extension Graphics {
 
         private var size: (width: Int, height: Int) {
             if let cachedSize { return cachedSize }
-            let data = self.data
-            let size = (data.width, data.height)
+            let raw = rawData()
+            let size = (raw.width, raw.height)
             cachedSize = size
             return size
         }

Sources/PlaydateKit/Graphics/Classes/Font.swift

@@ -23,9 +23,11 @@ extension Graphics {
 
         /// Creates a font from the contents of a .pft file already in memory.
         /// The bytes are copied and retained for the font's lifetime.
-        public convenience init?(data: UnsafeRawBufferPointer, wide: Bool = false) {
+        public convenience init?(data: Span<UInt8>, wide: Bool = false) {
             let copy = UnsafeMutableRawPointer.allocate(byteCount: data.count, alignment: 4)
-            copy.copyMemory(from: data.baseAddress.unsafelyUnwrapped, byteCount: data.count)
+            data.withUnsafeBytes { bytes in
+                copy.copyMemory(from: bytes.baseAddress.unsafelyUnwrapped, byteCount: bytes.count)
+            }
             let fontData = OpaquePointer(copy)
             guard let pointer = gfx.pointee.makeFontFromData.unsafelyUnwrapped(
                 fontData, wide ? 1 : 0, Int32(data.count)) else {