Merge pull request #429 from scala-steward/update/scalafmt-core-3.0.8

Update scalafmt-core to 3.0.8

Author: mergify[bot]

.scalafmt.conf

@@ -1,4 +1,4 @@
-version = "3.0.7"
+version = "3.0.8"
 style = defaultWithAlign
 maxColumn = 120
 align.openParenDefnSite = true

app/nodejs-v10/src/test/scala/io/scalajs/nodejs/http/HttpTest.scala

@@ -17,8 +17,8 @@ class HttpTest extends AnyFunSpec {
       assert(server !== null)
 
       // don't listen on a port
-      //server.listen(58888)
-      //setTimeout(() => server.close(), 100.millis)
+      // server.listen(58888)
+      // setTimeout(() => server.close(), 100.millis)
     }
 
     it("should provide statusCode") {

app/nodejs-v10/src/test/scala/io/scalajs/nodejs/http/StatusCodeTest.scala

@@ -16,8 +16,8 @@ class StatusCodeTest extends AnyFunSpec {
       assert(server !== null)
 
       // don't listen on a port
-      //server.listen(58888)
-      //setTimeout(() => server.close(), 100.millis)
+      // server.listen(58888)
+      // setTimeout(() => server.close(), 100.millis)
     }
   }
 }

app/nodejs-v16/src/main/scala/io/scalajs/nodejs/Error.scala

@@ -39,17 +39,17 @@ class Error() extends js.Object {
 @js.native
 @JSGlobal
 object Error extends js.Object {
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
   //      Properties
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
 
   /** Error.stackTraceLimit
     */
   def stackTraceLimit: Int = js.native
 
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
   //      Methods
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
 
   /** Creates a .stack property on targetObject, which when accessed returns a string representing the location in the
     * code at which Error.captureStackTrace() was called.

app/nodejs-v16/src/main/scala/io/scalajs/nodejs/buffer/Buffer.scala

@@ -39,9 +39,9 @@ class Buffer protected () extends Uint8Array( /* dummy to trick constructor */ -
   @JSBracketAccess
   def update(index: Int, value: Int): Unit = js.native
 
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
   //      Methods
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
 
   /** Compares `buf` with `target` and returns a number indicating whether `buf` comes before, after, or is the same as
     * `target` in sort order. Comparison is based on the actual sequence of bytes in each `Buffer`.
@@ -1011,18 +1011,18 @@ class Buffer protected () extends Uint8Array( /* dummy to trick constructor */ -
 @js.native
 @JSGlobal
 object Buffer extends js.Object {
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
   //      Properties
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
 
   /** This is the number of bytes used to determine the size of pre-allocated, internal Buffer instances used for
     * pooling. This value may be modified.
     */
   var poolSize: Int = js.native
 
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
   //      Methods
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
 
   /** Allocates a new `Buffer` of `size` bytes. If `fill` is `undefined`, the `Buffer` will be zero-filled.
     *

app/nodejs-v16/src/main/scala/io/scalajs/nodejs/buffer/package.scala

@@ -16,9 +16,9 @@ package object buffer {
   type BlobSources =
     js.Array[String] | js.Array[ArrayBuffer] | js.Array[TypedArray[_, _]] | js.Array[DataView] | js.Array[Blob]
 
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
   //      Buffer Extensions
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
 
   /** Buffer Extensions
     */

app/nodejs-v16/src/main/scala/io/scalajs/nodejs/cluster/Cluster.scala

@@ -12,17 +12,17 @@ import scala.scalajs.js.annotation.JSImport
   */
 @js.native
 trait Cluster extends IEventEmitter {
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
   //      Constants
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
 
   val SCHED_NONE: Int = js.native
 
   val SCHED_RR: Int = js.native
 
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
   //      Properties
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
 
   /** True if the process is a master. This is determined by the process.env.NODE_UNIQUE_ID. If
     * process.env.NODE_UNIQUE_ID is undefined, then isMaster is true.
@@ -64,9 +64,9 @@ trait Cluster extends IEventEmitter {
     */
   def workers: js.Dictionary[Worker] = js.native
 
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
   //      Methods
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
 
   /** When they are disconnected all internal handles will be closed, allowing the master process to die gracefully if
     * no other event is waiting.

app/nodejs-v16/src/main/scala/io/scalajs/nodejs/cluster/Worker.scala

@@ -11,9 +11,9 @@ import scala.scalajs.js
   */
 @js.native
 trait Worker extends IEventEmitter {
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
   //      Properties
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
 
   /** Set by calling .kill() or .disconnect(). Until then, it is undefined.
     *
@@ -35,9 +35,9 @@ trait Worker extends IEventEmitter {
     */
   def process: ChildProcess = js.native
 
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
   //      Methods
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
 
   /** In a worker, this function will close all servers, wait for the 'close' event on those servers, and then
     * disconnect the IPC channel.

app/nodejs-v16/src/main/scala/io/scalajs/nodejs/cluster/package.scala

@@ -11,9 +11,9 @@ import scala.scalajs.js
 package object cluster {
   type Message = js.Any
 
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
   //      Cluster Events and Extensions
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
 
   /** Cluster Events
     * @param cluster
@@ -92,18 +92,18 @@ package object cluster {
     def onSetup(callback: ClusterSettings => Any): Cluster = cluster.on("setup", callback)
   }
 
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
   //      Worker Events and Extensions
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
 
   /** Worker Events and Extensions
     * @param worker
     *   the given [[Worker worker]]
     */
   implicit final class WorkerExtensions(private val worker: Worker) extends AnyVal {
-    /////////////////////////////////////////////////////////////////////////////////
+    // ///////////////////////////////////////////////////////////////////////////////
     //      Worker Extensions
-    /////////////////////////////////////////////////////////////////////////////////
+    // ///////////////////////////////////////////////////////////////////////////////
 
     /** Send a message to a worker or master, optionally with a handle. In the master this sends a message to a specific
       * worker. It is identical to ChildProcess.send(). In a worker this sends a message to the master. It is identical
@@ -114,9 +114,9 @@ package object cluster {
     @inline
     def sendFuture[T](message: Message): Future[T] = promiseCallback1[T](worker.send(message, _))
 
-    /////////////////////////////////////////////////////////////////////////////////
+    // ///////////////////////////////////////////////////////////////////////////////
     //      Worker Events
-    /////////////////////////////////////////////////////////////////////////////////
+    // ///////////////////////////////////////////////////////////////////////////////
 
     /** Similar to the cluster.on('disconnect') event, but specific to this worker.
       * @param callback

app/nodejs-v16/src/main/scala/io/scalajs/nodejs/crypto/Crypto.scala

@@ -20,9 +20,9 @@ import scala.scalajs.js.|
   */
 @js.native
 trait Crypto extends js.Object {
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
   //      Properties
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
 
   /** The default encoding to use for functions that can take either strings or buffers. The default value is 'buffer',
     * which makes methods default to Buffer objects.
@@ -39,9 +39,9 @@ trait Crypto extends js.Object {
   @deprecated("Please use crypto.setFips() and crypto.getFips() instead.", "Node.js v10.0")
   var fips: Boolean = js.native
 
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
   //      Methods
-  /////////////////////////////////////////////////////////////////////////////////
+  // ///////////////////////////////////////////////////////////////////////////////
 
   /** Creates and returns a Cipher object that uses the given algorithm and password.
     * @param algorithm