bulk code format fix (#8707)

2026-06-15 08:48:52 +00:00 · 2025-09-23 21:50:27 -07:00
parent 0e047869da
commit caf3b494db
559 changed files with 38871 additions and 31276 deletions
--- a/swift/Sources/Common/Int+extension.swift
+++ b/swift/Sources/Common/Int+extension.swift
@@ -28,9 +28,9 @@ extension Int {
    var n = UInt32(self)

    #if arch(arm) || arch(i386)
-    let max = UInt32(Int.max)
+      let max = UInt32(Int.max)
    #else
-    let max = UInt32.max
+      let max = UInt32.max
    #endif

    n -= 1
--- a/swift/Sources/Common/Scalar.swift
+++ b/swift/Sources/Common/Scalar.swift
@@ -18,7 +18,7 @@ import Foundation

 /// A boolean to see if the system is littleEndian
 public let isLitteEndian: Bool = {
-  let number: UInt32 = 0x12345678
+  let number: UInt32 = 0x1234_5678
  return number == number.littleEndian
 }()

--- a/swift/Sources/Common/padding.swift
+++ b/swift/Sources/Common/padding.swift
@@ -23,7 +23,7 @@ import Foundation
@inline(__always)
 public func padding(
  bufSize: UInt,
-  elementSize: UInt) -> UInt
-{
+  elementSize: UInt
+) -> UInt {
  ((~bufSize) &+ 1) & (elementSize &- 1)
 }
--- a/swift/Sources/FlatBuffers/ByteBuffer.swift
+++ b/swift/Sources/FlatBuffers/ByteBuffer.swift
@@ -29,8 +29,8 @@ public struct ByteBuffer {
    @usableFromInline
    enum Blob {
      #if !os(WASI)
-      case data(Data)
-      case bytes(ContiguousBytes)
+        case data(Data)
+        case bytes(ContiguousBytes)
      #endif

      case byteBuffer(_InternalByteBuffer)
@@ -96,16 +96,16 @@ public struct ByteBuffer {
    @inline(__always)
    func withUnsafeBytes<T>(
      _ body: (UnsafeRawBufferPointer) throws
-        -> T) rethrows -> T
-    {
+        -> T
+    ) rethrows -> T {
      switch retainedBlob {
      case .byteBuffer(let byteBuffer):
        return try byteBuffer.withUnsafeBytes(body)
      #if !os(WASI)
-      case .data(let data):
-        return try data.withUnsafeBytes(body)
-      case .bytes(let contiguousBytes):
-        return try contiguousBytes.withUnsafeBytes(body)
+        case .data(let data):
+          return try data.withUnsafeBytes(body)
+        case .bytes(let contiguousBytes):
+          return try contiguousBytes.withUnsafeBytes(body)
      #endif
      case .array(let array):
        return try array.withUnsafeBytes(body)
@@ -118,25 +118,28 @@ public struct ByteBuffer {
    @inline(__always)
    func withUnsafeRawPointer<T>(
      _ body: (UnsafeMutableRawPointer) throws
-        -> T) rethrows -> T
-    {
+        -> T
+    ) rethrows -> T {
      switch retainedBlob {
      case .byteBuffer(let byteBuffer):
        return try byteBuffer.withUnsafeRawPointer(body)
      #if !os(WASI)
-      case .data(let data):
-        return try data
-          .withUnsafeBytes {
-            try body(UnsafeMutableRawPointer(mutating: $0.baseAddress!))
-          }
-      case .bytes(let contiguousBytes):
-        return try contiguousBytes
-          .withUnsafeBytes {
-            try body(UnsafeMutableRawPointer(mutating: $0.baseAddress!))
-          }
+        case .data(let data):
+          return
+            try data
+            .withUnsafeBytes {
+              try body(UnsafeMutableRawPointer(mutating: $0.baseAddress!))
+            }
+        case .bytes(let contiguousBytes):
+          return
+            try contiguousBytes
+            .withUnsafeBytes {
+              try body(UnsafeMutableRawPointer(mutating: $0.baseAddress!))
+            }
      #endif
      case .array(let array):
-        return try array
+        return
+          try array
          .withUnsafeBytes {
            try body(UnsafeMutableRawPointer(mutating: $0.baseAddress!))
          }
@@ -149,20 +152,20 @@ public struct ByteBuffer {
    @inline(__always)
    func readWithUnsafeRawPointer<T>(
      position: Int,
-      _ body: (UnsafeRawPointer) throws -> T) rethrows -> T
-    {
+      _ body: (UnsafeRawPointer) throws -> T
+    ) rethrows -> T {
      switch retainedBlob {
      case .byteBuffer(let byteBuffer):
        return try byteBuffer.readWithUnsafeRawPointer(position: position, body)
      #if !os(WASI)
-      case .data(let data):
-        return try data.withUnsafeBytes {
-          try body($0.baseAddress!.advanced(by: position))
-        }
-      case .bytes(let contiguousBytes):
-        return try contiguousBytes.withUnsafeBytes {
-          try body($0.baseAddress!.advanced(by: position))
-        }
+        case .data(let data):
+          return try data.withUnsafeBytes {
+            try body($0.baseAddress!.advanced(by: position))
+          }
+        case .bytes(let contiguousBytes):
+          return try contiguousBytes.withUnsafeBytes {
+            try body($0.baseAddress!.advanced(by: position))
+          }
      #endif
      case .array(let array):
        return try array.withUnsafeBytes {
@@ -206,8 +209,8 @@ public struct ByteBuffer {
  @inline(__always)
  public init(
    copyingMemoryBound memory: UnsafeRawPointer,
-    capacity: Int)
-  {
+    capacity: Int
+  ) {
    _storage = Storage(count: capacity)
    _storage.copy(from: memory, count: capacity)
    _readerIndex = capacity
@@ -225,29 +228,29 @@ public struct ByteBuffer {
  }

  #if !os(WASI)
-  /// Constructor that creates a Flatbuffer from the Swift Data type object
-  /// - Parameter
-  ///   - data: Swift data Object
-  @inline(__always)
-  public init(data: Data) {
-    _storage = Storage(blob: .data(data), capacity: data.count)
-    _readerIndex = data.count
-    capacity = data.count
-  }
+    /// Constructor that creates a Flatbuffer from the Swift Data type object
+    /// - Parameter
+    ///   - data: Swift data Object
+    @inline(__always)
+    public init(data: Data) {
+      _storage = Storage(blob: .data(data), capacity: data.count)
+      _readerIndex = data.count
+      capacity = data.count
+    }

-  /// Constructor that creates a Flatbuffer object from a ContiguousBytes
-  /// - Parameters:
-  ///   - contiguousBytes: Binary stripe to use as the buffer
-  ///   - count: amount of readable bytes
-  @inline(__always)
-  public init<Bytes: ContiguousBytes>(
-    contiguousBytes: Bytes,
-    count: Int)
-  {
-    _storage = Storage(blob: .bytes(contiguousBytes), capacity: count)
-    _readerIndex = count
-    self.capacity = count
-  }
+    /// Constructor that creates a Flatbuffer object from a ContiguousBytes
+    /// - Parameters:
+    ///   - contiguousBytes: Binary stripe to use as the buffer
+    ///   - count: amount of readable bytes
+    @inline(__always)
+    public init<Bytes: ContiguousBytes>(
+      contiguousBytes: Bytes,
+      count: Int
+    ) {
+      _storage = Storage(blob: .bytes(contiguousBytes), capacity: count)
+      _readerIndex = count
+      self.capacity = count
+    }
  #endif

  /// Constructor that creates a Flatbuffer from unsafe memory region without copying
@@ -259,8 +262,8 @@ public struct ByteBuffer {
  @inline(__always)
  public init(
    assumingMemoryBound memory: UnsafeMutableRawPointer,
-    capacity: Int)
-  {
+    capacity: Int
+  ) {
    _storage = Storage(
      blob: .pointer(memory),
      capacity: capacity)
@@ -277,8 +280,8 @@ public struct ByteBuffer {
  init(
    blob: Storage.Blob,
    count: Int,
-    removing removeBytes: Int)
-  {
+    removing removeBytes: Int
+  ) {
    _storage = Storage(blob: blob, capacity: count)
    _readerIndex = removeBytes
    capacity = count
@@ -329,8 +332,8 @@ public struct ByteBuffer {
  @inline(__always)
  public func readSlice<T>(
    index: Int,
-    count: Int) -> [T]
-  {
+    count: Int
+  ) -> [T] {
    assert(
      index + count <= capacity,
      "Reading out of bounds is illegal")
@@ -352,8 +355,8 @@ public struct ByteBuffer {
  public func withUnsafePointerToSlice<T>(
    index: Int,
    count: Int,
-    body: (UnsafeRawBufferPointer) throws -> T) rethrows -> T
-  {
+    body: (UnsafeRawBufferPointer) throws -> T
+  ) rethrows -> T {
    assert(
      index + count <= capacity,
      "Reading out of bounds is illegal")
@@ -363,46 +366,46 @@ public struct ByteBuffer {
  }

  #if !os(WASI)
-  /// Reads a string from the buffer and encodes it to a swift string
-  /// - Parameters:
-  ///   - index: index of the string in the buffer
-  ///   - count: length of the string
-  ///   - type: Encoding of the string
-  @inline(__always)
-  public func readString(
-    at index: Int,
-    count: Int,
-    type: String.Encoding = .utf8) -> String?
-  {
-    assert(
-      index + count <= capacity,
-      "Reading out of bounds is illegal")
-    return _storage.readWithUnsafeRawPointer(position: index) {
-      let buf = UnsafeBufferPointer(
-        start: $0.bindMemory(to: UInt8.self, capacity: count),
-        count: count)
-      return String(
-        bytes: buf,
-        encoding: type)
+    /// Reads a string from the buffer and encodes it to a swift string
+    /// - Parameters:
+    ///   - index: index of the string in the buffer
+    ///   - count: length of the string
+    ///   - type: Encoding of the string
+    @inline(__always)
+    public func readString(
+      at index: Int,
+      count: Int,
+      type: String.Encoding = .utf8
+    ) -> String? {
+      assert(
+        index + count <= capacity,
+        "Reading out of bounds is illegal")
+      return _storage.readWithUnsafeRawPointer(position: index) {
+        let buf = UnsafeBufferPointer(
+          start: $0.bindMemory(to: UInt8.self, capacity: count),
+          count: count)
+        return String(
+          bytes: buf,
+          encoding: type)
+      }
    }
-  }
  #else
-  /// Reads a string from the buffer and encodes it to a swift string
-  /// - Parameters:
-  ///   - index: index of the string in the buffer
-  ///   - count: length of the string
-  @inline(__always)
-  public func readString(
-    at index: Int,
-    count: Int) -> String?
-  {
-    assert(
-      index + count <= capacity,
-      "Reading out of bounds is illegal")
-    return _storage.readWithUnsafeRawPointer(position: index) {
-      String(cString: $0.bindMemory(to: UInt8.self, capacity: count))
+    /// Reads a string from the buffer and encodes it to a swift string
+    /// - Parameters:
+    ///   - index: index of the string in the buffer
+    ///   - count: length of the string
+    @inline(__always)
+    public func readString(
+      at index: Int,
+      count: Int
+    ) -> String? {
+      assert(
+        index + count <= capacity,
+        "Reading out of bounds is illegal")
+      return _storage.readWithUnsafeRawPointer(position: index) {
+        String(cString: $0.bindMemory(to: UInt8.self, capacity: count))
+      }
    }
-  }
  #endif

  /// Creates a new Flatbuffer object that's duplicated from the current one
@@ -434,8 +437,8 @@ public struct ByteBuffer {
  @inline(__always)
  public func withUnsafeBytes<T>(
    body: (UnsafeRawBufferPointer) throws
-      -> T) rethrows -> T
-  {
+      -> T
+  ) rethrows -> T {
    try _storage.withUnsafeBytes(body)
  }

@@ -443,8 +446,8 @@ public struct ByteBuffer {
  @inline(__always)
  func withUnsafeMutableRawPointer<T>(
    body: (UnsafeMutableRawPointer) throws
-      -> T) rethrows -> T
-  {
+      -> T
+  ) rethrows -> T {
    try _storage.withUnsafeRawPointer(body)
  }

@@ -452,8 +455,8 @@ public struct ByteBuffer {
  @inline(__always)
  func readWithUnsafeRawPointer<T>(
    position: Int,
-    _ body: (UnsafeRawPointer) throws -> T) rethrows -> T
-  {
+    _ body: (UnsafeRawPointer) throws -> T
+  ) rethrows -> T {
    try _storage.readWithUnsafeRawPointer(position: position, body)
  }
 }
--- a/swift/Sources/FlatBuffers/Constants.swift
+++ b/swift/Sources/FlatBuffers/Constants.swift
@@ -14,18 +14,20 @@
 * limitations under the License.
 */

-#if canImport(Common)
-import Common
-#endif
 import Foundation

+#if canImport(Common)
+  import Common
+#endif
+
 /// Type aliases
 public typealias Byte = UInt8
 public typealias UOffset = UInt32
 public typealias SOffset = Int32
 public typealias VOffset = UInt16
 /// Maximum size for a buffer
-public let FlatBufferMaxSize = UInt32
+public let FlatBufferMaxSize =
+  UInt32
  .max << ((MemoryLayout<SOffset>.size * 8 - 1) - 1)

 /// Protocol that All Scalars should conform to
--- a/swift/Sources/FlatBuffers/Documentation.docc/Resources/code/swift/swift_code_11.swift
+++ b/swift/Sources/FlatBuffers/Documentation.docc/Resources/code/swift/swift_code_11.swift
@@ -3,7 +3,7 @@ import Foundation

 func run() {
  // create a ByteBuffer(:) from an [UInt8] or Data()
-  let buf = [] // Get your data
+  let buf = []  // Get your data
  var byteBuffer = ByteBuffer(bytes: buf)
  // Get an accessor to the root object inside the buffer.
  let monster: Monster = try! getCheckedRoot(byteBuffer: &byteBuffer)
--- a/swift/Sources/FlatBuffers/Documentation.docc/Resources/code/swift/swift_code_12.swift
+++ b/swift/Sources/FlatBuffers/Documentation.docc/Resources/code/swift/swift_code_12.swift
@@ -3,7 +3,7 @@ import Foundation

 func run() {
  // create a ByteBuffer(:) from an [UInt8] or Data()
-  let buf = [] // Get your data
+  let buf = []  // Get your data
  var byteBuffer = ByteBuffer(bytes: buf)
  // Get an accessor to the root object inside the buffer.
  let monster: Monster = try! getCheckedRoot(byteBuffer: &byteBuffer)
@@ -11,7 +11,7 @@ func run() {

  let hp = monster.hp
  let mana = monster.mana
-  let name = monster.name // returns an optional string
+  let name = monster.name  // returns an optional string

  let pos = monster.pos
  let x = pos.x
--- a/swift/Sources/FlatBuffers/Documentation.docc/Resources/code/swift/swift_code_13.swift
+++ b/swift/Sources/FlatBuffers/Documentation.docc/Resources/code/swift/swift_code_13.swift
@@ -3,7 +3,7 @@ import Foundation

 func run() {
  // create a ByteBuffer(:) from an [UInt8] or Data()
-  let buf = [] // Get your data
+  let buf = []  // Get your data
  var byteBuffer = ByteBuffer(bytes: buf)
  // Get an accessor to the root object inside the buffer.
  let monster: Monster = try! getCheckedRoot(byteBuffer: &byteBuffer)
@@ -11,7 +11,7 @@ func run() {

  let hp = monster.hp
  let mana = monster.mana
-  let name = monster.name // returns an optional string
+  let name = monster.name  // returns an optional string

  let pos = monster.pos
  let x = pos.x
@@ -20,7 +20,7 @@ func run() {
  // Get and check if the monster has an equipped item
  if monster.equippedType == .weapon {
    let _weapon = monster.equipped(type: Weapon.self)
-    let name = _weapon.name // should return "Axe"
-    let dmg = _weapon.damage // should return 5
+    let name = _weapon.name  // should return "Axe"
+    let dmg = _weapon.damage  // should return 5
  }
 }
--- a/swift/Sources/FlatBuffers/Enum.swift
+++ b/swift/Sources/FlatBuffers/Enum.swift
@@ -14,12 +14,12 @@
 * limitations under the License.
 */

-#if canImport(Common)
-import Common
-#endif
-
 import Foundation

+#if canImport(Common)
+  import Common
+#endif
+
 /// Enum is a protocol that all flatbuffers enums should conform to
 /// Since it allows us to get the actual `ByteSize` and `Value` from
 /// a swift enum.
@@ -44,8 +44,8 @@ extension Enum where Self: Verifiable {
  public static func verify<T>(
    _ verifier: inout Verifier,
    at position: Int,
-    of type: T.Type) throws where T: Verifiable
-  {
+    of type: T.Type
+  ) throws where T: Verifiable {
    try verifier.inBuffer(position: position, of: type.self)
  }

--- a/swift/Sources/FlatBuffers/FlatBufferBuilder.swift
+++ b/swift/Sources/FlatBuffers/FlatBufferBuilder.swift
@@ -14,12 +14,12 @@
 * limitations under the License.
 */

-#if canImport(Common)
-import Common
-#endif
-
 import Foundation

+#if canImport(Common)
+  import Common
+#endif
+
 /// ``FlatBufferBuilder`` builds a `FlatBuffer` through manipulating its internal state.
 ///
 /// This is done by creating a ``ByteBuffer`` that hosts the incoming data and
@@ -63,21 +63,21 @@ public struct FlatBufferBuilder {
  public var capacity: Int { _bb.capacity }

  #if !os(WASI)
-  /// Data representation of the buffer
-  ///
-  /// Should only be used after ``finish(offset:addPrefix:)`` is called
-  public var data: Data {
-    assert(finished, "Data shouldn't be called before finish()")
-    return _bb.withUnsafeSlicedBytes { ptr in
-      var data = Data()
-      data.append(
-        ptr.baseAddress!.bindMemory(
-          to: UInt8.self,
-          capacity: ptr.count),
-        count: ptr.count)
-      return data
+    /// Data representation of the buffer
+    ///
+    /// Should only be used after ``finish(offset:addPrefix:)`` is called
+    public var data: Data {
+      assert(finished, "Data shouldn't be called before finish()")
+      return _bb.withUnsafeSlicedBytes { ptr in
+        var data = Data()
+        data.append(
+          ptr.baseAddress!.bindMemory(
+            to: UInt8.self,
+            capacity: ptr.count),
+          count: ptr.count)
+        return data
+      }
    }
-  }
  #endif

  /// Returns the underlying bytes in the ``ByteBuffer``
@@ -132,8 +132,8 @@ public struct FlatBufferBuilder {
  /// however the builder can be force by passing true for `serializeDefaults`
  public init(
    initialSize: Int32 = 1024,
-    serializeDefaults force: Bool = false)
-  {
+    serializeDefaults force: Bool = false
+  ) {
    assert(initialSize > 0, "Size should be greater than zero!")
    guard isLitteEndian else {
      fatalError(
@@ -200,8 +200,8 @@ public struct FlatBufferBuilder {
  mutating public func finish(
    offset: Offset,
    fileId: String,
-    addPrefix prefix: Bool = false)
-  {
+    addPrefix prefix: Bool = false
+  ) {
    let size = MemoryLayout<UOffset>.size
    preAlign(
      len: size &+ (prefix ? size : 0) &+ FileIdLength,
@@ -230,8 +230,8 @@ public struct FlatBufferBuilder {
  /// include the size of the current buffer.
  mutating public func finish(
    offset: Offset,
-    addPrefix prefix: Bool = false)
-  {
+    addPrefix prefix: Bool = false
+  ) {
    notNested()
    let size = MemoryLayout<UOffset>.size
    preAlign(len: size &+ (prefix ? size : 0), alignment: _minAlignment)
@@ -355,9 +355,11 @@ public struct FlatBufferBuilder {
  @usableFromInline
  mutating internal func preAlign(len: Int, alignment: Int) {
    minAlignment(size: alignment)
-    _bb.fill(padding: numericCast(padding(
-      bufSize: numericCast(_bb.size) &+ numericCast(len),
-      elementSize: numericCast(alignment))))
+    _bb.fill(
+      padding: numericCast(
+        padding(
+          bufSize: numericCast(_bb.size) &+ numericCast(len),
+          elementSize: numericCast(alignment))))
  }

  /// Prealigns the buffer before writting a new object into the buffer
@@ -468,8 +470,8 @@ public struct FlatBufferBuilder {
  @inline(__always)
  mutating public func createVector<T: Scalar>(
    _ elements: [T],
-    size: Int) -> Offset
-  {
+    size: Int
+  ) -> Offset {
    let size = size
    startVector(size, elementSize: MemoryLayout<T>.size)
    _bb.push(elements: elements)
@@ -477,20 +479,20 @@ public struct FlatBufferBuilder {
  }

  #if swift(>=5.0) && !os(WASI)
-  @inline(__always)
-  /// Creates a vector of bytes in the buffer.
-  ///
-  /// Allows creating a vector from `Data` without copying to a `[UInt8]`
-  ///
-  /// - Parameter bytes: bytes to be written into the buffer
-  /// - Returns: ``Offset`` of the vector
-  mutating public func createVector(bytes: ContiguousBytes) -> Offset {
-    bytes.withUnsafeBytes {
-      startVector($0.count, elementSize: MemoryLayout<UInt8>.size)
-      _bb.push(bytes: $0)
-      return endVector(len: $0.count)
+    @inline(__always)
+    /// Creates a vector of bytes in the buffer.
+    ///
+    /// Allows creating a vector from `Data` without copying to a `[UInt8]`
+    ///
+    /// - Parameter bytes: bytes to be written into the buffer
+    /// - Returns: ``Offset`` of the vector
+    mutating public func createVector(bytes: ContiguousBytes) -> Offset {
+      bytes.withUnsafeBytes {
+        startVector($0.count, elementSize: MemoryLayout<UInt8>.size)
+        _bb.push(bytes: $0)
+        return endVector(len: $0.count)
+      }
    }
-  }
  #endif

  /// Creates a vector of type ``Enum`` into the ``ByteBuffer``
@@ -528,8 +530,8 @@ public struct FlatBufferBuilder {
  @inline(__always)
  mutating public func createVector<T: Enum>(
    _ elements: [T],
-    size: Int) -> Offset
-  {
+    size: Int
+  ) -> Offset {
    let size = size
    startVector(size, elementSize: T.byteSize)
    for index in stride(from: elements.count, to: 0, by: -1) {
@@ -574,8 +576,8 @@ public struct FlatBufferBuilder {
  @inline(__always)
  mutating public func createVector(
    ofOffsets offsets: [Offset],
-    len: Int) -> Offset
-  {
+    len: Int
+  ) -> Offset {
    startVector(len, elementSize: MemoryLayout<Offset>.size)
    for index in stride(from: offsets.count, to: 0, by: -1) {
      push(element: offsets[index &- 1])
@@ -651,8 +653,8 @@ public struct FlatBufferBuilder {
  @inline(__always)
  @discardableResult
  mutating public func create<T: NativeStruct>(
-    struct s: T, position: VOffset) -> Offset
-  {
+    struct s: T, position: VOffset
+  ) -> Offset {
    let offset = create(struct: s)
    _vtableStorage.add(
      loc: (offset: _bb.size, position: VOffset(position)))
@@ -676,8 +678,8 @@ public struct FlatBufferBuilder {
  @inline(__always)
  @discardableResult
  mutating public func create<T: NativeStruct>(
-    struct s: T) -> Offset
-  {
+    struct s: T
+  ) -> Offset {
    let size = MemoryLayout<T>.size
    preAlign(len: size, alignment: MemoryLayout<T>.alignment)
    _bb.push(struct: s, size: size)
@@ -792,8 +794,8 @@ public struct FlatBufferBuilder {
  mutating public func add<T: Scalar>(
    element: T,
    def: T,
-    at position: VOffset)
-  {
+    at position: VOffset
+  ) {
    if element == def && !serializeDefaults { return }
    track(offset: push(element: element), at: position)
  }
--- a/swift/Sources/FlatBuffers/FlatbuffersErrors.swift
+++ b/swift/Sources/FlatBuffers/FlatbuffersErrors.swift
@@ -63,13 +63,13 @@ public enum FlatbuffersErrors: Error, Equatable {

 #if !os(WASI)

-extension FlatbuffersErrors {
-  public static func == (
-    lhs: FlatbuffersErrors,
-    rhs: FlatbuffersErrors) -> Bool
-  {
-    lhs.localizedDescription == rhs.localizedDescription
+  extension FlatbuffersErrors {
+    public static func == (
+      lhs: FlatbuffersErrors,
+      rhs: FlatbuffersErrors
+    ) -> Bool {
+      lhs.localizedDescription == rhs.localizedDescription
+    }
  }
-}

 #endif
--- a/swift/Sources/FlatBuffers/Message.swift
+++ b/swift/Sources/FlatBuffers/Message.swift
@@ -28,7 +28,8 @@ public protocol FlatBufferGRPCMessage {
  @inline(__always)
  func withUnsafeReadableBytes<T>(
    _ body: (UnsafeRawBufferPointer) throws
-      -> T) rethrows -> T
+      -> T
+  ) rethrows -> T
 }

 /// Message is a wrapper around Buffers to to able to send Flatbuffers `Buffers` through the
@@ -40,8 +41,7 @@ public struct Message<T: FlatBufferObject>: FlatBufferGRPCMessage {
  public var object: T {
    T.init(
      buffer,
-      o: Int32(buffer.read(def: UOffset.self, position: buffer.reader)) &+
-        Int32(buffer.reader))
+      o: Int32(buffer.read(def: UOffset.self, position: buffer.reader)) &+ Int32(buffer.reader))
  }

  public var size: Int { Int(buffer.size) }
@@ -66,8 +66,8 @@ public struct Message<T: FlatBufferObject>: FlatBufferGRPCMessage {
  @inline(__always)
  public func withUnsafeReadableBytes<Data>(
    _ body: (UnsafeRawBufferPointer) throws
-      -> Data) rethrows -> Data
-  {
+      -> Data
+  ) rethrows -> Data {
    return try buffer.readWithUnsafeRawPointer(position: buffer.reader) {
      try body(UnsafeRawBufferPointer(start: $0, count: size))
    }
--- a/swift/Sources/FlatBuffers/Mutable.swift
+++ b/swift/Sources/FlatBuffers/Mutable.swift
@@ -14,12 +14,12 @@
 * limitations under the License.
 */

-#if canImport(Common)
-import Common
-#endif
-
 import Foundation

+#if canImport(Common)
+  import Common
+#endif
+
 /// Mutable is a protocol that allows us to mutate Scalar values within a ``ByteBuffer``
 public protocol Mutable {
  /// makes Flatbuffer accessed within the Protocol
--- a/swift/Sources/FlatBuffers/NativeObject.swift
+++ b/swift/Sources/FlatBuffers/NativeObject.swift
@@ -27,8 +27,7 @@ extension NativeObject {
  /// - Parameter type: Type of the Flatbuffer object
  /// - Returns: returns the encoded sized ByteBuffer
  public func serialize<T: ObjectAPIPacker>(type: T.Type) -> ByteBuffer
-    where T.T == Self
-  {
+  where T.T == Self {
    var builder = FlatBufferBuilder(initialSize: 1024)
    return serialize(builder: &builder, type: type.self)
  }
@@ -43,8 +42,8 @@ extension NativeObject {
  ///  It can be considered less expensive in terms of memory allocation
  public func serialize<T: ObjectAPIPacker>(
    builder: inout FlatBufferBuilder,
-    type: T.Type) -> ByteBuffer where T.T == Self
-  {
+    type: T.Type
+  ) -> ByteBuffer where T.T == Self {
    var s = self
    let root = type.pack(&builder, obj: &s)
    builder.finish(offset: root)
--- a/swift/Sources/FlatBuffers/Root.swift
+++ b/swift/Sources/FlatBuffers/Root.swift
@@ -29,8 +29,8 @@ import Foundation
 public func getPrefixedSizeCheckedRoot<T: FlatBufferObject & Verifiable>(
  byteBuffer: inout ByteBuffer,
  fileId: String? = nil,
-  options: VerifierOptions = .init()) throws -> T
-{
+  options: VerifierOptions = .init()
+) throws -> T {
  byteBuffer.skipPrefix()
  return try getCheckedRoot(
    byteBuffer: &byteBuffer,
@@ -51,8 +51,8 @@ public func getPrefixedSizeCheckedRoot<T: FlatBufferObject & Verifiable>(
 public func getCheckedPrefixedSizeRoot<T: FlatBufferObject & Verifiable>(
  byteBuffer: inout ByteBuffer,
  fileId: String? = nil,
-  options: VerifierOptions = .init()) throws -> T
-{
+  options: VerifierOptions = .init()
+) throws -> T {
  let prefix = byteBuffer.skipPrefix()
  if prefix != byteBuffer.size {
    throw FlatbuffersErrors.prefixedSizeNotEqualToBufferSize
@@ -71,7 +71,8 @@ public func getCheckedPrefixedSizeRoot<T: FlatBufferObject & Verifiable>(
 /// ``getPrefixedSizeCheckedRoot(byteBuffer:options:)`` would skip the first Bytes in
 /// the ``ByteBuffer`` and then calls ``getRoot(byteBuffer:)``
 public func getPrefixedSizeRoot<T: FlatBufferObject>(
-  byteBuffer: inout ByteBuffer)
+  byteBuffer: inout ByteBuffer
+)
  -> T
 {
  byteBuffer.skipPrefix()
@@ -92,8 +93,8 @@ public func getPrefixedSizeRoot<T: FlatBufferObject>(
 public func getCheckedRoot<T: FlatBufferObject & Verifiable>(
  byteBuffer: inout ByteBuffer,
  fileId: String? = nil,
-  options: VerifierOptions = .init()) throws -> T
-{
+  options: VerifierOptions = .init()
+) throws -> T {
  var verifier = try Verifier(buffer: &byteBuffer, options: options)
  if let fileId = fileId {
    try verifier.verify(id: fileId)
@@ -101,8 +102,8 @@ public func getCheckedRoot<T: FlatBufferObject & Verifiable>(
  try ForwardOffset<T>.verify(&verifier, at: 0, of: T.self)
  return T.init(
    byteBuffer,
-    o: Int32(byteBuffer.read(def: UOffset.self, position: byteBuffer.reader)) &+
-      Int32(byteBuffer.reader))
+    o: Int32(byteBuffer.read(def: UOffset.self, position: byteBuffer.reader))
+      &+ Int32(byteBuffer.reader))
 }

 /// Returns a `NON-Checked` flatbuffers object
@@ -111,6 +112,6 @@ public func getCheckedRoot<T: FlatBufferObject & Verifiable>(
 public func getRoot<T: FlatBufferObject>(byteBuffer: inout ByteBuffer) -> T {
  T.init(
    byteBuffer,
-    o: Int32(byteBuffer.read(def: UOffset.self, position: byteBuffer.reader)) &+
-      Int32(byteBuffer.reader))
+    o: Int32(byteBuffer.read(def: UOffset.self, position: byteBuffer.reader))
+      &+ Int32(byteBuffer.reader))
 }
--- a/swift/Sources/FlatBuffers/String+extension.swift
+++ b/swift/Sources/FlatBuffers/String+extension.swift
@@ -28,8 +28,8 @@ extension String: Verifiable {
  public static func verify<T>(
    _ verifier: inout Verifier,
    at position: Int,
-    of type: T.Type) throws where T: Verifiable
-  {
+    of type: T.Type
+  ) throws where T: Verifiable {

    let range = try String.verifyRange(&verifier, at: position, of: UInt8.self)
    /// Safe &+ since we already check for overflow in verify range
@@ -41,9 +41,10 @@ extension String: Verifiable {
        end: verifier.capacity)
    }

-    let isNullTerminated = verifier._buffer.read(
-      def: UInt8.self,
-      position: stringLen) == 0
+    let isNullTerminated =
+      verifier._buffer.read(
+        def: UInt8.self,
+        position: stringLen) == 0

    if !verifier._options._ignoreMissingNullTerminators && !isNullTerminated {
      let str = verifier._buffer.readString(at: range.start, count: range.count)
@@ -63,9 +64,10 @@ extension String: FlatbuffersInitializable {
  public init(_ bb: ByteBuffer, o: Int32) {
    let v = Int(o)
    let count = bb.read(def: Int32.self, position: v)
-    self = bb.readString(
-      at: MemoryLayout<Int32>.size &+ v,
-      count: Int(count)) ?? ""
+    self =
+      bb.readString(
+        at: MemoryLayout<Int32>.size &+ v,
+        count: Int(count)) ?? ""
  }
 }

@@ -73,16 +75,16 @@ extension String: ObjectAPIPacker {

  public static func pack(
    _ builder: inout FlatBufferBuilder,
-    obj: inout String?) -> Offset
-  {
+    obj: inout String?
+  ) -> Offset {
    guard var obj = obj else { return Offset() }
    return pack(&builder, obj: &obj)
  }

  public static func pack(
    _ builder: inout FlatBufferBuilder,
-    obj: inout String) -> Offset
-  {
+    obj: inout String
+  ) -> Offset {
    builder.create(string: obj)
  }

@@ -95,15 +97,14 @@ extension String: ObjectAPIPacker {
 extension String: NativeObject {

  public func serialize<T: ObjectAPIPacker>(type: T.Type) -> ByteBuffer
-    where T.T == Self
-  {
+  where T.T == Self {
    fatalError("serialize should never be called from string directly")
  }

  public func serialize<T: ObjectAPIPacker>(
    builder: inout FlatBufferBuilder,
-    type: T.Type) -> ByteBuffer where T.T == Self
-  {
+    type: T.Type
+  ) -> ByteBuffer where T.T == Self {
    fatalError("serialize should never be called from string directly")
  }
 }
--- a/swift/Sources/FlatBuffers/Struct.swift
+++ b/swift/Sources/FlatBuffers/Struct.swift
@@ -14,12 +14,12 @@
 * limitations under the License.
 */

-#if canImport(Common)
-import Common
-#endif
-
 import Foundation

+#if canImport(Common)
+  import Common
+#endif
+
 /// Struct is a representation of a mutable `Flatbuffers` struct
 /// since native structs are value types and cant be mutated
@frozen
--- a/swift/Sources/FlatBuffers/Table.swift
+++ b/swift/Sources/FlatBuffers/Table.swift
@@ -14,12 +14,12 @@
 * limitations under the License.
 */

-#if canImport(Common)
-import Common
-#endif
-
 import Foundation

+#if canImport(Common)
+  import Common
+#endif
+
 /// `Table` is a Flatbuffers object that can read,
 /// mutate scalar fields within a valid flatbuffers buffer
@frozen
@@ -51,10 +51,13 @@ public struct Table {
  /// - Returns: offset of field within buffer
  public func offset(_ o: Int32) -> Int32 {
    let vtable = position &- bb.read(def: Int32.self, position: Int(position))
-    return o < bb
-      .read(def: VOffset.self, position: Int(vtable)) ? Int32(bb.read(
-        def: Int16.self,
-        position: Int(vtable &+ o))) : 0
+    return o
+      < bb
+      .read(def: VOffset.self, position: Int(vtable))
+      ? Int32(
+        bb.read(
+          def: Int16.self,
+          position: Int(vtable &+ o))) : 0
  }

  /// Gets the indirect offset of the current stored object
@@ -141,8 +144,8 @@ public struct Table {
  @inline(__always)
  public func withUnsafePointerToSlice<T>(
    at off: Int32,
-    body: (UnsafeRawBufferPointer) throws -> T) rethrows -> T?
-  {
+    body: (UnsafeRawBufferPointer) throws -> T
+  ) rethrows -> T? {
    let o = offset(off)
    guard o != 0 else { return nil }
    return try bb.withUnsafePointerToSlice(
@@ -189,14 +192,18 @@ public struct Table {
  static public func offset(
    _ o: Int32,
    vOffset: Int32,
-    fbb: inout FlatBufferBuilder) -> Int32
-  {
+    fbb: inout FlatBufferBuilder
+  ) -> Int32 {
    let vTable = Int32(fbb.capacity) &- o
-    return vTable &+ Int32(fbb.read(
-      def: Int16.self,
-      position: Int(vTable &+ vOffset &- fbb.read(
-        def: Int32.self,
-        position: Int(vTable)))))
+    return vTable
+      &+ Int32(
+        fbb.read(
+          def: Int16.self,
+          position: Int(
+            vTable &+ vOffset
+              &- fbb.read(
+                def: Int32.self,
+                position: Int(vTable)))))
  }

  /// Compares two objects at offset A and offset B within a ByteBuffer
@@ -209,8 +216,8 @@ public struct Table {
  static public func compare(
    _ off1: Int32,
    _ off2: Int32,
-    fbb: inout FlatBufferBuilder) -> Int32
-  {
+    fbb: inout FlatBufferBuilder
+  ) -> Int32 {
    let memorySize = Int32(MemoryLayout<Int32>.size)
    let _off1 = off1 &+ fbb.read(def: Int32.self, position: Int(off1))
    let _off2 = off2 &+ fbb.read(def: Int32.self, position: Int(off2))
@@ -239,8 +246,8 @@ public struct Table {
  static public func compare(
    _ off1: Int32,
    _ key: [Byte],
-    fbb: inout FlatBufferBuilder) -> Int32
-  {
+    fbb: inout FlatBufferBuilder
+  ) -> Int32 {
    let memorySize = Int32(MemoryLayout<Int32>.size)
    let _off1 = off1 &+ fbb.read(def: Int32.self, position: Int(off1))
    let len1 = fbb.read(def: Int32.self, position: Int(_off1))
@@ -267,14 +274,18 @@ public struct Table {
  static public func offset(
    _ o: Int32,
    vOffset: Int32,
-    fbb: ByteBuffer) -> Int32
-  {
+    fbb: ByteBuffer
+  ) -> Int32 {
    let vTable = Int32(fbb.capacity) &- o
-    return vTable &+ Int32(fbb.read(
-      def: Int16.self,
-      position: Int(vTable &+ vOffset &- fbb.read(
-        def: Int32.self,
-        position: Int(vTable)))))
+    return vTable
+      &+ Int32(
+        fbb.read(
+          def: Int16.self,
+          position: Int(
+            vTable &+ vOffset
+              &- fbb.read(
+                def: Int32.self,
+                position: Int(vTable)))))
  }

  /// Compares two objects at offset A and offset B within a ByteBuffer
@@ -287,8 +298,8 @@ public struct Table {
  static public func compare(
    _ off1: Int32,
    _ off2: Int32,
-    fbb: ByteBuffer) -> Int32
-  {
+    fbb: ByteBuffer
+  ) -> Int32 {
    let memorySize = Int32(MemoryLayout<Int32>.size)
    let _off1 = off1 &+ fbb.read(def: Int32.self, position: Int(off1))
    let _off2 = off2 &+ fbb.read(def: Int32.self, position: Int(off2))
@@ -317,8 +328,8 @@ public struct Table {
  static public func compare(
    _ off1: Int32,
    _ key: [Byte],
-    fbb: ByteBuffer) -> Int32
-  {
+    fbb: ByteBuffer
+  ) -> Int32 {
    let memorySize = Int32(MemoryLayout<Int32>.size)
    let _off1 = off1 &+ fbb.read(def: Int32.self, position: Int(off1))
    let len1 = fbb.read(def: Int32.self, position: Int(_off1))
--- a/swift/Sources/FlatBuffers/TableVerifier.swift
+++ b/swift/Sources/FlatBuffers/TableVerifier.swift
@@ -45,8 +45,8 @@ public struct TableVerifier {
    position: Int,
    vtable: Int,
    vtableLength: Int,
-    verifier: inout Verifier)
-  {
+    verifier: inout Verifier
+  ) {
    _position = position
    _vtable = vtable
    _vtableLength = vtableLength
@@ -84,8 +84,8 @@ public struct TableVerifier {
    field: VOffset,
    fieldName: String,
    required: Bool,
-    type: T.Type) throws where T: Verifiable
-  {
+    type: T.Type
+  ) throws where T: Verifiable {
    let derefValue = try dereference(field)

    if let value = derefValue {
@@ -115,9 +115,9 @@ public struct TableVerifier {
    unionKeyName: String,
    fieldName: String,
    required: Bool,
-    completion: @escaping (inout Verifier, T, Int) throws -> Void) throws
-    where T: UnionEnum
-  {
+    completion: @escaping (inout Verifier, T, Int) throws -> Void
+  ) throws
+  where T: UnionEnum {
    let keyPos = try dereference(key)
    let valPos = try dereference(field)

@@ -131,14 +131,16 @@ public struct TableVerifier {
    }

    if let _key = keyPos,
-       let _val = valPos
+      let _val = valPos
    {
      /// verifiying that the key is within the buffer
      try T.T.verify(&_verifier, at: _key, of: T.T.self)
-      guard let _enum = try T.init(value: _verifier._buffer.read(
-        def: T.T.self,
-        position: _key)) else
-      {
+      guard
+        let _enum = try T.init(
+          value: _verifier._buffer.read(
+            def: T.T.self,
+            position: _key))
+      else {
        throw FlatbuffersErrors.unknownUnionCase
      }
      /// we are assuming that Unions will always be of type Uint8
@@ -170,14 +172,14 @@ public struct TableVerifier {
    unionKeyName: String,
    fieldName: String,
    required: Bool,
-    completion: @escaping (inout Verifier, T, Int) throws -> Void) throws
-    where T: UnionEnum
-  {
+    completion: @escaping (inout Verifier, T, Int) throws -> Void
+  ) throws
+  where T: UnionEnum {
    let keyVectorPosition = try dereference(key)
    let offsetVectorPosition = try dereference(field)

    if let keyPos = keyVectorPosition,
-       let valPos = offsetVectorPosition
+      let valPos = offsetVectorPosition
    {
      try UnionVector<T>.verify(
        &_verifier,
--- a/swift/Sources/FlatBuffers/VeriferOptions.swift
+++ b/swift/Sources/FlatBuffers/VeriferOptions.swift
@@ -39,10 +39,10 @@ public struct VerifierOptions {
  ///   - ignoreMissingNullTerminators: Ignoring missing null terminals in strings *Currently not supported in swift*
  public init(
    maxDepth: UOffset = 64,
-    maxTableCount: UOffset = 1000000,
+    maxTableCount: UOffset = 1_000_000,
    maxApparentSize: UOffset = 1 << 31,
-    ignoreMissingNullTerminators: Bool = false)
-  {
+    ignoreMissingNullTerminators: Bool = false
+  ) {
    _maxDepth = maxDepth
    _maxTableCount = maxTableCount
    _maxApparentSize = maxApparentSize
--- a/swift/Sources/FlatBuffers/Verifiable.swift
+++ b/swift/Sources/FlatBuffers/Verifiable.swift
@@ -14,12 +14,12 @@
 * limitations under the License.
 */

-#if canImport(Common)
-import Common
-#endif
-
 import Foundation

+#if canImport(Common)
+  import Common
+#endif
+
 /// Verifiable is a protocol all swift flatbuffers object should conform to,
 /// since swift is similar to `cpp` and `rust` where the data is read directly
 /// from `unsafeMemory` thus the need to verify if the buffer received is a valid one
@@ -51,8 +51,8 @@ extension Verifiable {
  @discardableResult
  public static func verifyRange<T>(
    _ verifier: inout Verifier,
-    at position: Int, of type: T.Type) throws -> (start: Int, count: Int)
-  {
+    at position: Int, of type: T.Type
+  ) throws -> (start: Int, count: Int) {
    let len: UOffset = try verifier.getValue(at: position)
    let intLen = Int(len)
    let start = Int(clamping: (position &+ MemoryLayout<Int32>.size).magnitude)
@@ -74,8 +74,8 @@ extension Verifiable where Self: Scalar {
  public static func verify<T>(
    _ verifier: inout Verifier,
    at position: Int,
-    of type: T.Type) throws where T: Verifiable
-  {
+    of type: T.Type
+  ) throws where T: Verifiable {
    try verifier.inBuffer(position: position, of: type.self)
  }
 }
@@ -96,8 +96,8 @@ public enum ForwardOffset<U>: Verifiable where U: Verifiable {
  public static func verify<T>(
    _ verifier: inout Verifier,
    at position: Int,
-    of type: T.Type) throws where T: Verifiable
-  {
+    of type: T.Type
+  ) throws where T: Verifiable {
    let offset: UOffset = try verifier.getValue(at: position)
    let nextOffset = Int(clamping: (Int(offset) &+ position).magnitude)
    try U.verify(&verifier, at: nextOffset, of: U.self)
@@ -120,8 +120,8 @@ public enum Vector<U, S>: Verifiable where U: Verifiable, S: Verifiable {
  public static func verify<T>(
    _ verifier: inout Verifier,
    at position: Int,
-    of type: T.Type) throws where T: Verifiable
-  {
+    of type: T.Type
+  ) throws where T: Verifiable {
    /// checks if the next verification type S is equal to U of type forwardOffset
    /// This had to be done since I couldnt find a solution for duplicate call functions
    /// A fix will be appreciated
@@ -170,8 +170,8 @@ public enum UnionVector<S> where S: UnionEnum {
    fieldPosition: Int,
    unionKeyName: String,
    fieldName: String,
-    completion: @escaping Completion) throws
-  {
+    completion: @escaping Completion
+  ) throws {
    /// Get offset for union key vectors and offset vectors
    let keyOffset: UOffset = try verifier.getValue(at: keyPosition)
    let fieldOffset: UOffset = try verifier.getValue(at: fieldPosition)
@@ -202,10 +202,12 @@ public enum UnionVector<S> where S: UnionEnum {

      /// index of readable enum value in array
      let keysIndex = MemoryLayout<S.T>.size &* count
-      guard let _enum = try S.init(value: verifier._buffer.read(
-        def: S.T.self,
-        position: keysRange.start &+ keysIndex)) else
-      {
+      guard
+        let _enum = try S.init(
+          value: verifier._buffer.read(
+            def: S.T.self,
+            position: keysRange.start &+ keysIndex))
+      else {
        throw FlatbuffersErrors.unknownUnionCase
      }
      /// index of readable offset value in array
--- a/swift/Sources/FlatBuffers/Verifier.swift
+++ b/swift/Sources/FlatBuffers/Verifier.swift
@@ -44,7 +44,6 @@ public struct Verifier {
    storage.tableCount
  }

-
  /// Initializer for the verifier
  /// - Parameters:
  ///   - buffer: Bytebuffer that is required to be verified
@@ -54,8 +53,8 @@ public struct Verifier {
  public init(
    buffer: inout ByteBuffer,
    options: VerifierOptions = .init(),
-    checkAlignment: Bool = true) throws
-  {
+    checkAlignment: Bool = true
+  ) throws {
    guard buffer.capacity < FlatBufferMaxSize else {
      throw FlatbuffersErrors.exceedsMaxSizeAllowed
    }
@@ -186,17 +185,21 @@ public struct Verifier {

    let reportedOverflow: (partialValue: UInt32, overflow: Bool)
    if offset > 0 {
-      reportedOverflow = _int32Position
+      reportedOverflow =
+        _int32Position
        .subtractingReportingOverflow(offset.magnitude)
    } else {
-      reportedOverflow = _int32Position
+      reportedOverflow =
+        _int32Position
        .addingReportingOverflow(offset.magnitude)
    }

    /// since `subtractingReportingOverflow` & `addingReportingOverflow` returns true,
    /// if there is overflow we return failure
-    if reportedOverflow.overflow || reportedOverflow.partialValue > _buffer
-      .capacity
+    if reportedOverflow.overflow
+      || reportedOverflow.partialValue
+        > _buffer
+        .capacity
    {
      throw FlatbuffersErrors.signedOffsetOutOfBounds(
        offset: Int(offset),
--- a/swift/Sources/FlatBuffers/_InternalByteBuffer.swift
+++ b/swift/Sources/FlatBuffers/_InternalByteBuffer.swift
@@ -14,12 +14,12 @@
 * limitations under the License.
 */

-#if canImport(Common)
-import Common
-#endif
-
 import Foundation

+#if canImport(Common)
+  import Common
+#endif
+
 /// `ByteBuffer` is the interface that stores the data for a `Flatbuffers` object
 /// it allows users to Construct their buffers internally without much cost to performance
@usableFromInline
@@ -144,18 +144,18 @@ struct _InternalByteBuffer {
  /// Adds a `ContiguousBytes` to buffer memory
  /// - Parameter value: bytes to copy
  #if swift(>=5.0) && !os(WASI)
-  @inline(__always)
-  @usableFromInline
-  mutating func push(bytes: ContiguousBytes) {
-    bytes.withUnsafeBytes { ptr in
-      ensureSpace(size: ptr.count)
-      memcpy(
-        _storage.memory.advanced(by: writerIndex &- ptr.count),
-        ptr.baseAddress!,
-        ptr.count)
-      _writerSize = _writerSize &+ ptr.count
+    @inline(__always)
+    @usableFromInline
+    mutating func push(bytes: ContiguousBytes) {
+      bytes.withUnsafeBytes { ptr in
+        ensureSpace(size: ptr.count)
+        memcpy(
+          _storage.memory.advanced(by: writerIndex &- ptr.count),
+          ptr.baseAddress!,
+          ptr.count)
+        _writerSize = _writerSize &+ ptr.count
+      }
    }
-  }
  #endif

  /// Adds an object of type NativeStruct into the buffer
@@ -200,8 +200,7 @@ struct _InternalByteBuffer {
  mutating func push(string str: String, len: Int) {
    ensureSpace(size: len)
    if str.utf8
-      .withContiguousStorageIfAvailable({ self.push(bytes: $0, len: len) }) !=
-      nil
+      .withContiguousStorageIfAvailable({ self.push(bytes: $0, len: len) }) != nil
    {
    } else {
      let utf8View = str.utf8
@@ -219,8 +218,8 @@ struct _InternalByteBuffer {
  @inline(__always)
  mutating func push(
    bytes: UnsafeBufferPointer<String.UTF8View.Element>,
-    len: Int) -> Bool
-  {
+    len: Int
+  ) -> Bool {
    memcpy(
      _storage.memory.advanced(by: writerIndex &- len),
      bytes.baseAddress!,
@@ -260,7 +259,7 @@ struct _InternalByteBuffer {
  mutating func ensureSpace(size: Int) -> Int {
    let expectedWriterIndex = size &+ _writerSize
    if expectedWriterIndex > capacity {
-      
+
      let currentWritingIndex = capacity &- _writerSize
      while capacity <= expectedWriterIndex {
        capacity = capacity << 1
@@ -269,7 +268,6 @@ struct _InternalByteBuffer {
      /// solution take from Apple-NIO
      capacity = capacity.convertToPowerofTwo

-      
      _storage.reallocate(
        capacity: capacity,
        writerSize: _writerSize,
@@ -327,30 +325,32 @@ struct _InternalByteBuffer {
  @inline(__always)
  func withUnsafeBytes<T>(
    _ body: (UnsafeRawBufferPointer) throws
-      -> T) rethrows -> T
-  {
-    try body(UnsafeRawBufferPointer(
-      start: _storage.memory,
-      count: capacity))
+      -> T
+  ) rethrows -> T {
+    try body(
+      UnsafeRawBufferPointer(
+        start: _storage.memory,
+        count: capacity))
  }

  @discardableResult
  @inline(__always)
  func withUnsafeSlicedBytes<T>(
    _ body: (UnsafeRawBufferPointer) throws
-      -> T) rethrows -> T
-  {
-    try body(UnsafeRawBufferPointer(
-      start: _storage.memory.advanced(by: writerIndex),
-      count: capacity &- writerIndex))
+      -> T
+  ) rethrows -> T {
+    try body(
+      UnsafeRawBufferPointer(
+        start: _storage.memory.advanced(by: writerIndex),
+        count: capacity &- writerIndex))
  }

  @discardableResult
  @inline(__always)
  func withUnsafeRawPointer<T>(
    _ body: (UnsafeMutableRawPointer) throws
-      -> T) rethrows -> T
-  {
+      -> T
+  ) rethrows -> T {
    try body(_storage.memory)
  }

@@ -358,8 +358,8 @@ struct _InternalByteBuffer {
  @inline(__always)
  func readWithUnsafeRawPointer<T>(
    position: Int,
-    _ body: (UnsafeRawPointer) throws -> T) rethrows -> T
-  {
+    _ body: (UnsafeRawPointer) throws -> T
+  ) rethrows -> T {
    try body(_storage.memory.advanced(by: position))
  }
 }
--- a/swift/Sources/FlexBuffers/ByteBuffer.swift
+++ b/swift/Sources/FlexBuffers/ByteBuffer.swift
@@ -29,8 +29,8 @@ public struct ByteBuffer {
    @usableFromInline
    enum Blob {
      #if !os(WASI)
-      case data(Data)
-      case bytes(ContiguousBytes)
+        case data(Data)
+        case bytes(ContiguousBytes)
      #endif

      case byteBuffer(_InternalByteBuffer)
@@ -96,16 +96,16 @@ public struct ByteBuffer {
    @inline(__always)
    func withUnsafeBytes<T>(
      _ body: (UnsafeRawBufferPointer) throws
-        -> T) rethrows -> T
-    {
+        -> T
+    ) rethrows -> T {
      switch retainedBlob {
      case .byteBuffer(let byteBuffer):
        return try byteBuffer.withUnsafeBytes(body)
      #if !os(WASI)
-      case .data(let data):
-        return try data.withUnsafeBytes(body)
-      case .bytes(let contiguousBytes):
-        return try contiguousBytes.withUnsafeBytes(body)
+        case .data(let data):
+          return try data.withUnsafeBytes(body)
+        case .bytes(let contiguousBytes):
+          return try contiguousBytes.withUnsafeBytes(body)
      #endif
      case .array(let array):
        return try array.withUnsafeBytes(body)
@@ -118,25 +118,28 @@ public struct ByteBuffer {
    @inline(__always)
    func withUnsafeRawPointer<T>(
      _ body: (UnsafeMutableRawPointer) throws
-        -> T) rethrows -> T
-    {
+        -> T
+    ) rethrows -> T {
      switch retainedBlob {
      case .byteBuffer(let byteBuffer):
        return try byteBuffer.withUnsafeRawPointer(body)
      #if !os(WASI)
-      case .data(let data):
-        return try data
-          .withUnsafeBytes {
-            try body(UnsafeMutableRawPointer(mutating: $0.baseAddress!))
-          }
-      case .bytes(let contiguousBytes):
-        return try contiguousBytes
-          .withUnsafeBytes {
-            try body(UnsafeMutableRawPointer(mutating: $0.baseAddress!))
-          }
+        case .data(let data):
+          return
+            try data
+            .withUnsafeBytes {
+              try body(UnsafeMutableRawPointer(mutating: $0.baseAddress!))
+            }
+        case .bytes(let contiguousBytes):
+          return
+            try contiguousBytes
+            .withUnsafeBytes {
+              try body(UnsafeMutableRawPointer(mutating: $0.baseAddress!))
+            }
      #endif
      case .array(let array):
-        return try array
+        return
+          try array
          .withUnsafeBytes {
            try body(UnsafeMutableRawPointer(mutating: $0.baseAddress!))
          }
@@ -149,20 +152,20 @@ public struct ByteBuffer {
    @inline(__always)
    func readWithUnsafeRawPointer<T>(
      position: Int,
-      _ body: (UnsafeRawPointer) throws -> T) rethrows -> T
-    {
+      _ body: (UnsafeRawPointer) throws -> T
+    ) rethrows -> T {
      switch retainedBlob {
      case .byteBuffer(let byteBuffer):
        return try byteBuffer.readWithUnsafeRawPointer(position: position, body)
      #if !os(WASI)
-      case .data(let data):
-        return try data.withUnsafeBytes {
-          try body($0.baseAddress!.advanced(by: position))
-        }
-      case .bytes(let contiguousBytes):
-        return try contiguousBytes.withUnsafeBytes {
-          try body($0.baseAddress!.advanced(by: position))
-        }
+        case .data(let data):
+          return try data.withUnsafeBytes {
+            try body($0.baseAddress!.advanced(by: position))
+          }
+        case .bytes(let contiguousBytes):
+          return try contiguousBytes.withUnsafeBytes {
+            try body($0.baseAddress!.advanced(by: position))
+          }
      #endif
      case .array(let array):
        return try array.withUnsafeBytes {
@@ -204,8 +207,8 @@ public struct ByteBuffer {
  @inline(__always)
  public init(
    copyingMemoryBound memory: UnsafeRawPointer,
-    capacity: Int)
-  {
+    capacity: Int
+  ) {
    _storage = Storage(count: capacity)
    _storage.copy(from: memory, count: capacity)
    _readerIndex = capacity
@@ -223,29 +226,29 @@ public struct ByteBuffer {
  }

  #if !os(WASI)
-  /// Constructor that creates a Flatbuffer from the Swift Data type object
-  /// - Parameter
-  ///   - data: Swift data Object
-  @inline(__always)
-  public init(data: Data) {
-    _storage = Storage(blob: .data(data), capacity: data.count)
-    _readerIndex = data.count
-    capacity = data.count
-  }
+    /// Constructor that creates a Flatbuffer from the Swift Data type object
+    /// - Parameter
+    ///   - data: Swift data Object
+    @inline(__always)
+    public init(data: Data) {
+      _storage = Storage(blob: .data(data), capacity: data.count)
+      _readerIndex = data.count
+      capacity = data.count
+    }

-  /// Constructor that creates a Flatbuffer object from a ContiguousBytes
-  /// - Parameters:
-  ///   - contiguousBytes: Binary stripe to use as the buffer
-  ///   - count: amount of readable bytes
-  @inline(__always)
-  public init<Bytes: ContiguousBytes>(
-    contiguousBytes: Bytes,
-    count: Int)
-  {
-    _storage = Storage(blob: .bytes(contiguousBytes), capacity: count)
-    _readerIndex = count
-    capacity = count
-  }
+    /// Constructor that creates a Flatbuffer object from a ContiguousBytes
+    /// - Parameters:
+    ///   - contiguousBytes: Binary stripe to use as the buffer
+    ///   - count: amount of readable bytes
+    @inline(__always)
+    public init<Bytes: ContiguousBytes>(
+      contiguousBytes: Bytes,
+      count: Int
+    ) {
+      _storage = Storage(blob: .bytes(contiguousBytes), capacity: count)
+      _readerIndex = count
+      capacity = count
+    }
  #endif

  /// Constructor that creates a Flatbuffer from unsafe memory region without copying
@@ -257,8 +260,8 @@ public struct ByteBuffer {
  @inline(__always)
  public init(
    assumingMemoryBound memory: UnsafeMutableRawPointer,
-    capacity: Int)
-  {
+    capacity: Int
+  ) {
    _storage = Storage(
      blob: .pointer(memory),
      capacity: capacity)
@@ -275,8 +278,8 @@ public struct ByteBuffer {
  init(
    blob: Storage.Blob,
    count: Int,
-    removing removeBytes: Int)
-  {
+    removing removeBytes: Int
+  ) {
    _storage = Storage(blob: blob, capacity: count)
    _readerIndex = removeBytes
    capacity = count
@@ -368,8 +371,8 @@ public struct ByteBuffer {
    t3: T3.Type,
    t4: T4.Type,
    position: Int,
-    byteWidth: UInt8) -> T
-  {
+    byteWidth: UInt8
+  ) -> T {
    switch byteWidth {
    case 1:
      numericCast(read(def: T1.self, position: position))
@@ -389,8 +392,8 @@ public struct ByteBuffer {
  @inline(__always)
  public func readSlice<T>(
    index: Int,
-    count: Int) -> [T]
-  {
+    count: Int
+  ) -> [T] {
    assert(
      index + count <= capacity,
      "Reading out of bounds is illegal")
@@ -407,8 +410,8 @@ public struct ByteBuffer {
  public func readString(
    at index: Int,
    count: Int,
-    type: String.Encoding) -> String?
-  {
+    type: String.Encoding
+  ) -> String? {
    assert(
      index + count <= capacity,
      "Reading out of bounds is illegal")
@@ -429,8 +432,8 @@ public struct ByteBuffer {
  @inline(__always)
  public func readString(
    at index: Int,
-    count: Int) -> String?
-  {
+    count: Int
+  ) -> String? {
    assert(
      index + count <= capacity,
      "Reading out of bounds is illegal")
@@ -448,8 +451,8 @@ public struct ByteBuffer {
  public func withUnsafePointerToSlice<T>(
    index: Int,
    count: Int,
-    body: (UnsafeRawBufferPointer) throws -> T) rethrows -> T
-  {
+    body: (UnsafeRawBufferPointer) throws -> T
+  ) rethrows -> T {
    assert(
      index + count <= capacity,
      "Reading out of bounds is illegal")
@@ -462,8 +465,8 @@ public struct ByteBuffer {
  @inline(__always)
  public func withUnsafeBytes<T>(
    body: (UnsafeRawBufferPointer) throws
-      -> T) rethrows -> T
-  {
+      -> T
+  ) rethrows -> T {
    try _storage.withUnsafeBytes(body)
  }

@@ -471,8 +474,8 @@ public struct ByteBuffer {
  @inline(__always)
  func withUnsafeMutableRawPointer<T>(
    body: (UnsafeMutableRawPointer) throws
-      -> T) rethrows -> T
-  {
+      -> T
+  ) rethrows -> T {
    try _storage.withUnsafeRawPointer(body)
  }

@@ -480,8 +483,8 @@ public struct ByteBuffer {
  @inline(__always)
  func readWithUnsafeRawPointer<T>(
    position: Int,
-    _ body: (UnsafeRawPointer) throws -> T) rethrows -> T
-  {
+    _ body: (UnsafeRawPointer) throws -> T
+  ) rethrows -> T {
    try _storage.readWithUnsafeRawPointer(position: position, body)
  }
 }
--- a/swift/Sources/FlexBuffers/FlexBufferType.swift
+++ b/swift/Sources/FlexBuffers/FlexBufferType.swift
@@ -46,7 +46,8 @@ public enum FlexBufferType: UInt64 {
  @available(
    *,
    deprecated,
-    message: "use FBT_VECTOR or FBT_VECTOR_KEY instead.")
+    message: "use FBT_VECTOR or FBT_VECTOR_KEY instead."
+  )
  case vectorString = 15

  /// Typed tuples (no type table, no size field).
--- a/swift/Sources/FlexBuffers/Reader/FixedTypedVector.swift
+++ b/swift/Sources/FlexBuffers/Reader/FixedTypedVector.swift
@@ -31,8 +31,8 @@ public struct FixedTypedVector: FlexBufferVector {
    offset: Int,
    byteWidth: UInt8,
    type: FlexBufferType,
-    count: Int)
-  {
+    count: Int
+  ) {
    self.byteBuffer = byteBuffer
    self.offset = offset
    self.byteWidth = byteWidth
--- a/swift/Sources/FlexBuffers/Reader/FlexBufferVector.swift
+++ b/swift/Sources/FlexBuffers/Reader/FlexBufferVector.swift
@@ -39,13 +39,14 @@ public protocol FlexBufferContiguousBytes {
  var count: Int { get }

  func withUnsafeRawBufferPointer<Result>(
-    _ body: (UnsafeRawBufferPointer) throws -> Result) rethrows -> Result
+    _ body: (UnsafeRawBufferPointer) throws -> Result
+  ) rethrows -> Result
 }

 extension FlexBufferContiguousBytes {
  public func withUnsafeRawBufferPointer<Result>(
-    _ body: (UnsafeRawBufferPointer) throws -> Result) rethrows -> Result
-  {
+    _ body: (UnsafeRawBufferPointer) throws -> Result
+  ) rethrows -> Result {
    try byteBuffer.withUnsafePointerToSlice(
      index: offset,
      count: count,
--- a/swift/Sources/FlexBuffers/Reader/Reference.swift
+++ b/swift/Sources/FlexBuffers/Reader/Reference.swift
@@ -58,8 +58,8 @@ public struct Reference {
    byteBuffer: ByteBuffer,
    offset: Int,
    parentWidth: UInt8,
-    packedType: UInt8)
-  {
+    packedType: UInt8
+  ) {
    guard let type = FlexBufferType(rawValue: UInt64(packedType >> 2)) else {
      return nil
    }
@@ -76,8 +76,8 @@ public struct Reference {
    offset: Int,
    parentWidth: UInt8,
    byteWidth: UInt8,
-    type: FlexBufferType)
-  {
+    type: FlexBufferType
+  ) {
    self.byteBuffer = byteBuffer
    self.offset = offset
    self.parentWidth = parentWidth
@@ -97,7 +97,8 @@ public struct Reference {
  public var uint: UInt64? {
    return switch type {
    case .uint: byteBuffer.readUInt64(offset: offset, byteWidth: byteWidth)
-    case .indirectUInt: byteBuffer.readUInt64(
+    case .indirectUInt:
+      byteBuffer.readUInt64(
        offset: indirect(),
        byteWidth: byteWidth)
    default: nil
@@ -108,7 +109,8 @@ public struct Reference {
  public var int: Int64? {
    return switch type {
    case .int: byteBuffer.readInt64(offset: offset, byteWidth: byteWidth)
-    case .indirectInt: byteBuffer.readInt64(
+    case .indirectInt:
+      byteBuffer.readInt64(
        offset: indirect(),
        byteWidth: byteWidth)
    default: nil
@@ -119,7 +121,8 @@ public struct Reference {
  public var double: Double? {
    return switch type {
    case .float: byteBuffer.readDouble(offset: offset, byteWidth: byteWidth)
-    case .indirectFloat: byteBuffer.readDouble(
+    case .indirectFloat:
+      byteBuffer.readDouble(
        offset: indirect(),
        byteWidth: byteWidth)
    default: nil
@@ -238,7 +241,8 @@ public struct Reference {
  @inline(__always)
  public func withUnsafeRawPointer<Result>(
    _ completion: (UnsafeRawPointer) throws
-      -> Result)
+      -> Result
+  )
    rethrows -> Result?
  {
    return try byteBuffer.readWithUnsafeRawPointer(
--- a/swift/Sources/FlexBuffers/Reader/TypedVector.swift
+++ b/swift/Sources/FlexBuffers/Reader/TypedVector.swift
@@ -30,8 +30,8 @@ public struct TypedVector: FlexBufferVector {
    byteBuffer: ByteBuffer,
    offset: Int,
    byteWidth: UInt8,
-    type: FlexBufferType)
-  {
+    type: FlexBufferType
+  ) {
    self.byteBuffer = byteBuffer
    self.offset = offset
    self.byteWidth = byteWidth
@@ -54,8 +54,8 @@ public struct TypedVector: FlexBufferVector {
  static func mapKeys(
    byteBuffer: ByteBuffer,
    offset: Int,
-    byteWidth: UInt8) -> TypedVector
-  {
+    byteWidth: UInt8
+  ) -> TypedVector {
    let prefixedFields = 3
    let keysOffset = offset &- (numericCast(byteWidth) &* prefixedFields)

@@ -88,12 +88,11 @@ extension TypedVector {
      byteWidth)

    return byteBuffer.readWithUnsafeRawPointer(
-      position: indirectoffset)
-    { bufPointer in
+      position: indirectoffset
+    ) { bufPointer in
      target.withCString { strPointer in
        Int(strcmp(bufPointer, strPointer))
      }
    }
  }
 }
-
--- a/swift/Sources/FlexBuffers/Utils/BitWidth.swift
+++ b/swift/Sources/FlexBuffers/Utils/BitWidth.swift
@@ -18,7 +18,10 @@ import Foundation

@usableFromInline
 enum BitWidth: UInt64, CaseIterable {
-  case w8 = 0, w16 = 1, w32 = 2, w64 = 3
+  case w8 = 0
+  case w16 = 1
+  case w32 = 2
+  case w64 = 3
 }

 extension BitWidth: Comparable {
--- a/swift/Sources/FlexBuffers/Utils/Constants.swift
+++ b/swift/Sources/FlexBuffers/Utils/Constants.swift
@@ -14,11 +14,12 @@
 * limitations under the License.
 */

-#if canImport(Common)
-import Common
-#endif
 import Foundation

+#if canImport(Common)
+  import Common
+#endif
+
 extension UInt64 {
  static let one: UInt64 = 1
 }
@@ -55,4 +56,3 @@ extension Optional {
    }
  }
 }
-
--- a/swift/Sources/FlexBuffers/Utils/Value.swift
+++ b/swift/Sources/FlexBuffers/Utils/Value.swift
@@ -14,12 +14,12 @@
 * limitations under the License.
 */

-#if canImport(Common)
-import Common
-#endif
-
 import Foundation

+#if canImport(Common)
+  import Common
+#endif
+
 public struct Value: Equatable {

  @usableFromInline
@@ -110,9 +110,11 @@ extension Value {
      return bitWidth
    } else {
      for byteWidth in stride(from: 1, to: MemoryLayout<UInt64>.size, by: 2) {
-        let _offsetLoc: UInt64 = numericCast(numericCast(size) &+ padding(
-          bufSize: numericCast(size),
-          elementSize: numericCast(byteWidth)))
+        let _offsetLoc: UInt64 = numericCast(
+          numericCast(size)
+            &+ padding(
+              bufSize: numericCast(size),
+              elementSize: numericCast(byteWidth)))
        let offsetLoc = _offsetLoc &+ (index &* numericCast(byteWidth))
        let offset = offsetLoc &- u

--- a/swift/Sources/FlexBuffers/Utils/functions.swift
+++ b/swift/Sources/FlexBuffers/Utils/functions.swift
@@ -14,12 +14,12 @@
 * limitations under the License.
 */

-#if canImport(Common)
-import Common
-#endif
-
 import Foundation

+#if canImport(Common)
+  import Common
+#endif
+
@inline(__always)
 internal func isInline(_ t: FlexBufferType) -> Bool {
  return t <= .float || t == .bool
@@ -73,17 +73,26 @@ func getScalarType<T>(type: T.Type) -> FlexBufferType where T: Scalar {

@inline(__always)
 func toTypedVector(type: FlexBufferType, length: UInt64) -> FlexBufferType {
-  let type: UInt64 = switch length {
-  case 0: type.rawValue &- FlexBufferType.int.rawValue &+ FlexBufferType
-    .vectorInt.rawValue
-  case 2: type.rawValue &- FlexBufferType.int.rawValue &+ FlexBufferType
-    .vectorInt2.rawValue
-  case 3: type.rawValue &- FlexBufferType.int.rawValue &+ FlexBufferType
-    .vectorInt3.rawValue
-  case 4: type.rawValue &- FlexBufferType.int.rawValue &+ FlexBufferType
-    .vectorInt4.rawValue
-  default: 0
-  }
+  let type: UInt64 =
+    switch length {
+    case 0:
+      type.rawValue &- FlexBufferType.int.rawValue
+        &+ FlexBufferType
+        .vectorInt.rawValue
+    case 2:
+      type.rawValue &- FlexBufferType.int.rawValue
+        &+ FlexBufferType
+        .vectorInt2.rawValue
+    case 3:
+      type.rawValue &- FlexBufferType.int.rawValue
+        &+ FlexBufferType
+        .vectorInt3.rawValue
+    case 4:
+      type.rawValue &- FlexBufferType.int.rawValue
+        &+ FlexBufferType
+        .vectorInt4.rawValue
+    default: 0
+    }
  return FlexBufferType(rawValue: type) ?? .null
 }

@@ -100,7 +109,8 @@ func isTypedVectorType(type: FlexBufferType) -> Bool {
@inline(__always)
 func toTypedVectorElementType(type: FlexBufferType) -> FlexBufferType? {
  return FlexBufferType(
-    rawValue: type.rawValue &- FlexBufferType.vectorInt
+    rawValue: type.rawValue
+      &- FlexBufferType.vectorInt
      .rawValue &+ FlexBufferType.int.rawValue)
 }

@@ -115,12 +125,16 @@ func toFixedTypedVectorElementType(type: FlexBufferType)
 {
  assert(isFixedTypedVectorType(type: type))
  let fixedType: UInt64 = numericCast(
-    type.rawValue &- FlexBufferType.vectorInt2
+    type.rawValue
+      &- FlexBufferType.vectorInt2
      .rawValue)
  let len: Int = numericCast(fixedType.dividedReportingOverflow(by: 3).partialValue &+ 2)
  return (
-    FlexBufferType(rawValue: (fixedType.quotientAndRemainder(dividingBy: 3).remainder) &+ FlexBufferType.int.rawValue),
-    len)
+    FlexBufferType(
+      rawValue: (fixedType.quotientAndRemainder(dividingBy: 3).remainder)
+        &+ FlexBufferType.int.rawValue),
+    len
+  )
 }

 // MARK: - Reader functions
@@ -128,8 +142,8 @@ func toFixedTypedVectorElementType(type: FlexBufferType)
@inline(__always)
 func binarySearch(
  vector: TypedVector,
-  target: String) -> Int?
-{
+  target: String
+) -> Int? {
  var left = 0
  var right = vector.count

@@ -149,14 +163,17 @@ func binarySearch(

@inline(__always)
 func readIndirect(buffer: ByteBuffer, offset: Int, _ byteWidth: UInt8) -> Int {
-  return offset &- numericCast(buffer.readUInt64(
-    offset: offset,
-    byteWidth: byteWidth))
+  return offset
+    &- numericCast(
+      buffer.readUInt64(
+        offset: offset,
+        byteWidth: byteWidth))
 }

@inline(__always)
 func getCount(buffer: ByteBuffer, offset: Int, byteWidth: UInt8) -> Int {
-  Int(buffer.readUInt64(
-    offset: offset &- numericCast(byteWidth),
-    byteWidth: byteWidth))
+  Int(
+    buffer.readUInt64(
+      offset: offset &- numericCast(byteWidth),
+      byteWidth: byteWidth))
 }
--- a/swift/Sources/FlexBuffers/Writer/FlexBuffersWriter.swift
+++ b/swift/Sources/FlexBuffers/Writer/FlexBuffersWriter.swift
@@ -14,12 +14,12 @@
 * limitations under the License.
 */

-#if canImport(Common)
-import Common
-#endif
-
 import Foundation

+#if canImport(Common)
+  import Common
+#endif
+
 private let twentyFourBytes: Int = 24
 public typealias FlexBuffersWriterBuilder = (inout FlexBuffersWriter) -> Void

@@ -74,21 +74,21 @@ public struct FlexBuffersWriter {
  }

  #if !os(WASI)
-  /// Data representation of the buffer
-  ///
-  /// Should only be used after ``finish(offset:addPrefix:)`` is called
-  public var data: Data {
-    assert(finished, "Data shouldn't be called before finish()")
-    return _bb.withUnsafeSlicedBytes { ptr in
-      var data = Data()
-      data.append(
-        ptr.baseAddress!.bindMemory(
-          to: UInt8.self,
-          capacity: ptr.count),
-        count: ptr.count)
-      return data
+    /// Data representation of the buffer
+    ///
+    /// Should only be used after ``finish(offset:addPrefix:)`` is called
+    public var data: Data {
+      assert(finished, "Data shouldn't be called before finish()")
+      return _bb.withUnsafeSlicedBytes { ptr in
+        var data = Data()
+        data.append(
+          ptr.baseAddress!.bindMemory(
+            to: UInt8.self,
+            capacity: ptr.count),
+          count: ptr.count)
+        return data
+      }
    }
-  }
  #endif

  /// Resets the internal state. Automatically called before building a new flexbuffer.
@@ -139,8 +139,8 @@ public struct FlexBuffersWriter {
  public mutating func endVector(
    start: Int,
    typed: Bool = false,
-    fixed: Bool = false) -> UInt64
-  {
+    fixed: Bool = false
+  ) -> UInt64 {
    let vec = createVector(
      start: start,
      count: stack.count &- start,
@@ -162,8 +162,7 @@ public struct FlexBuffersWriter {
  @discardableResult
  @inline(__always)
  public mutating func create<T>(vector: [T], key: borrowing String) -> Int
-    where T: Scalar
-  {
+  where T: Scalar {
    add(key: key)
    return create(vector: vector, fixed: false)
  }
@@ -179,8 +178,8 @@ public struct FlexBuffersWriter {
  @inline(__always)
  public mutating func createFixed<T>(
    vector: [T],
-    key: borrowing String) -> Int where T: Scalar
-  {
+    key: borrowing String
+  ) -> Int where T: Scalar {
    assert(vector.count >= 2 && vector.count <= 4)
    add(key: key)
    return create(vector: vector, fixed: true)
@@ -302,8 +301,8 @@ public struct FlexBuffersWriter {
  @inline(__always)
  public mutating func add(
    uint64 value: borrowing UInt64,
-    key: borrowing String)
-  {
+    key: borrowing String
+  ) {
    add(key: key)
    add(uint64: value)
  }
@@ -316,8 +315,8 @@ public struct FlexBuffersWriter {
  @inline(__always)
  public mutating func indirect(
    uint64 val: borrowing UInt64,
-    key: borrowing String)
-  {
+    key: borrowing String
+  ) {
    add(key: key)
    indirect(uint64: val)
  }
@@ -325,8 +324,8 @@ public struct FlexBuffersWriter {
  @inline(__always)
  public mutating func indirect(
    uint val: borrowing UInt,
-    key: borrowing String)
-  {
+    key: borrowing String
+  ) {
    add(key: key)
    indirect(uint64: numericCast(val))
  }
@@ -385,8 +384,8 @@ public struct FlexBuffersWriter {
  @inline(__always)
  public mutating func add(
    int64 value: borrowing Int64,
-    key: borrowing String)
-  {
+    key: borrowing String
+  ) {
    add(key: key)
    add(int64: value)
  }
@@ -399,8 +398,8 @@ public struct FlexBuffersWriter {
  @inline(__always)
  public mutating func indirect(
    int64 val: borrowing Int64,
-    key: borrowing String)
-  {
+    key: borrowing String
+  ) {
    add(key: key)
    indirect(int64: val)
  }
@@ -408,8 +407,8 @@ public struct FlexBuffersWriter {
  @inline(__always)
  public mutating func indirect(
    int val: borrowing Int,
-    key: borrowing String)
-  {
+    key: borrowing String
+  ) {
    add(key: key)
    indirect(int64: numericCast(val))
  }
@@ -424,8 +423,8 @@ public struct FlexBuffersWriter {
  @inline(__always)
  public mutating func add(
    float32 value: borrowing Float32,
-    key: borrowing String)
-  {
+    key: borrowing String
+  ) {
    add(key: key)
    add(float32: value)
  }
@@ -438,8 +437,8 @@ public struct FlexBuffersWriter {
  @inline(__always)
  public mutating func indirect(
    float32 val: borrowing Float32,
-    key: borrowing String)
-  {
+    key: borrowing String
+  ) {
    add(key: key)
    indirect(float32: val)
  }
@@ -452,8 +451,8 @@ public struct FlexBuffersWriter {
  @inline(__always)
  public mutating func add(
    double value: borrowing Double,
-    key: borrowing String)
-  {
+    key: borrowing String
+  ) {
    add(key: key)
    add(double: value)
  }
@@ -466,8 +465,8 @@ public struct FlexBuffersWriter {
  @inline(__always)
  public mutating func indirect(
    double val: borrowing Double,
-    key: borrowing String)
-  {
+    key: borrowing String
+  ) {
    add(key: key)
    indirect(double: val)
  }
@@ -489,8 +488,8 @@ public struct FlexBuffersWriter {
  @inline(__always)
  public mutating func add<T>(
    blob: borrowing T,
-    length l: Int) -> UInt where T: ContiguousBytes
-  {
+    length l: Int
+  ) -> UInt where T: ContiguousBytes {
    storeBlob(blob, len: l, type: .blob)
  }

@@ -499,8 +498,8 @@ public struct FlexBuffersWriter {
  public mutating func add<T>(
    blob: borrowing T,
    key: borrowing String,
-    length l: Int) -> UInt where T: ContiguousBytes
-  {
+    length l: Int
+  ) -> UInt where T: ContiguousBytes {
    add(key: key)
    return storeBlob(blob, len: l, type: .blob)
  }
@@ -541,8 +540,8 @@ public struct FlexBuffersWriter {
  mutating func pushIndirect<T>(
    value: T,
    type: FlexBufferType,
-    bitWidth: BitWidth)
-  {
+    bitWidth: BitWidth
+  ) {
    let byteWidth = align(width: bitWidth)
    let iloc = writerIndex
    _bb.ensureSpace(size: byteWidth)
@@ -619,8 +618,8 @@ public struct FlexBuffersWriter {
  mutating func storeBlob<T>(
    _ bytes: T,
    len: Int,
-    type: FlexBufferType) -> UInt where T: ContiguousBytes
-  {
+    type: FlexBufferType
+  ) -> UInt where T: ContiguousBytes {
    return bytes.withUnsafeBytes {
      storeBlob(pointer: $0.baseAddress!, len: len, type: type)
    }
@@ -632,8 +631,8 @@ public struct FlexBuffersWriter {
    pointer: borrowing UnsafeRawPointer,
    len: Int,
    trailing: Int = 0,
-    type: FlexBufferType) -> UInt
-  {
+    type: FlexBufferType
+  ) -> UInt {
    _bb.ensureSpace(size: len &+ trailing)
    let bitWidth = widthU(numericCast(len))

@@ -656,8 +655,7 @@ public struct FlexBuffersWriter {
  @discardableResult
  @usableFromInline
  mutating func create<T>(vector: [T], fixed: Bool) -> Int
-    where T: Scalar
-  {
+  where T: Scalar {
    let length: UInt64 = numericCast(vector.count)
    let vectorType = getScalarType(type: T.self)
    let byteWidth = MemoryLayout<T>.size
@@ -693,8 +691,8 @@ public struct FlexBuffersWriter {
    step: Int,
    typed: Bool,
    fixed: Bool,
-    keys: Value? = nil) -> Value
-  {
+    keys: Value? = nil
+  ) -> Value {
    assert(
      !fixed || typed,
      "Typed false and fixed true is a combination not supported currently")
@@ -736,16 +734,17 @@ public struct FlexBuffersWriter {
    let byteWidth = align(width: bitWidth)

    let currentSize: Int = count &* step &* byteWidth
-    let requiredSize: Int = if !typed {
-      // We ensure that we have enough space
-      // for loop two write operations &
-      // 24 bytes for when its not fixed,
-      // and keys isn't null. As an extra safe
-      // guard
-      (currentSize &* 2) &+ twentyFourBytes
-    } else {
-      currentSize
-    }
+    let requiredSize: Int =
+      if !typed {
+        // We ensure that we have enough space
+        // for loop two write operations &
+        // 24 bytes for when its not fixed,
+        // and keys isn't null. As an extra safe
+        // guard
+        (currentSize &* 2) &+ twentyFourBytes
+      } else {
+        currentSize
+      }

    _bb.ensureSpace(
      size: requiredSize)
@@ -858,8 +857,8 @@ extension FlexBuffersWriter {
  @discardableResult
  public mutating func vector(
    key: String,
-    _ closure: FlexBuffersWriterBuilder) -> UInt64
-  {
+    _ closure: FlexBuffersWriterBuilder
+  ) -> UInt64 {
    let start = startVector(key: key)
    closure(&self)
    return endVector(start: start)
@@ -880,8 +879,8 @@ extension FlexBuffersWriter {
  @discardableResult
  public mutating func map(
    key: String,
-    _ closure: FlexBuffersWriterBuilder) -> UInt64
-  {
+    _ closure: FlexBuffersWriterBuilder
+  ) -> UInt64 {
    let start = startMap(key: key)
    closure(&self)
    return endMap(start: start)
--- a/swift/Sources/FlexBuffers/_InternalByteBuffer.swift
+++ b/swift/Sources/FlexBuffers/_InternalByteBuffer.swift
@@ -14,12 +14,12 @@
 * limitations under the License.
 */

-#if canImport(Common)
-import Common
-#endif
-
 import Foundation

+#if canImport(Common)
+  import Common
+#endif
+
 /// `ByteBuffer` is the interface that stores the data for a `Flatbuffers` object
 /// it allows users to write and read data directly from memory thus the use of its
 /// functions should be used
@@ -124,7 +124,7 @@ struct _InternalByteBuffer {
  @usableFromInline
  mutating func ensureSpace(size: Int) {
    guard size &+ writerIndex > capacity else { return }
-    
+
    while capacity <= writerIndex &+ size {
      capacity = capacity << 1
    }
@@ -141,9 +141,12 @@ struct _InternalByteBuffer {

  @inline(__always)
  mutating func addPadding(bytes: Int) {
-    writerIndex = writerIndex &+ numericCast(padding(
-      bufSize: numericCast(writerIndex),
-      elementSize: numericCast(bytes)))
+    writerIndex =
+      writerIndex
+      &+ numericCast(
+        padding(
+          bufSize: numericCast(writerIndex),
+          elementSize: numericCast(bytes)))
    ensureSpace(size: writerIndex)
  }

@@ -171,30 +174,32 @@ struct _InternalByteBuffer {
  @inline(__always)
  func withUnsafeBytes<T>(
    _ body: (UnsafeRawBufferPointer) throws
-      -> T) rethrows -> T
-  {
-    try body(UnsafeRawBufferPointer(
-      start: _storage.memory,
-      count: capacity))
+      -> T
+  ) rethrows -> T {
+    try body(
+      UnsafeRawBufferPointer(
+        start: _storage.memory,
+        count: capacity))
  }

  @discardableResult
  @inline(__always)
  func withUnsafeSlicedBytes<T>(
    _ body: (UnsafeRawBufferPointer) throws
-      -> T) rethrows -> T
-  {
-    try body(UnsafeRawBufferPointer(
-      start: _storage.memory,
-      count: writerIndex))
+      -> T
+  ) rethrows -> T {
+    try body(
+      UnsafeRawBufferPointer(
+        start: _storage.memory,
+        count: writerIndex))
  }

  @discardableResult
  @inline(__always)
  func withUnsafeRawPointer<T>(
    _ body: (UnsafeMutableRawPointer) throws
-      -> T) rethrows -> T
-  {
+      -> T
+  ) rethrows -> T {
    try body(_storage.memory)
  }

@@ -202,8 +207,8 @@ struct _InternalByteBuffer {
  @inline(__always)
  func readWithUnsafeRawPointer<T>(
    position: Int,
-    _ body: (UnsafeRawPointer) throws -> T) rethrows -> T
-  {
+    _ body: (UnsafeRawPointer) throws -> T
+  ) rethrows -> T {
    try body(_storage.memory.advanced(by: position))
  }
 }