Fix ArgumentOutOfRangeException when using DateTime.MinValue/MaxValue with timezone offsets

Fluid.Tests/TemplateTests.cs

@@ -285,6 +285,86 @@ public async Task ShouldEvaluateTimeSpanValue()
             Assert.Equal("1970-01-01 01:00:00Z", result);
         }
 
+        [Fact]
+        public async Task ShouldHandleDateTimeMinValueWithPositiveTimezoneOffset()
+        {
+            // Set a timezone offset of +2 hours (like EET - Eastern European Time)
+            var plusTwoTimezone = TimeZoneInfo.CreateCustomTimeZone("Custom+2", TimeSpan.FromHours(2), "UTC+2", "UTC+2");
+
+            _parser.TryParse("{{ foo }} {{ date }}", out var template, out var error);
+
+            var context = new TemplateContext { TimeZone = plusTwoTimezone };
+            context.SetValue("foo", "bar");
+            context.SetValue("date", DateTime.MinValue);
+
+            // This should not throw ArgumentOutOfRangeException
+            var result = await template.RenderAsync(context);
+
+            // DateTime.MinValue should be rendered as the minimum DateTimeOffset value
+            Assert.Contains("bar", result);
+            Assert.Contains("0001-01-01", result);
+        }
+
+        [Fact]
+        public async Task ShouldHandleDateTimeNearMinValueWithPositiveTimezoneOffset()
+        {
+            // Set a timezone offset of +2 hours (like EET - Eastern European Time)
+            var plusTwoTimezone = TimeZoneInfo.CreateCustomTimeZone("Custom+2", TimeSpan.FromHours(2), "UTC+2", "UTC+2");
+
+            _parser.TryParse("{{ foo }} {{ date }}", out var template, out var error);
+
+            var context = new TemplateContext { TimeZone = plusTwoTimezone };
+            context.SetValue("foo", "bar");
+            context.SetValue("date", DateTime.MinValue.AddHours(1));
+
+            // This should not throw ArgumentOutOfRangeException even with DateTime.MinValue + 1 hour
+            var result = await template.RenderAsync(context);
+
+            // DateTime near MinValue should be rendered as the minimum DateTimeOffset value
+            Assert.Contains("bar", result);
+            Assert.Contains("0001-01-01", result);
+        }
+
+        [Fact]
+        public async Task ShouldHandleDateTimeMaxValueWithNegativeTimezoneOffset()
+        {
+            // Set a timezone offset of -2 hours (like Brazil Standard Time)
+            var minusTwoTimezone = TimeZoneInfo.CreateCustomTimeZone("Custom-2", TimeSpan.FromHours(-2), "UTC-2", "UTC-2");
+
+            _parser.TryParse("{{ foo }} {{ date }}", out var template, out var error);
+
+            var context = new TemplateContext { TimeZone = minusTwoTimezone };
+            context.SetValue("foo", "bar");
+            context.SetValue("date", DateTime.MaxValue);
+
+            // This should not throw ArgumentOutOfRangeException
+            var result = await template.RenderAsync(context);
+
+            // DateTime.MaxValue should be rendered as the maximum DateTimeOffset value
+            Assert.Contains("bar", result);
+            Assert.Contains("9999-12-31", result);
+        }
+
+        [Fact]
+        public async Task ShouldHandleDateTimeNearMaxValueWithNegativeTimezoneOffset()
+        {
+            // Set a timezone offset of -2 hours (like Brazil Standard Time)
+            var minusTwoTimezone = TimeZoneInfo.CreateCustomTimeZone("Custom-2", TimeSpan.FromHours(-2), "UTC-2", "UTC-2");
+
+            _parser.TryParse("{{ foo }} {{ date }}", out var template, out var error);
+
+            var context = new TemplateContext { TimeZone = minusTwoTimezone };
+            context.SetValue("foo", "bar");
+            context.SetValue("date", DateTime.MaxValue.AddHours(-1));
+
+            // This should not throw ArgumentOutOfRangeException even with DateTime.MaxValue - 1 hour
+            var result = await template.RenderAsync(context);
+
+            // DateTime near MaxValue should be rendered as the maximum DateTimeOffset value
+            Assert.Contains("bar", result);
+            Assert.Contains("9999-12-31", result);
+        }
+
         [Fact]
         public async Task ShouldEvaluateObjectProperty()
         {

Fluid/Values/DateTimeValue.cs

@@ -13,6 +13,33 @@ public DateTimeValue(DateTimeOffset value)
             _value = value;
         }
 
+        public DateTimeValue(DateTime value)
+        {
+            // Handle edge cases where DateTime cannot be safely converted to DateTimeOffset
+            // with local timezone offset due to overflow (e.g., DateTime.MinValue with positive offset)
+
+            try
+            {
+                // Attempt normal conversion - implicit conversion uses local timezone for Unspecified kind
+                _value = value;
+            }
+            catch (ArgumentOutOfRangeException)
+            {
+                // If conversion fails due to offset overflow, use the appropriate boundary value
+                // This happens when the UTC representation would be outside the valid range
+                if (value < DateTime.MinValue.AddDays(1))
+                {
+                    // Value is close to MinValue and offset caused underflow
+                    _value = DateTimeOffset.MinValue;
+                }
+                else
+                {
+                    // Value is close to MaxValue and offset caused overflow
+                    _value = DateTimeOffset.MaxValue;
+                }
+            }
+        }
+
         public override FluidValues Type => FluidValues.DateTime;
 
         public override bool Equals(FluidValue other)