Fix trimWhitespace configuration consistency across all decode paths

g-cqd · claude · g-cqd · commit bf7d898b44a8 · 2025-12-28T18:50:35.000+01:00
- Apply trimWhitespace in getValue() centrally for CSVKeyedDecodingContainer - Add trimmedValue computed property to CSVSingleValueContainer - Update all numeric, boolean, date, and string decoders to use trimmed values - Fix header trimming inconsistency between main and parallel decode paths - Document UTF-8 encoding limitation in configuration - Add comprehensive tests for whitespace trimming with numeric fields - Update CHANGELOG and GettingStarted documentation Previously, trimWhitespace only worked for streaming parser and parallel header extraction. Numeric fields like Int and Double would fail to parse when whitespace was present (e.g., " 2024 "). Boolean decoding always trimmed regardless of configuration. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -67,6 +67,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Unterminated quote detection with line/column information
 - Quoted fields containing CRLF now parse correctly
 - Empty quoted fields handled properly
+- `trimWhitespace` configuration now consistently applied to all field types
+  - Previously, numeric fields (Int, Double, etc.) would fail parsing with whitespace
+  - Boolean decoding now respects configuration instead of always trimming
+  - Header extraction now applies trimWhitespace consistently across all decode paths
 
 ## [1.1.0] - 2025-12-27
 
