Add numeric normalization strategies

Author: mattt

README.md

@@ -51,7 +51,7 @@ see the [TOON specification](https://github.com/toon-format/spec).
 `TOONEncoder` conforms to **TOON specification version 3.0** (2025-11-24)
 and implements the following features:
 
-- [x] Canonical number formatting (no trailing zeros, no leading zeros except `0`; `-0` normalized to `0`)
+- [x] Canonical number formatting (no trailing zeros, no leading zeros except `0`; `-0` normalized to `0` by default)
 - [x] Correct escape sequences for strings (`\\`, `\"`, `\n`, `\r`, `\t`)
 - [x] Three delimiter types: comma (default), tab, pipe
 - [x] Array length validation
@@ -177,6 +177,22 @@ items[2|]{sku|name|qty|price}:
   B2|Gadget|1|14.5
 ```
 
+#### Numeric Normalization
+
+`TOONEncoder` defaults to canonical normalization that matches the spec and the
+reference JavaScript implementation. You can override this behavior when you
+need to preserve negative zero or handle non-finite values explicitly.
+
+```swift
+let encoder = TOONEncoder()
+encoder.negativeZeroEncodingStrategy = .preserve
+encoder.nonConformingFloatEncodingStrategy = .convertToString(
+    positiveInfinity: "Infinity",
+    negativeInfinity: "-Infinity",
+    nan: "NaN"
+)
+```
+
 #### Tabular Arrays
 
 Arrays of objects with identical primitive fields use an efficient tabular format:

Sources/ToonFormat/Encoder.swift

@@ -45,6 +45,33 @@ public final class TOONEncoder {
     /// The delimiter to use for array values and tabular rows.
     public var delimiter: Delimiter = .comma
 
+    /// Strategy for encoding negative zero values.
+    public enum NegativeZeroEncodingStrategy: Hashable, Sendable {
+        /// Normalizes `-0.0` to `0`.
+        case normalize
+
+        /// Preserves `-0.0` as `-0`.
+        case preserve
+    }
+
+    /// The strategy to use for encoding negative zero values.
+    public var negativeZeroEncodingStrategy: NegativeZeroEncodingStrategy = .normalize
+
+    /// Strategy for encoding non-conforming floating-point values.
+    public enum NonConformingFloatEncodingStrategy: Hashable, Sendable {
+        /// Encodes non-finite values as `null`.
+        case null
+
+        /// Throws an error on non-finite values.
+        case `throw`
+
+        /// Encodes non-finite values as string literals.
+        case convertToString(positiveInfinity: String, negativeInfinity: String, nan: String)
+    }
+
+    /// The strategy to use for encoding non-conforming floating-point values.
+    public var nonConformingFloatEncodingStrategy: NonConformingFloatEncodingStrategy = .null
+
     /// Key folding mode.
     public enum KeyFolding: Hashable, Sendable {
         /// No key folding.
@@ -115,6 +142,8 @@ public final class TOONEncoder {
     /// Default settings:
     /// - `indent`: 2 spaces
     /// - `delimiter`: `.comma`
+    /// - `negativeZeroEncodingStrategy`: `.normalize`
+    /// - `nonConformingFloatEncodingStrategy`: `.null`
     /// - `keyFolding`: `.disabled`
     /// - `flattenDepth`: `Int.max`
     /// - `limits`: `.default`
@@ -148,6 +177,10 @@ public final class TOONEncoder {
             v = encoder.encodedValue
         }
 
+        if case .throw = nonConformingFloatEncodingStrategy {
+            try validateNonConformingFloats(in: v)
+        }
+
         var output: [String] = []
         encodeValue(v, output: &output, depth: 0)
 
@@ -646,12 +679,32 @@ public final class TOONEncoder {
         case .double(let doubleValue):
             // Check for non-finite numbers first
             if !doubleValue.isFinite {
-                return "null"
+                switch nonConformingFloatEncodingStrategy {
+                case .null:
+                    return "null"
+                case .throw:
+                    return "null"
+                case .convertToString(let positiveInfinity, let negativeInfinity, let nan):
+                    let literal: String
+                    if doubleValue.isNaN {
+                        literal = nan
+                    } else if doubleValue.sign == .minus {
+                        literal = negativeInfinity
+                    } else {
+                        literal = positiveInfinity
+                    }
+                    return encodeStringLiteral(literal, delimiter: delimiter)
+                }
             }
 
             // Format numbers in decimal form without scientific notation
             if doubleValue == 0.0 && doubleValue.sign == .minus {
-                return "0"  // Convert -0 to 0
+                switch negativeZeroEncodingStrategy {
+                case .normalize:
+                    return "0"
+                case .preserve:
+                    return "-0"
+                }
             }
 
             if let formatted = numberFormatter.string(from: NSNumber(value: doubleValue)) {
@@ -677,6 +730,32 @@ public final class TOONEncoder {
         }
     }
 
+    private func validateNonConformingFloats(in value: Value) throws {
+        switch value {
+        case .double(let doubleValue):
+            guard doubleValue.isFinite else {
+                throw EncodingError.invalidValue(
+                    doubleValue,
+                    EncodingError.Context(
+                        codingPath: [],
+                        debugDescription: "Non-conforming float value: \(doubleValue)"
+                    )
+                )
+            }
+        case .array(let array):
+            for item in array {
+                try validateNonConformingFloats(in: item)
+            }
+        case .object(let values, let keyOrder):
+            for key in keyOrder {
+                guard let nestedValue = values[key] else { continue }
+                try validateNonConformingFloats(in: nestedValue)
+            }
+        case .null, .bool, .int, .string, .date, .url, .data:
+            break
+        }
+    }
+
     private func encodeStringLiteral(_ value: String, delimiter: String = ",")
         -> String
     {

Tests/ToonFormatTests/EncoderTests.swift

@@ -69,12 +69,30 @@ struct EncoderTests {
 
     @Test func specialNumericValues() async throws {
         #expect(String(data: try encoder.encode(-0.0), encoding: .utf8) == "0")
+        #expect(String(data: try encoder.encode(Double.nan), encoding: .utf8) == "null")
+        #expect(String(data: try encoder.encode(Double.infinity), encoding: .utf8) == "null")
+        #expect(String(data: try encoder.encode(-Double.infinity), encoding: .utf8) == "null")
         #expect(String(data: try encoder.encode(1e6), encoding: .utf8) == "1000000")
         #expect(String(data: try encoder.encode(1e-6), encoding: .utf8) == "0.000001")
         #expect(String(data: try encoder.encode(1e20), encoding: .utf8) == "100000000000000000000")
         #expect(String(data: try encoder.encode(Int64.max), encoding: .utf8) == "9223372036854775807")
     }
 
+    @Test func preserveNegativeZero() async throws {
+        encoder.negativeZeroEncodingStrategy = .preserve
+        #expect(String(data: try encoder.encode(-0.0), encoding: .utf8) == "-0")
+    }
+
+    @Test func nonConformingFloatThrowStrategy() async throws {
+        encoder.nonConformingFloatEncodingStrategy = .throw
+        #expect(throws: EncodingError.self) {
+            _ = try encoder.encode(Double.nan)
+        }
+        #expect(throws: EncodingError.self) {
+            _ = try encoder.encode(Double.infinity)
+        }
+    }
+
     @Test func booleans() async throws {
         #expect(String(data: try encoder.encode(true), encoding: .utf8) == "true")
         #expect(String(data: try encoder.encode(false), encoding: .utf8) == "false")