fix: align finite printf and quoted numeric string semantics

Author: akeit0

src/Lua/Internal/HexConverter.cs

@@ -143,4 +143,85 @@ public static string FromDouble(double value)
         var mantissaHex = mantissa.ToString("x13").TrimEnd('0');
         return $"{sign}0x{leadingDigit}.{mantissaHex}p{adjustedExponent:+0;-0}";
     }
+
+    internal static string FormatDouble(
+        double value,
+        int precision,
+        bool alternateForm,
+        bool upperCase
+    )
+    {
+        string text;
+        if (double.IsNaN(value) || double.IsInfinity(value))
+        {
+            text = value.ToString(CultureInfo.InvariantCulture);
+        }
+        else
+        {
+            text = FormatFinite(value, precision, alternateForm);
+        }
+        return upperCase ? text.ToUpperInvariant() : text;
+    }
+
+    static string FormatFinite(double value, int precision, bool alternateForm)
+    {
+        const ulong fractionMask = (1UL << 52) - 1;
+        var bits = BitConverter.DoubleToInt64Bits(value);
+        var exponent = (int)((bits >> 52) & 0x7ff);
+        var significand = ((ulong)bits & fractionMask) | (exponent == 0 ? 0 : 1UL << 52);
+        var adjustedExponent = exponent == 0 ? (significand == 0 ? 0 : -1022) : exponent - 1023;
+
+        if (precision is >= 0 and < 13)
+        {
+            var shift = 52 - precision * 4;
+            var retained = significand >> shift;
+            var discarded = significand & ((1UL << shift) - 1);
+            var halfway = 1UL << (shift - 1);
+            // Round to nearest, with ties to an even final hexadecimal digit.
+            if (discarded > halfway || (discarded == halfway && (retained & 1) != 0))
+                retained++;
+            significand = retained << shift;
+        }
+
+        var sign = bits < 0 ? "-" : "";
+        var leadingDigit = (char)('0' + (significand >> 52));
+        var fraction = significand & fractionMask;
+        var digits = "";
+        if (precision != 0 && (precision >= 0 || fraction != 0))
+        {
+            digits = fraction.ToString("x13", CultureInfo.InvariantCulture);
+            digits =
+                precision < 0 ? digits.TrimEnd('0')
+                : precision < 13 ? digits[..precision]
+                : digits.PadRight(precision, '0');
+        }
+#if NET6_0_OR_GREATER
+        if (digits.Length == 0 && !alternateForm)
+            return string.Create(
+                CultureInfo.InvariantCulture,
+                $"{sign}0x{leadingDigit}p{adjustedExponent:+0;-0}"
+            );
+        return string.Create(
+            CultureInfo.InvariantCulture,
+            $"{sign}0x{leadingDigit}.{digits}p{adjustedExponent:+0;-0}"
+        );
+#else
+        if (digits.Length == 0 && !alternateForm)
+            return string.Format(
+                CultureInfo.InvariantCulture,
+                "{0}0x{1}p{2:+0;-0}",
+                sign,
+                leadingDigit,
+                adjustedExponent
+            );
+        return string.Format(
+            CultureInfo.InvariantCulture,
+            "{0}0x{1}.{2}p{3:+0;-0}",
+            sign,
+            leadingDigit,
+            digits,
+            adjustedExponent
+        );
+#endif
+    }
 }