diff --git a/Sources/CSVCoder/CSVCoder.docc/GettingStarted.md b/Sources/CSVCoder/CSVCoder.docc/GettingStarted.md
@@ -97,6 +97,19 @@ let config = CSVDecoder.Configuration(
 )
 ```
 
+### Whitespace Handling
+
+By default, CSVCoder trims leading and trailing whitespace from all field values:
+
+```swift
+// CSV: " Toyota , 2024 " becomes "Toyota" and 2024
+let decoder = CSVDecoder()  // trimWhitespace defaults to true
+
+// Preserve whitespace if needed
+let config = CSVDecoder.Configuration(trimWhitespace: false)
+let decoder = CSVDecoder(configuration: config)
+```
+
 ## Topics
 
 ### Next Steps
diff --git a/Sources/CSVCoder/Core/CSVDecoder.swift b/Sources/CSVCoder/Core/CSVDecoder.swift
@@ -96,6 +96,10 @@ public final class CSVDecoder: Sendable {
         public var hasHeaders: Bool
 
         /// The encoding to use when reading data. Default is UTF-8.
+        ///
+        /// - Note: The current implementation optimizes for UTF-8 with zero-copy parsing.
+        ///   Non-UTF-8 data should be converted to String using the appropriate encoding
+        ///   before passing to `decode(from:)`. This property is reserved for future use.
         public var encoding: String.Encoding
 
         /// Whether to trim whitespace from field values. Default is true.
@@ -388,7 +392,8 @@ public final class CSVDecoder: Sendable {
             rawHeaders.reserveCapacity(firstRow.count)
             for i in 0..<firstRow.count {
                 if let s = firstRow.string(at: i) {
-                    rawHeaders.append(s)
+                    // Apply trimWhitespace to headers for consistency with parallel decoding
+                    rawHeaders.append(configuration.trimWhitespace ? s.trimmingCharacters(in: .whitespaces) : s)
                 } else {
                     rawHeaders.append("column\(i)")
                 }
diff --git a/Sources/CSVCoder/Decoder/CSVRowDecoder.swift b/Sources/CSVCoder/Decoder/CSVRowDecoder.swift
@@ -98,6 +98,7 @@ struct CSVKeyedDecodingContainer<Key: CodingKey>: KeyedDecodingContainerProtocol
     }
 
     private func getValue(for key: Key) throws -> String {
+        let rawValue: String
         switch source {
         case .dictionary(let row):
             guard let value = row[key.stringValue] else {
@@ -106,7 +107,7 @@ struct CSVKeyedDecodingContainer<Key: CodingKey>: KeyedDecodingContainerProtocol
                     location: makeLocation(for: key, includeAvailableKeys: true)
                 )
             }
-            return value
+            rawValue = value
 
         case .view(let view, let headerMap):
             guard let index = headerMap[key.stringValue], index < view.count else {
@@ -122,8 +123,11 @@ struct CSVKeyedDecodingContainer<Key: CodingKey>: KeyedDecodingContainerProtocol
                     location: makeLocation(for: key, includeAvailableKeys: true)
                 )
             }
-            return value
+            rawValue = value
         }
+
+        // Apply trimWhitespace configuration
+        return configuration.trimWhitespace ? rawValue.trimmingCharacters(in: .whitespaces) : rawValue
     }
 
     /// Returns the string value for a key, or nil if not present.
@@ -166,7 +170,7 @@ struct CSVKeyedDecodingContainer<Key: CodingKey>: KeyedDecodingContainerProtocol
     }
 
     func decode(_ type: Bool.Type, forKey key: Key) throws -> Bool {
-        let value = try getValue(for: key).lowercased().trimmingCharacters(in: .whitespaces)
+        let value = try getValue(for: key).lowercased()
         let location = makeLocation(for: key)
 
         switch configuration.boolDecodingStrategy {
diff --git a/Sources/CSVCoder/Decoder/CSVSingleValueDecoder.swift b/Sources/CSVCoder/Decoder/CSVSingleValueDecoder.swift
@@ -33,6 +33,11 @@ struct CSVSingleValueContainer: SingleValueDecodingContainer {
     let configuration: CSVDecoder.Configuration
     let codingPath: [CodingKey]
 
+    /// The value with trimWhitespace applied based on configuration.
+    private var trimmedValue: String {
+        configuration.trimWhitespace ? value.trimmingCharacters(in: .whitespaces) : value
+    }
+
     private var location: CSVLocation {
         CSVLocation(codingPath: codingPath)
     }
@@ -42,7 +47,7 @@ struct CSVSingleValueContainer: SingleValueDecodingContainer {
     }
 
     func decode(_ type: Bool.Type) throws -> Bool {
-        let lower = value.lowercased().trimmingCharacters(in: .whitespaces)
+        let lower = trimmedValue.lowercased()
 
         switch configuration.boolDecodingStrategy {
         case .standard:
@@ -76,19 +81,19 @@ struct CSVSingleValueContainer: SingleValueDecodingContainer {
     }
 
     func decode(_ type: String.Type) throws -> String {
-        value
+        trimmedValue
     }
 
     func decode(_ type: Double.Type) throws -> Double {
-        guard let result = parseDouble(value) else {
-            throw CSVDecodingError.typeMismatch(expected: "Double", actual: value, location: location)
+        guard let result = parseDouble(trimmedValue) else {
+            throw CSVDecodingError.typeMismatch(expected: "Double", actual: trimmedValue, location: location)
         }
         return result
     }
 
     func decode(_ type: Float.Type) throws -> Float {
-        guard let result = parseDouble(value) else {
-            throw CSVDecodingError.typeMismatch(expected: "Float", actual: value, location: location)
+        guard let result = parseDouble(trimmedValue) else {
+            throw CSVDecodingError.typeMismatch(expected: "Float", actual: trimmedValue, location: location)
         }
         return Float(result)
     }
@@ -221,71 +226,71 @@ struct CSVSingleValueContainer: SingleValueDecodingContainer {
     }
 
     func decode(_ type: Int.Type) throws -> Int {
-        guard let result = Int(value) else {
-            throw CSVDecodingError.typeMismatch(expected: "Int", actual: value, location: location)
+        guard let result = Int(trimmedValue) else {
+            throw CSVDecodingError.typeMismatch(expected: "Int", actual: trimmedValue, location: location)
         }
         return result
     }
 
     func decode(_ type: Int8.Type) throws -> Int8 {
-        guard let result = Int8(value) else {
-            throw CSVDecodingError.typeMismatch(expected: "Int8", actual: value, location: location)
+        guard let result = Int8(trimmedValue) else {
+            throw CSVDecodingError.typeMismatch(expected: "Int8", actual: trimmedValue, location: location)
         }
         return result
     }
 
     func decode(_ type: Int16.Type) throws -> Int16 {
-        guard let result = Int16(value) else {
-            throw CSVDecodingError.typeMismatch(expected: "Int16", actual: value, location: location)
+        guard let result = Int16(trimmedValue) else {
+            throw CSVDecodingError.typeMismatch(expected: "Int16", actual: trimmedValue, location: location)
         }
         return result
     }
 
     func decode(_ type: Int32.Type) throws -> Int32 {
-        guard let result = Int32(value) else {
-            throw CSVDecodingError.typeMismatch(expected: "Int32", actual: value, location: location)
+        guard let result = Int32(trimmedValue) else {
+            throw CSVDecodingError.typeMismatch(expected: "Int32", actual: trimmedValue, location: location)
         }
         return result
     }
 
     func decode(_ type: Int64.Type) throws -> Int64 {
-        guard let result = Int64(value) else {
-            throw CSVDecodingError.typeMismatch(expected: "Int64", actual: value, location: location)
+        guard let result = Int64(trimmedValue) else {
+            throw CSVDecodingError.typeMismatch(expected: "Int64", actual: trimmedValue, location: location)
         }
         return result
     }
 
     func decode(_ type: UInt.Type) throws -> UInt {
-        guard let result = UInt(value) else {
-            throw CSVDecodingError.typeMismatch(expected: "UInt", actual: value, location: location)
+        guard let result = UInt(trimmedValue) else {
+            throw CSVDecodingError.typeMismatch(expected: "UInt", actual: trimmedValue, location: location)
         }
         return result
     }
 
     func decode(_ type: UInt8.Type) throws -> UInt8 {
-        guard let result = UInt8(value) else {
-            throw CSVDecodingError.typeMismatch(expected: "UInt8", actual: value, location: location)
+        guard let result = UInt8(trimmedValue) else {
+            throw CSVDecodingError.typeMismatch(expected: "UInt8", actual: trimmedValue, location: location)
         }
         return result
     }
 
     func decode(_ type: UInt16.Type) throws -> UInt16 {
-        guard let result = UInt16(value) else {
-            throw CSVDecodingError.typeMismatch(expected: "UInt16", actual: value, location: location)
+        guard let result = UInt16(trimmedValue) else {
+            throw CSVDecodingError.typeMismatch(expected: "UInt16", actual: trimmedValue, location: location)
         }
         return result
     }
 
     func decode(_ type: UInt32.Type) throws -> UInt32 {
-        guard let result = UInt32(value) else {
-            throw CSVDecodingError.typeMismatch(expected: "UInt32", actual: value, location: location)
+        guard let result = UInt32(trimmedValue) else {
+            throw CSVDecodingError.typeMismatch(expected: "UInt32", actual: trimmedValue, location: location)
         }
         return result
     }
 
     func decode(_ type: UInt64.Type) throws -> UInt64 {
-        guard let result = UInt64(value) else {
-            throw CSVDecodingError.typeMismatch(expected: "UInt64", actual: value, location: location)
+        guard let result = UInt64(trimmedValue) else {
+            throw CSVDecodingError.typeMismatch(expected: "UInt64", actual: trimmedValue, location: location)
         }
         return result
     }
@@ -298,24 +303,24 @@ struct CSVSingleValueContainer: SingleValueDecodingContainer {
 
         // Handle Decimal specially
         if type == Decimal.self {
-            guard let decimal = parseDecimal(value) else {
-                throw CSVDecodingError.typeMismatch(expected: "Decimal", actual: value, location: location)
+            guard let decimal = parseDecimal(trimmedValue) else {
+                throw CSVDecodingError.typeMismatch(expected: "Decimal", actual: trimmedValue, location: location)
             }
             return decimal as! T
         }
 
         // Handle UUID specially
         if type == UUID.self {
-            guard let uuid = UUID(uuidString: value) else {
-                throw CSVDecodingError.typeMismatch(expected: "UUID", actual: value, location: location)
+            guard let uuid = UUID(uuidString: trimmedValue) else {
+                throw CSVDecodingError.typeMismatch(expected: "UUID", actual: trimmedValue, location: location)
             }
             return uuid as! T
         }
 
         // Handle URL specially
         if type == URL.self {
-            guard let url = URL(string: value) else {
-                throw CSVDecodingError.typeMismatch(expected: "URL", actual: value, location: location)
+            guard let url = URL(string: trimmedValue) else {
+                throw CSVDecodingError.typeMismatch(expected: "URL", actual: trimmedValue, location: location)
             }
             return url as! T
         }
@@ -325,26 +330,27 @@ struct CSVSingleValueContainer: SingleValueDecodingContainer {
     }
 
     private func decodeDate() throws -> Date {
+        let dateValue = trimmedValue
         switch configuration.dateDecodingStrategy {
         case .deferredToDate:
-            throw CSVDecodingError.typeMismatch(expected: "Date (use a date strategy)", actual: value, location: location)
+            throw CSVDecodingError.typeMismatch(expected: "Date (use a date strategy)", actual: dateValue, location: location)
 
         case .secondsSince1970:
-            guard let seconds = Double(value) else {
-                throw CSVDecodingError.typeMismatch(expected: "Unix timestamp", actual: value, location: location)
+            guard let seconds = Double(dateValue) else {
+                throw CSVDecodingError.typeMismatch(expected: "Unix timestamp", actual: dateValue, location: location)
             }
             return Date(timeIntervalSince1970: seconds)
 
         case .millisecondsSince1970:
-            guard let milliseconds = Double(value) else {
-                throw CSVDecodingError.typeMismatch(expected: "Unix timestamp (ms)", actual: value, location: location)
+            guard let milliseconds = Double(dateValue) else {
+                throw CSVDecodingError.typeMismatch(expected: "Unix timestamp (ms)", actual: dateValue, location: location)
             }
             return Date(timeIntervalSince1970: milliseconds / 1000)
 
         case .iso8601:
             let formatter = ISO8601DateFormatter()
-            guard let date = formatter.date(from: value) else {
-                throw CSVDecodingError.typeMismatch(expected: "ISO8601 date", actual: value, location: location)
+            guard let date = formatter.date(from: dateValue) else {
+                throw CSVDecodingError.typeMismatch(expected: "ISO8601 date", actual: dateValue, location: location)
             }
             return date
 
@@ -353,40 +359,40 @@ struct CSVSingleValueContainer: SingleValueDecodingContainer {
             formatter.dateFormat = format
             formatter.locale = Locale.autoupdatingCurrent
             formatter.timeZone = TimeZone.autoupdatingCurrent
-            guard let date = formatter.date(from: value) else {
-                throw CSVDecodingError.typeMismatch(expected: "Date with format \(format)", actual: value, location: location)
+            guard let date = formatter.date(from: dateValue) else {
+                throw CSVDecodingError.typeMismatch(expected: "Date with format \(format)", actual: dateValue, location: location)
             }
             return date
 
         case .custom(let closure):
-            return try closure(value)
+            return try closure(dateValue)
 
         case .flexible:
-            guard let date = parseFlexibleDate(value, hint: nil) else {
-                throw CSVDecodingError.typeMismatch(expected: "Date (no matching format found)", actual: value, location: location)
+            guard let date = parseFlexibleDate(dateValue, hint: nil) else {
+                throw CSVDecodingError.typeMismatch(expected: "Date (no matching format found)", actual: dateValue, location: location)
             }
             return date
 
         case .flexibleWithHint(let preferred):
-            guard let date = parseFlexibleDate(value, hint: preferred) else {
-                throw CSVDecodingError.typeMismatch(expected: "Date (no matching format found)", actual: value, location: location)
+            guard let date = parseFlexibleDate(dateValue, hint: preferred) else {
+                throw CSVDecodingError.typeMismatch(expected: "Date (no matching format found)", actual: dateValue, location: location)
             }
             return date
 
         case .localeAware(let locale, let style):
             if #available(iOS 15.0, macOS 12.0, tvOS 15.0, watchOS 8.0, *) {
-                if let date = LocaleUtilities.parseDate(value, locale: locale, style: style) {
+                if let date = LocaleUtilities.parseDate(dateValue, locale: locale, style: style) {
                     return date
                 }
                 // Fall back to flexible parsing if locale-aware fails
-                if let date = parseFlexibleDate(value, hint: nil) {
+                if let date = parseFlexibleDate(dateValue, hint: nil) {
                     return date
                 }
-                throw CSVDecodingError.typeMismatch(expected: "Date (locale-aware)", actual: value, location: location)
+                throw CSVDecodingError.typeMismatch(expected: "Date (locale-aware)", actual: dateValue, location: location)
             } else {
                 // Pre-iOS 15: use flexible parsing
-                guard let date = parseFlexibleDate(value, hint: nil) else {
-                    throw CSVDecodingError.typeMismatch(expected: "Date", actual: value, location: location)
+                guard let date = parseFlexibleDate(dateValue, hint: nil) else {
+                    throw CSVDecodingError.typeMismatch(expected: "Date", actual: dateValue, location: location)
                 }
                 return date
             }
diff --git a/Tests/CSVCoderTests/CSVDecoderRFC4180Tests.swift b/Tests/CSVCoderTests/CSVDecoderRFC4180Tests.swift

Original file line number	Diff line number	Diff line change
`@@ -98,6 +98,7 @@ struct CSVKeyedDecodingContainer<Key: CodingKey>: KeyedDecodingContainerProtocol`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`private func getValue(for key: Key) throws -> String {`
	`101`	`+ let rawValue: String`
`101`	`102`	`switch source {`
`102`	`103`	`case .dictionary(let row):`
`103`	`104`	`guard let value = row[key.stringValue] else {`
`@@ -106,7 +107,7 @@ struct CSVKeyedDecodingContainer<Key: CodingKey>: KeyedDecodingContainerProtocol`
`106`	`107`	`location: makeLocation(for: key, includeAvailableKeys: true)`
`107`	`108`	`)`
`108`	`109`	`}`
`109`		`- return value`
	`110`	`+ rawValue = value`
`110`	`111`
`111`	`112`	`case .view(let view, let headerMap):`
`112`	`113`	`guard let index = headerMap[key.stringValue], index < view.count else {`
`@@ -122,8 +123,11 @@ struct CSVKeyedDecodingContainer<Key: CodingKey>: KeyedDecodingContainerProtocol`
`122`	`123`	`location: makeLocation(for: key, includeAvailableKeys: true)`
`123`	`124`	`)`
`124`	`125`	`}`
`125`		`- return value`
	`126`	`+ rawValue = value`
`126`	`127`	`}`
	`128`	`+`
	`129`	`+ // Apply trimWhitespace configuration`
	`130`	`+ return configuration.trimWhitespace ? rawValue.trimmingCharacters(in: .whitespaces) : rawValue`
