Updated initializers to be explicit when possible, and dropped return keywords

dimitribouniol · dimitribouniol · commit 2e1458c697a1 · 2025-02-02T05:15:20.000-08:00
diff --git a/Sources/WebAuthn/Ceremonies/Registration/PublicKeyCredentialCreationOptions.swift b/Sources/WebAuthn/Ceremonies/Registration/PublicKeyCredentialCreationOptions.swift
@@ -93,7 +93,7 @@ extension Array where Element == PublicKeyCredentialParameters {
     /// A list of `PublicKeyCredentialParameters` Swift WebAuthn currently supports.
     public static var supported: [Element] {
         COSEAlgorithmIdentifier.allCases.map {
-            Element.init(type: .publicKey, alg: $0)
+            Element(type: .publicKey, alg: $0)
         }
     }
 }
diff --git a/Sources/WebAuthn/Ceremonies/Shared/COSE/COSEAlgorithmIdentifier.swift b/Sources/WebAuthn/Ceremonies/Shared/COSE/COSEAlgorithmIdentifier.swift
@@ -19,39 +19,36 @@ import Crypto
 /// [https://www.w3.org/TR/webauthn/#biblio-iana-cose-algs-reg], for instance, -7 for "ES256" and -257 for "RS256".
 public enum COSEAlgorithmIdentifier: Int, RawRepresentable, CaseIterable, Encodable, Sendable {
     /// AlgES256 ECDSA with SHA-256
-	case algES256 = -7
-	/// AlgES384 ECDSA with SHA-384
-	case algES384 = -35
-	/// AlgES512 ECDSA with SHA-512
-	case algES512 = -36
+    case algES256 = -7
+    /// AlgES384 ECDSA with SHA-384
+    case algES384 = -35
+    /// AlgES512 ECDSA with SHA-512
+    case algES512 = -36
 
-	// We don't support RSA yet
+    // We don't support RSA yet
 
-	// /// AlgRS1 RSASSA-PKCS1-v1_5 with SHA-1
-	// case algRS1 = -65535
-	// /// AlgRS256 RSASSA-PKCS1-v1_5 with SHA-256
-	// case algRS256 = -257
-	// /// AlgRS384 RSASSA-PKCS1-v1_5 with SHA-384
-	// case algRS384 = -258
-	// /// AlgRS512 RSASSA-PKCS1-v1_5 with SHA-512
-	// case algRS512 = -259
-	// /// AlgPS256 RSASSA-PSS with SHA-256
-	// case algPS256 = -37
-	// /// AlgPS384 RSASSA-PSS with SHA-384
-	// case algPS384 = -38
-	// /// AlgPS512 RSASSA-PSS with SHA-512
-	// case algPS512 = -39
-	// // AlgEdDSA EdDSA
-	// case algEdDSA = -8
+    // /// AlgRS1 RSASSA-PKCS1-v1_5 with SHA-1
+    // case algRS1 = -65535
+    // /// AlgRS256 RSASSA-PKCS1-v1_5 with SHA-256
+    // case algRS256 = -257
+    // /// AlgRS384 RSASSA-PKCS1-v1_5 with SHA-384
+    // case algRS384 = -258
+    // /// AlgRS512 RSASSA-PKCS1-v1_5 with SHA-512
+    // case algRS512 = -259
+    // /// AlgPS256 RSASSA-PSS with SHA-256
+    // case algPS256 = -37
+    // /// AlgPS384 RSASSA-PSS with SHA-384
+    // case algPS384 = -38
+    // /// AlgPS512 RSASSA-PSS with SHA-512
+    // case algPS512 = -39
+    // // AlgEdDSA EdDSA
+    // case algEdDSA = -8
 
-	func hashAndCompare(data: Data, to compareHash: Data) -> Bool {
-		switch self {
-		case .algES256:
-			return SHA256.hash(data: data) == compareHash
-		case .algES384:
-			return SHA384.hash(data: data) == compareHash
-		case .algES512:
-			return SHA512.hash(data: data) == compareHash
-		}
-	}
+    func hashAndCompare(data: Data, to compareHash: Data) -> Bool {
+        switch self {
+        case .algES256: SHA256.hash(data: data) == compareHash
+        case .algES384: SHA384.hash(data: data) == compareHash
+        case .algES512: SHA512.hash(data: data) == compareHash
+        }
+    }
 }
