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
         }