`127`	`131`	`}`
`128`	`132`
`129`	`133`	`/// Returns the string value for a key, or nil if not present.`
`@@ -166,7 +170,7 @@ struct CSVKeyedDecodingContainer<Key: CodingKey>: KeyedDecodingContainerProtocol`
`166`	`170`	`}`
`167`	`171`
`168`	`172`	`func decode(_ type: Bool.Type, forKey key: Key) throws -> Bool {`
`169`		`- let value = try getValue(for: key).lowercased().trimmingCharacters(in: .whitespaces)`
	`173`	`+ let value = try getValue(for: key).lowercased()`
`170`	`174`	`let location = makeLocation(for: key)`
`171`	`175`
`172`	`176`	`switch configuration.boolDecodingStrategy {`
Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,11 @@ struct CSVSingleValueContainer: SingleValueDecodingContainer {`
`33`	`33`	`let configuration: CSVDecoder.Configuration`
`34`	`34`	`let codingPath: [CodingKey]`
`35`	`35`
	`36`	`+ /// The value with trimWhitespace applied based on configuration.`
	`37`	`+ private var trimmedValue: String {`
	`38`	`+ configuration.trimWhitespace ? value.trimmingCharacters(in: .whitespaces) : value`
	`39`	`+ }`
	`40`	`+`
`36`	`41`	`private var location: CSVLocation {`
`37`	`42`	`CSVLocation(codingPath: codingPath)`
`38`	`43`	`}`
`@@ -42,7 +47,7 @@ struct CSVSingleValueContainer: SingleValueDecodingContainer {`
`42`	`47`	`}`
`43`	`48`
`44`	`49`	`func decode(_ type: Bool.Type) throws -> Bool {`
`45`		`- let lower = value.lowercased().trimmingCharacters(in: .whitespaces)`
	`50`	`+ let lower = trimmedValue.lowercased()`
`46`	`51`
`47`	`52`	`switch configuration.boolDecodingStrategy {`
`48`	`53`	`case .standard:`
`@@ -76,19 +81,19 @@ struct CSVSingleValueContainer: SingleValueDecodingContainer {`
`76`	`81`	`}`
`77`	`82`
`78`	`83`	`func decode(_ type: String.Type) throws -> String {`
`79`		`- value`
	`84`	`+ trimmedValue`
`80`	`85`	`}`
`81`	`86`
`82`	`87`	`func decode(_ type: Double.Type) throws -> Double {`
`83`		`- guard let result = parseDouble(value) else {`
`84`		`- throw CSVDecodingError.typeMismatch(expected: "Double", actual: value, location: location)`
	`88`	`+ guard let result = parseDouble(trimmedValue) else {`
	`89`	`+ throw CSVDecodingError.typeMismatch(expected: "Double", actual: trimmedValue, location: location)`
`85`	`90`	`}`
`86`	`91`	`return result`
`87`	`92`	`}`
`88`	`93`
`89`	`94`	`func decode(_ type: Float.Type) throws -> Float {`
`90`		`- guard let result = parseDouble(value) else {`
`91`		`- throw CSVDecodingError.typeMismatch(expected: "Float", actual: value, location: location)`
	`95`	`+ guard let result = parseDouble(trimmedValue) else {`
	`96`	`+ throw CSVDecodingError.typeMismatch(expected: "Float", actual: trimmedValue, location: location)`
`92`	`97`	`}`
`93`	`98`	`return Float(result)`
`94`	`99`	`}`
`@@ -221,71 +226,71 @@ struct CSVSingleValueContainer: SingleValueDecodingContainer {`
`221`	`226`	`}`
`222`	`227`
`223`	`228`	`func decode(_ type: Int.Type) throws -> Int {`
`224`		`- guard let result = Int(value) else {`
`225`		`- throw CSVDecodingError.typeMismatch(expected: "Int", actual: value, location: location)`
	`229`	`+ guard let result = Int(trimmedValue) else {`
	`230`	`+ throw CSVDecodingError.typeMismatch(expected: "Int", actual: trimmedValue, location: location)`
`226`	`231`	`}`
`227`	`232`	`return result`
`228`	`233`	`}`
`229`	`234`
`230`	`235`	`func decode(_ type: Int8.Type) throws -> Int8 {`
`231`		`- guard let result = Int8(value) else {`
`232`		`- throw CSVDecodingError.typeMismatch(expected: "Int8", actual: value, location: location)`
	`236`	`+ guard let result = Int8(trimmedValue) else {`
	`237`	`+ throw CSVDecodingError.typeMismatch(expected: "Int8", actual: trimmedValue, location: location)`
`233`	`238`	`}`
`234`	`239`	`return result`
`235`	`240`	`}`
`236`	`241`
`237`	`242`	`func decode(_ type: Int16.Type) throws -> Int16 {`
`238`		`- guard let result = Int16(value) else {`
`239`		`- throw CSVDecodingError.typeMismatch(expected: "Int16", actual: value, location: location)`
	`243`	`+ guard let result = Int16(trimmedValue) else {`
	`244`	`+ throw CSVDecodingError.typeMismatch(expected: "Int16", actual: trimmedValue, location: location)`
`240`	`245`	`}`
`241`	`246`	`return result`
`242`	`247`	`}`
`243`	`248`
`244`	`249`	`func decode(_ type: Int32.Type) throws -> Int32 {`
`245`		`- guard let result = Int32(value) else {`
`246`		`- throw CSVDecodingError.typeMismatch(expected: "Int32", actual: value, location: location)`
	`250`	`+ guard let result = Int32(trimmedValue) else {`
	`251`	`+ throw CSVDecodingError.typeMismatch(expected: "Int32", actual: trimmedValue, location: location)`
`247`	`252`	`}`
`248`	`253`	`return result`
`249`	`254`	`}`
`250`	`255`
`251`	`256`	`func decode(_ type: Int64.Type) throws -> Int64 {`
`252`		`- guard let result = Int64(value) else {`
`253`		`- throw CSVDecodingError.typeMismatch(expected: "Int64", actual: value, location: location)`
	`257`	`+ guard let result = Int64(trimmedValue) else {`
	`258`	`+ throw CSVDecodingError.typeMismatch(expected: "Int64", actual: trimmedValue, location: location)`
`254`	`259`	`}`
`255`	`260`	`return result`
`256`	`261`	`}`
`257`	`262`
`258`	`263`	`func decode(_ type: UInt.Type) throws -> UInt {`
`259`		`- guard let result = UInt(value) else {`
`260`		`- throw CSVDecodingError.typeMismatch(expected: "UInt", actual: value, location: location)`
	`264`	`+ guard let result = UInt(trimmedValue) else {`
	`265`	`+ throw CSVDecodingError.typeMismatch(expected: "UInt", actual: trimmedValue, location: location)`
`261`	`266`	`}`
`262`	`267`	`return result`
`263`	`268`	`}`
`264`	`269`
`265`	`270`	`func decode(_ type: UInt8.Type) throws -> UInt8 {`
`266`		`- guard let result = UInt8(value) else {`
`267`		`- throw CSVDecodingError.typeMismatch(expected: "UInt8", actual: value, location: location)`
	`271`	`+ guard let result = UInt8(trimmedValue) else {`
	`272`	`+ throw CSVDecodingError.typeMismatch(expected: "UInt8", actual: trimmedValue, location: location)`
`268`	`273`	`}`
`269`	`274`	`return result`
`270`	`275`	`}`
`271`	`276`
`272`	`277`	`func decode(_ type: UInt16.Type) throws -> UInt16 {`
`273`		`- guard let result = UInt16(value) else {`
`274`		`- throw CSVDecodingError.typeMismatch(expected: "UInt16", actual: value, location: location)`
	`278`	`+ guard let result = UInt16(trimmedValue) else {`
	`279`	`+ throw CSVDecodingError.typeMismatch(expected: "UInt16", actual: trimmedValue, location: location)`
`275`	`280`	`}`
`276`	`281`	`return result`
`277`	`282`	`}`
`278`	`283`
`279`	`284`	`func decode(_ type: UInt32.Type) throws -> UInt32 {`
`280`		`- guard let result = UInt32(value) else {`
`281`		`- throw CSVDecodingError.typeMismatch(expected: "UInt32", actual: value, location: location)`
	`285`	`+ guard let result = UInt32(trimmedValue) else {`
	`286`	`+ throw CSVDecodingError.typeMismatch(expected: "UInt32", actual: trimmedValue, location: location)`
`282`	`287`	`}`
`283`	`288`	`return result`
`284`	`289`	`}`
`285`	`290`
`286`	`291`	`func decode(_ type: UInt64.Type) throws -> UInt64 {`
`287`		`- guard let result = UInt64(value) else {`
`288`		`- throw CSVDecodingError.typeMismatch(expected: "UInt64", actual: value, location: location)`
	`292`	`+ guard let result = UInt64(trimmedValue) else {`
	`293`	`+ throw CSVDecodingError.typeMismatch(expected: "UInt64", actual: trimmedValue, location: location)`
`289`	`294`	`}`
`290`	`295`	`return result`
`291`	`296`	`}`
`@@ -298,24 +303,24 @@ struct CSVSingleValueContainer: SingleValueDecodingContainer {`
`298`	`303`
`299`	`304`	`// Handle Decimal specially`
`300`	`305`	`if type == Decimal.self {`
`301`		`- guard let decimal = parseDecimal(value) else {`
`302`		`- throw CSVDecodingError.typeMismatch(expected: "Decimal", actual: value, location: location)`
	`306`	`+ guard let decimal = parseDecimal(trimmedValue) else {`
	`307`	`+ throw CSVDecodingError.typeMismatch(expected: "Decimal", actual: trimmedValue, location: location)`
`303`	`308`	`}`
`304`	`309`	`return decimal as! T`
`305`	`310`	`}`
`306`	`311`
`307`	`312`	`// Handle UUID specially`
`308`	`313`	`if type == UUID.self {`
`309`		`- guard let uuid = UUID(uuidString: value) else {`
`310`		`- throw CSVDecodingError.typeMismatch(expected: "UUID", actual: value, location: location)`
	`314`	`+ guard let uuid = UUID(uuidString: trimmedValue) else {`
	`315`	`+ throw CSVDecodingError.typeMismatch(expected: "UUID", actual: trimmedValue, location: location)`
`311`	`316`	`}`
`312`	`317`	`return uuid as! T`
`313`	`318`	`}`
`314`	`319`
`315`	`320`	`// Handle URL specially`
`316`	`321`	`if type == URL.self {`
`317`		`- guard let url = URL(string: value) else {`
`318`		`- throw CSVDecodingError.typeMismatch(expected: "URL", actual: value, location: location)`
	`322`	`+ guard let url = URL(string: trimmedValue) else {`
	`323`	`+ throw CSVDecodingError.typeMismatch(expected: "URL", actual: trimmedValue, location: location)`
`319`	`324`	`}`
`320`	`325`	`return url as! T`
`321`	`326`	`}`
`@@ -325,26 +330,27 @@ struct CSVSingleValueContainer: SingleValueDecodingContainer {`
`325`	`330`	`}`
`326`	`331`
`327`	`332`	`private func decodeDate() throws -> Date {`
	`333`	`+ let dateValue = trimmedValue`
`328`	`334`	`switch configuration.dateDecodingStrategy {`
`329`	`335`	`case .deferredToDate:`
`330`		`- throw CSVDecodingError.typeMismatch(expected: "Date (use a date strategy)", actual: value, location: location)`
	`336`	`+ throw CSVDecodingError.typeMismatch(expected: "Date (use a date strategy)", actual: dateValue, location: location)`
`331`	`337`
`332`	`338`	`case .secondsSince1970:`
`333`		`- guard let seconds = Double(value) else {`
`334`		`- throw CSVDecodingError.typeMismatch(expected: "Unix timestamp", actual: value, location: location)`
	`339`	`+ guard let seconds = Double(dateValue) else {`
	`340`	`+ throw CSVDecodingError.typeMismatch(expected: "Unix timestamp", actual: dateValue, location: location)`
`335`	`341`	`}`
`336`	`342`	`return Date(timeIntervalSince1970: seconds)`
`337`	`343`
`338`	`344`	`case .millisecondsSince1970:`
`339`		`- guard let milliseconds = Double(value) else {`
`340`		`- throw CSVDecodingError.typeMismatch(expected: "Unix timestamp (ms)", actual: value, location: location)`
	`345`	`+ guard let milliseconds = Double(dateValue) else {`
	`346`	`+ throw CSVDecodingError.typeMismatch(expected: "Unix timestamp (ms)", actual: dateValue, location: location)`
`341`	`347`	`}`
`342`	`348`	`return Date(timeIntervalSince1970: milliseconds / 1000)`
`343`	`349`
`344`	`350`	`case .iso8601:`
`345`	`351`	`let formatter = ISO8601DateFormatter()`
`346`		`- guard let date = formatter.date(from: value) else {`
`347`		`- throw CSVDecodingError.typeMismatch(expected: "ISO8601 date", actual: value, location: location)`
	`352`	`+ guard let date = formatter.date(from: dateValue) else {`
	`353`	`+ throw CSVDecodingError.typeMismatch(expected: "ISO8601 date", actual: dateValue, location: location)`
`348`	`354`	`}`
`349`	`355`	`return date`
`350`	`356`
`@@ -353,40 +359,40 @@ struct CSVSingleValueContainer: SingleValueDecodingContainer {`
`353`	`359`	`formatter.dateFormat = format`
`354`	`360`	`formatter.locale = Locale.autoupdatingCurrent`
`355`	`361`	`formatter.timeZone = TimeZone.autoupdatingCurrent`
`356`		`- guard let date = formatter.date(from: value) else {`
`357`		`- throw CSVDecodingError.typeMismatch(expected: "Date with format \(format)", actual: value, location: location)`
	`362`	`+ guard let date = formatter.date(from: dateValue) else {`
	`363`	`+ throw CSVDecodingError.typeMismatch(expected: "Date with format \(format)", actual: dateValue, location: location)`
`358`	`364`	`}`
`359`	`365`	`return date`
`360`	`366`
`361`	`367`	`case .custom(let closure):`
`362`		`- return try closure(value)`
	`368`	`+ return try closure(dateValue)`
`363`	`369`
`364`	`370`	`case .flexible:`
`365`		`- guard let date = parseFlexibleDate(value, hint: nil) else {`
`366`		`- throw CSVDecodingError.typeMismatch(expected: "Date (no matching format found)", actual: value, location: location)`
	`371`	`+ guard let date = parseFlexibleDate(dateValue, hint: nil) else {`
	`372`	`+ throw CSVDecodingError.typeMismatch(expected: "Date (no matching format found)", actual: dateValue, location: location)`
`367`	`373`	`}`
`368`	`374`	`return date`
`369`	`375`
`370`	`376`	`case .flexibleWithHint(let preferred):`
`371`		`- guard let date = parseFlexibleDate(value, hint: preferred) else {`
`372`		`- throw CSVDecodingError.typeMismatch(expected: "Date (no matching format found)", actual: value, location: location)`
	`377`	`+ guard let date = parseFlexibleDate(dateValue, hint: preferred) else {`
	`378`	`+ throw CSVDecodingError.typeMismatch(expected: "Date (no matching format found)", actual: dateValue, location: location)`
`373`	`379`	`}`
`374`	`380`	`return date`
`375`	`381`
`376`	`382`	`case .localeAware(let locale, let style):`
`377`	`383`	`if #available(iOS 15.0, macOS 12.0, tvOS 15.0, watchOS 8.0, *) {`
`378`		`- if let date = LocaleUtilities.parseDate(value, locale: locale, style: style) {`
	`384`	`+ if let date = LocaleUtilities.parseDate(dateValue, locale: locale, style: style) {`
`379`	`385`	`return date`
`380`	`386`	`}`
`381`	`387`	`// Fall back to flexible parsing if locale-aware fails`
`382`		`- if let date = parseFlexibleDate(value, hint: nil) {`
	`388`	`+ if let date = parseFlexibleDate(dateValue, hint: nil) {`
`383`	`389`	`return date`
`384`	`390`	`}`
`385`		`- throw CSVDecodingError.typeMismatch(expected: "Date (locale-aware)", actual: value, location: location)`
	`391`	`+ throw CSVDecodingError.typeMismatch(expected: "Date (locale-aware)", actual: dateValue, location: location)`
`386`	`392`	`} else {`
`387`	`393`	`// Pre-iOS 15: use flexible parsing`
`388`		`- guard let date = parseFlexibleDate(value, hint: nil) else {`
`389`		`- throw CSVDecodingError.typeMismatch(expected: "Date", actual: value, location: location)`
	`394`	`+ guard let date = parseFlexibleDate(dateValue, hint: nil) else {`
	`395`	`+ throw CSVDecodingError.typeMismatch(expected: "Date", actual: dateValue, location: location)`
`390`	`396`	`}`
`391`	`397`	`return date`
`392`	`398`	`}`