diff --git a/Sources/WebAuthn/Ceremonies/Shared/CredentialPublicKey.swift b/Sources/WebAuthn/Ceremonies/Shared/CredentialPublicKey.swift
@@ -29,12 +29,9 @@ enum CredentialPublicKey: Sendable {
 
     var key: PublicKey {
         switch self {
-        case let .okp(key):
-            return key
-        case let .ec2(key):
-            return key
-        case let .rsa(key):
-            return key
+        case let .okp(key): key
+        case let .ec2(key): key
+        case let .rsa(key): key
         }
     }
 
diff --git a/Sources/WebAuthn/Helpers/Base64Utilities.swift b/Sources/WebAuthn/Helpers/Base64Utilities.swift
@@ -38,7 +38,7 @@ public struct EncodedBase64: ExpressibleByStringLiteral, Codable, Hashable, Equa
 
     /// Return as Base64URL
     public var urlEncoded: URLEncodedBase64 {
-        return .init(
+        URLEncodedBase64(
             self.base64.replacingOccurrences(of: "+", with: "-")
                 .replacingOccurrences(of: "/", with: "_")
                 .replacingOccurrences(of: "=", with: "")
@@ -47,12 +47,12 @@ public struct EncodedBase64: ExpressibleByStringLiteral, Codable, Hashable, Equa
 
     /// Decodes Base64 string and transforms result into `Data`
     public var decoded: Data? {
-        return Data(base64Encoded: self.base64)
+        Data(base64Encoded: self.base64)
     }
 
     /// Returns Base64 data as a String
     public func asString() -> String {
-        return self.base64
+        self.base64
     }
 }
 
@@ -74,12 +74,12 @@ public struct URLEncodedBase64: ExpressibleByStringLiteral, Codable, Hashable, E
         self.init(value)
     }
 
-    public init(from decoder: Decoder) throws {
+    public init(from decoder: any Decoder) throws {
         let container = try decoder.singleValueContainer()
         self.base64URL = try container.decode(String.self)
     }
 
-    public func encode(to encoder: Encoder) throws {
+    public func encode(to encoder: any Encoder) throws {
         var container = encoder.singleValueContainer()
         try container.encode(self.base64URL)
     }
@@ -90,12 +90,12 @@ public struct URLEncodedBase64: ExpressibleByStringLiteral, Codable, Hashable, E
         while result.count % 4 != 0 {
             result = result.appending("=")
         }
-        return .init(result)
+        return EncodedBase64(result)
     }
 
     /// Return Base64URL as a String
     public func asString() -> String {
-        return self.base64URL
+        self.base64URL
     }
 }
 
@@ -110,20 +110,20 @@ extension Array where Element == UInt8 {
     /// Encodes an array of bytes into a base64 string
     /// - Returns: A base64-encoded string
     public func base64EncodedString() -> EncodedBase64 {
-        return .init(Data(bytes: self, count: self.count).base64EncodedString())
+        EncodedBase64(Data(bytes: self, count: self.count).base64EncodedString())
     }
 }
 
 extension Data {
     /// Encodes data into a base64url-encoded string
     /// - Returns: A base64url-encoded string
     public func base64URLEncodedString() -> URLEncodedBase64 {
-        return [UInt8](self).base64URLEncodedString()
+        [UInt8](self).base64URLEncodedString()
     }
 }
 
 extension String {
     func toBase64() -> EncodedBase64 {
-        return .init(Data(self.utf8).base64EncodedString())
+        EncodedBase64(Data(self.utf8).base64EncodedString())
     }
 }
diff --git a/Sources/WebAuthn/Helpers/ChallengeGenerator.swift b/Sources/WebAuthn/Helpers/ChallengeGenerator.swift
@@ -15,6 +15,6 @@ package struct ChallengeGenerator: Sendable {
     var generate: @Sendable () -> [UInt8]
 
     package static var live: Self {
-        .init(generate: { [UInt8].random(count: 32) })
+        ChallengeGenerator(generate: { [UInt8].random(count: 32) })
     }
 }
diff --git a/Sources/WebAuthn/Helpers/UInt8+random.swift b/Sources/WebAuthn/Helpers/UInt8+random.swift
@@ -13,23 +13,23 @@
 
 extension FixedWidthInteger {
     public static func random() -> Self {
-        return Self.random(in: .min ... .max)
+        Self.random(in: .min ... .max)
     }
 
     public static func random<T>(using generator: inout T) -> Self where T: RandomNumberGenerator {
-        return Self.random(in: .min ... .max, using: &generator)
+        Self.random(in: .min ... .max, using: &generator)
     }
 }
 
 extension Array where Element: FixedWidthInteger {
     public static func random(count: Int) -> [Element] {
-        var array: [Element] = .init(repeating: 0, count: count)
+        var array = Array(repeating: Element.zero, count: count)
         (0..<count).forEach { array[$0] = Element.random() }
         return array
     }
 
     public static func random<T>(count: Int, using generator: inout T) -> [Element] where T: RandomNumberGenerator {
-        var array: [Element] = .init(repeating: 0, count: count)
+        var array = Array(repeating: Element.zero, count: count)
         (0..<count).forEach { array[$0] = Element.random(using: &generator) }
         return array
     }
diff --git a/Sources/WebAuthn/WebAuthnManager.swift b/Sources/WebAuthn/WebAuthnManager.swift
@@ -66,7 +66,10 @@ public struct WebAuthnManager: Sendable {
         return PublicKeyCredentialCreationOptions(
             challenge: challenge,
             user: user,
-            relyingParty: .init(id: configuration.relyingPartyID, name: configuration.relyingPartyName),
+            relyingParty: PublicKeyCredentialRelyingPartyEntity(
+                id: configuration.relyingPartyID,
+                name: configuration.relyingPartyName
+            ),
             publicKeyCredentialParameters: publicKeyCredentialParameters,
             timeout: timeout,
             attestation: attestation
diff --git a/Tests/WebAuthnTests/Utils/Hexadecimal.swift b/Tests/WebAuthnTests/Utils/Hexadecimal.swift
@@ -34,7 +34,7 @@ extension String {
 
 extension Data {
     var hexadecimal: String {
-        return map { String(format: "%02x", $0) }
+        self.map { String(format: "%02x", $0) }
             .joined()
     }
 }
diff --git a/Tests/WebAuthnTests/Utils/TestModels/TestAttestationObject.swift b/Tests/WebAuthnTests/Utils/TestModels/TestAttestationObject.swift
@@ -53,7 +53,7 @@ struct TestAttestationObjectBuilder {
     }
 
     func build() -> TestAttestationObject {
-        return wrapped
+        wrapped
     }
 
     func buildBase64URLEncoded() -> URLEncodedBase64 {
diff --git a/Tests/WebAuthnTests/Utils/TestModels/TestCredentialPublicKey.swift b/Tests/WebAuthnTests/Utils/TestModels/TestCredentialPublicKey.swift
@@ -50,12 +50,11 @@ struct TestCredentialPublicKeyBuilder {
     }
 
     func buildAsByteArray() -> [UInt8] {
-        return wrapped.byteArrayRepresentation
+        wrapped.byteArrayRepresentation
     }
 
     func validMock() -> Self {
-        return self
-            .kty(.ellipticKey)
+        self.kty(.ellipticKey)
             .crv(.p256)
             .alg(.algES256)
             .xCoordinate(TestECCKeyPair.publicKeyXCoordinate)
diff --git a/Tests/WebAuthnTests/Utils/TestModels/TestECCKeyPair.swift b/Tests/WebAuthnTests/Utils/TestModels/TestECCKeyPair.swift
@@ -34,8 +34,7 @@ struct TestECCKeyPair {
     static let publicKeyYCoordinate = "6637312afe0ae9a2bec08bcf4611e0e9081e6f120311a8986605d5d3b4b248f8".hexadecimal!
 
     static func signature(data: Data) throws -> P256.Signing.ECDSASignature {
-        let privateKey = try P256.Signing.PrivateKey(pemRepresentation: privateKeyPEM)
-        return try privateKey.signature(for: data)
+        try P256.Signing.PrivateKey(pemRepresentation: privateKeyPEM).signature(for: data)
     }
 
     static var signature: [UInt8] {
diff --git a/Tests/WebAuthnTests/WebAuthnManagerAuthenticationTests.swift b/Tests/WebAuthnTests/WebAuthnManagerAuthenticationTests.swift
@@ -30,11 +30,11 @@ final class WebAuthnManagerAuthenticationTests: XCTestCase {
             relyingPartyName: relyingPartyName,
             relyingPartyOrigin: relyingPartyOrigin
         )
-        webAuthnManager = .init(configuration: configuration, challengeGenerator: .mock(generate: challenge))
+        webAuthnManager = WebAuthnManager(configuration: configuration, challengeGenerator: .mock(generate: challenge))
     }
 
     func testBeginAuthentication() async throws {
-        let allowCredentials: [PublicKeyCredentialDescriptor] = [.init(type: .publicKey, id: [1, 0, 2, 30])]
+        let allowCredentials = [PublicKeyCredentialDescriptor(type: .publicKey, id: [1, 0, 2, 30])]
         let options = try webAuthnManager.beginAuthentication(
             timeout: .seconds(1234),
             allowCredentials: allowCredentials,
diff --git a/Tests/WebAuthnTests/WebAuthnManagerRegistrationTests.swift b/Tests/WebAuthnTests/WebAuthnManagerRegistrationTests.swift
@@ -30,7 +30,7 @@ final class WebAuthnManagerRegistrationTests: XCTestCase {
             relyingPartyName: relyingPartyDisplayName,
             relyingPartyOrigin: relyingPartyOrigin
         )
-        webAuthnManager = .init(configuration: configuration, challengeGenerator: .mock(generate: challenge))
+        webAuthnManager = WebAuthnManager(configuration: configuration, challengeGenerator: .mock(generate: challenge))
     }
 
     // MARK: - beginRegistration()

Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ extension Array where Element == PublicKeyCredentialParameters {`
`93`	`93`	/// A list of `PublicKeyCredentialParameters` Swift WebAuthn currently supports.
`94`	`94`	`public static var supported: [Element] {`
`95`	`95`	`COSEAlgorithmIdentifier.allCases.map {`
`96`		`- Element.init(type: .publicKey, alg: $0)`
	`96`	`+ Element(type: .publicKey, alg: $0)`
`97`	`97`	`}`
`98`	`98`	`}`
`99`	`99`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,12 +29,9 @@ enum CredentialPublicKey: Sendable {`
`29`	`29`
`30`	`30`	`var key: PublicKey {`
`31`	`31`	`switch self {`
`32`		`- case let .okp(key):`
`33`		`- return key`
`34`		`- case let .ec2(key):`
`35`		`- return key`
`36`		`- case let .rsa(key):`
`37`		`- return key`
	`32`	`+ case let .okp(key): key`
	`33`	`+ case let .ec2(key): key`
	`34`	`+ case let .rsa(key): key`
`38`	`35`	`}`
`39`	`36`	`}`
`40`	`37`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public struct EncodedBase64: ExpressibleByStringLiteral, Codable, Hashable, Equa`
`38`	`38`
`39`	`39`	`/// Return as Base64URL`
`40`	`40`	`public var urlEncoded: URLEncodedBase64 {`
`41`		`- return .init(`
	`41`	`+ URLEncodedBase64(`
`42`	`42`	`self.base64.replacingOccurrences(of: "+", with: "-")`
`43`	`43`	`.replacingOccurrences(of: "/", with: "_")`
`44`	`44`	`.replacingOccurrences(of: "=", with: "")`
`@@ -47,12 +47,12 @@ public struct EncodedBase64: ExpressibleByStringLiteral, Codable, Hashable, Equa`
`47`	`47`
`48`	`48`	/// Decodes Base64 string and transforms result into `Data`
`49`	`49`	`public var decoded: Data? {`
`50`		`- return Data(base64Encoded: self.base64)`
	`50`	`+ Data(base64Encoded: self.base64)`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`/// Returns Base64 data as a String`
`54`	`54`	`public func asString() -> String {`
`55`		`- return self.base64`
	`55`	`+ self.base64`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`@@ -74,12 +74,12 @@ public struct URLEncodedBase64: ExpressibleByStringLiteral, Codable, Hashable, E`
`74`	`74`	`self.init(value)`
`75`	`75`	`}`
`76`	`76`
`77`		`- public init(from decoder: Decoder) throws {`
	`77`	`+ public init(from decoder: any Decoder) throws {`
`78`	`78`	`let container = try decoder.singleValueContainer()`
`79`	`79`	`self.base64URL = try container.decode(String.self)`
`80`	`80`	`}`
`81`	`81`
`82`		`- public func encode(to encoder: Encoder) throws {`
	`82`	`+ public func encode(to encoder: any Encoder) throws {`
`83`	`83`	`var container = encoder.singleValueContainer()`
`84`	`84`	`try container.encode(self.base64URL)`
`85`	`85`	`}`
`@@ -90,12 +90,12 @@ public struct URLEncodedBase64: ExpressibleByStringLiteral, Codable, Hashable, E`
`90`	`90`	`while result.count % 4 != 0 {`
`91`	`91`	`result = result.appending("=")`
`92`	`92`	`}`
`93`		`- return .init(result)`
	`93`	`+ return EncodedBase64(result)`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`/// Return Base64URL as a String`
`97`	`97`	`public func asString() -> String {`
`98`		`- return self.base64URL`
	`98`	`+ self.base64URL`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`
`@@ -110,20 +110,20 @@ extension Array where Element == UInt8 {`
`110`	`110`	`/// Encodes an array of bytes into a base64 string`
`111`	`111`	`/// - Returns: A base64-encoded string`
`112`	`112`	`public func base64EncodedString() -> EncodedBase64 {`
`113`		`- return .init(Data(bytes: self, count: self.count).base64EncodedString())`
	`113`	`+ EncodedBase64(Data(bytes: self, count: self.count).base64EncodedString())`
`114`	`114`	`}`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`extension Data {`
`118`	`118`	`/// Encodes data into a base64url-encoded string`
`119`	`119`	`/// - Returns: A base64url-encoded string`
`120`	`120`	`public func base64URLEncodedString() -> URLEncodedBase64 {`
`121`		`- return [UInt8](self).base64URLEncodedString()`
	`121`	`+ [UInt8](self).base64URLEncodedString()`
`122`	`122`	`}`
`123`	`123`	`}`
`124`	`124`
`125`	`125`	`extension String {`
`126`	`126`	`func toBase64() -> EncodedBase64 {`
`127`		`- return .init(Data(self.utf8).base64EncodedString())`
	`127`	`+ EncodedBase64(Data(self.utf8).base64EncodedString())`
`128`	`128`	`}`
`129`	`129`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,6 @@ package struct ChallengeGenerator: Sendable {`
`15`	`15`	`var generate: @Sendable () -> [UInt8]`
`16`	`16`
`17`	`17`	`package static var live: Self {`
`18`		`- .init(generate: { [UInt8].random(count: 32) })`
	`18`	`+ ChallengeGenerator(generate: { [UInt8].random(count: 32) })`
`19`	`19`	`}`
`20`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,23 +13,23 @@`
`13`	`13`
`14`	`14`	`extension FixedWidthInteger {`
`15`	`15`	`public static func random() -> Self {`
`16`		`- return Self.random(in: .min ... .max)`
	`16`	`+ Self.random(in: .min ... .max)`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`public static func random<T>(using generator: inout T) -> Self where T: RandomNumberGenerator {`
`20`		`- return Self.random(in: .min ... .max, using: &generator)`
	`20`	`+ Self.random(in: .min ... .max, using: &generator)`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`extension Array where Element: FixedWidthInteger {`
`25`	`25`	`public static func random(count: Int) -> [Element] {`
`26`		`- var array: [Element] = .init(repeating: 0, count: count)`
	`26`	`+ var array = Array(repeating: Element.zero, count: count)`
`27`	`27`	`(0..<count).forEach { array[$0] = Element.random() }`
`28`	`28`	`return array`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`public static func random<T>(count: Int, using generator: inout T) -> [Element] where T: RandomNumberGenerator {`
`32`		`- var array: [Element] = .init(repeating: 0, count: count)`
	`32`	`+ var array = Array(repeating: Element.zero, count: count)`
`33`	`33`	`(0..<count).forEach { array[$0] = Element.random(using: &generator) }`
`34`	`34`	`return array`
`35`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ extension String {`
`34`	`34`
`35`	`35`	`extension Data {`
`36`	`36`	`var hexadecimal: String {`
`37`		`- return map { String(format: "%02x", $0) }`
	`37`	`+ self.map { String(format: "%02x", $0) }`
`38`	`38`	`.joined()`
`39`	`39`	`}`
`40`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ struct TestAttestationObjectBuilder {`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`func build() -> TestAttestationObject {`
`56`		`- return wrapped`
	`56`	`+ wrapped`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`func buildBase64URLEncoded() -> URLEncodedBase64 {`
Original file line number	Diff line number	Diff line change
`@@ -50,12 +50,11 @@ struct TestCredentialPublicKeyBuilder {`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`func buildAsByteArray() -> [UInt8] {`
`53`		`- return wrapped.byteArrayRepresentation`
	`53`	`+ wrapped.byteArrayRepresentation`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`func validMock() -> Self {`
`57`		`- return self`
`58`		`- .kty(.ellipticKey)`
	`57`	`+ self.kty(.ellipticKey)`
`59`	`58`	`.crv(.p256)`
`60`	`59`	`.alg(.algES256)`
`61`	`60`	`.xCoordinate(TestECCKeyPair.publicKeyXCoordinate)`
Original file line number	Diff line number	Diff line change
`@@ -34,8 +34,7 @@ struct TestECCKeyPair {`
`34`	`34`	`static let publicKeyYCoordinate = "6637312afe0ae9a2bec08bcf4611e0e9081e6f120311a8986605d5d3b4b248f8".hexadecimal!`
`35`	`35`
`36`	`36`	`static func signature(data: Data) throws -> P256.Signing.ECDSASignature {`
`37`		`- let privateKey = try P256.Signing.PrivateKey(pemRepresentation: privateKeyPEM)`
`38`		`- return try privateKey.signature(for: data)`
	`37`	`+ try P256.Signing.PrivateKey(pemRepresentation: privateKeyPEM).signature(for: data)`
`39`	`38`	`}`
`40`	`39`
`41`	`40`	`static var signature: [UInt8] {`
Original file line number	Diff line number	Diff line change
`@@ -30,11 +30,11 @@ final class WebAuthnManagerAuthenticationTests: XCTestCase {`
`30`	`30`	`relyingPartyName: relyingPartyName,`
`31`	`31`	`relyingPartyOrigin: relyingPartyOrigin`
`32`	`32`	`)`
`33`		`- webAuthnManager = .init(configuration: configuration, challengeGenerator: .mock(generate: challenge))`
	`33`	`+ webAuthnManager = WebAuthnManager(configuration: configuration, challengeGenerator: .mock(generate: challenge))`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`func testBeginAuthentication() async throws {`
`37`		`- let allowCredentials: [PublicKeyCredentialDescriptor] = [.init(type: .publicKey, id: [1, 0, 2, 30])]`
	`37`	`+ let allowCredentials = [PublicKeyCredentialDescriptor(type: .publicKey, id: [1, 0, 2, 30])]`
`38`	`38`	`let options = try webAuthnManager.beginAuthentication(`
`39`	`39`	`timeout: .seconds(1234),`
`40`	`40`	`allowCredentials: allowCredentials,`