Reimplement number/string conversions per ECMAScript spec (microsoft#215)

Co-authored-by: Nathan Shively-Sanders <[email protected]>

Author: jakebailey

.github/codeql/codeql-configuration.yml

@@ -4,3 +4,8 @@ paths-ignore:
   - _submodules/**
   - '**/testdata/**'
   - 'internal/bundled/libs/**'
+
+query-filters:
+  # This query takes too long on complicated string manipulations
+  - exclude:
+      id: go/unsafe-quoting

internal/jsnum/jsnum.go

@@ -3,7 +3,6 @@ package jsnum
 
 import (
 	"math"
-	"strconv"
 )
 
 const (
@@ -19,12 +18,6 @@ const (
 // not the "math" package and conversions.
 type Number float64
 
-// https://tc39.es/ecma262/2024/multipage/ecmascript-data-types-and-values.html#sec-numeric-types-number-tostring
-func (n Number) String() string {
-	// !!! verify that this is actually the same as JS.
-	return strconv.FormatFloat(float64(n), 'g', -1, 64)
-}
-
 func NaN() Number {
 	return Number(math.NaN())
 }
@@ -41,20 +34,6 @@ func (n Number) IsInf() bool {
 	return math.IsInf(float64(n), 0)
 }
 
-// https://tc39.es/ecma262/2024/multipage/abstract-operations.html#sec-stringtonumber
-func FromString(s string) Number {
-	// !!! verify that this is actually the same as JS.
-	floatValue, err := strconv.ParseFloat(s, 64)
-	if err == nil {
-		return Number(floatValue)
-	}
-	intValue, err := strconv.ParseInt(s, 0, 64)
-	if err == nil {
-		return Number(intValue)
-	}
-	return NaN()
-}
-
 func isNonFinite(x float64) bool {
 	// This is equivalent to checking `math.IsNaN(x) || math.IsInf(x, 0)` in one operation.
 	const mask = 0x7FF0000000000000

internal/jsnum/jsnum_test.go

@@ -10,13 +10,22 @@ import (
 
 func assertEqualNumber(t *testing.T, got, want Number) {
 	t.Helper()
-	if want.IsNaN() {
-		assert.Assert(t, got.IsNaN())
+
+	if got.IsNaN() || want.IsNaN() {
+		assert.Equal(t, got.IsNaN(), want.IsNaN(), "got: %v, want: %v", got, want)
 	} else {
 		assert.Equal(t, got, want)
 	}
 }
 
+func numberFromBits(b uint64) Number {
+	return Number(math.Float64frombits(b))
+}
+
+func numberToBits(n Number) uint64 {
+	return math.Float64bits(float64(n))
+}
+
 var toInt32Tests = []struct {
 	name  string
 	input Number
@@ -46,8 +55,8 @@ var toInt32Tests = []struct {
 	{"-SmallestNonzeroFloat64", -math.SmallestNonzeroFloat64, 0, false},
 	{"MaxFloat64", math.MaxFloat64, 0, false},
 	{"-MaxFloat64", -math.MaxFloat64, 0, false},
-	{"Largest subnormal number", Number(math.Float64frombits(0x000FFFFFFFFFFFFF)), 0, false},
-	{"Smallest positive normal number", Number(math.Float64frombits(0x0010000000000000)), 0, false},
+	{"Largest subnormal number", numberFromBits(0x000FFFFFFFFFFFFF), 0, false},
+	{"Smallest positive normal number", numberFromBits(0x0010000000000000), 0, false},
 	{"Largest normal number", math.MaxFloat64, 0, false},
 	{"-Largest normal number", -math.MaxFloat64, 0, false},
 	{"1.0", 1.0, 1, false},
@@ -75,7 +84,7 @@ func TestToInt32(t *testing.T) {
 	t.Parallel()
 
 	for _, test := range toInt32Tests {
-		t.Run(fmt.Sprintf("%s (%v)", test.name, test.input), func(t *testing.T) {
+		t.Run(fmt.Sprintf("%s (%v)", test.name, float64(test.input)), func(t *testing.T) {
 			t.Parallel()
 			assert.Equal(t, test.input.toInt32(), test.want)
 		})
@@ -90,7 +99,7 @@ func BenchmarkToInt32(b *testing.B) {
 			continue
 		}
 
-		b.Run(fmt.Sprintf("%s (%v)", test.name, test.input), func(b *testing.B) {
+		b.Run(fmt.Sprintf("%s (%v)", test.name, float64(test.input)), func(b *testing.B) {
 			for range b.N {
 				sink = test.input.toInt32()
 			}

internal/jsnum/ryu_test.go

@@ -0,0 +1,164 @@
+package jsnum
+
+// Copyright 2018 Ulf Adams
+//
+// The contents of this file may be used under the terms of the Apache License,
+// Version 2.0.
+//
+//    (See accompanying file LICENSE-Apache or copy at
+//     http://www.apache.org/licenses/LICENSE-2.0)
+//
+// Alternatively, the contents of this file may be used under the terms of
+// the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE-Boost or copy at
+//     https://www.boost.org/LICENSE_1_0.txt)
+//
+// Unless required by applicable law or agreed to in writing, this software
+// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.
+
+// Copied from https://github.com/ulfjack/ryu/blob/1264a946ba66eab320e927bfd2362e0c8580c42f/ryu/tests/d2s_test.cc
+// Modified to fit Number::toString's output.
+
+func ieeeParts2Double(sign bool, ieeeExponent uint32, ieeeMantissa uint64) Number {
+	if ieeeExponent > 2047 {
+		panic("ieeeExponent > 2047")
+	}
+	if ieeeMantissa > maxMantissa {
+		panic("ieeeMantissa > maxMantissa")
+	}
+	signBit := uint64(0)
+	if sign {
+		signBit = 1
+	}
+	return numberFromBits((signBit << 63) | (uint64(ieeeExponent) << 52) | ieeeMantissa)
+}
+
+const maxMantissa = (1 << 53) - 1
+
+var ryuTests = []stringTest{
+	{2.2250738585072014e-308, "2.2250738585072014e-308"},
+	{numberFromBits(0x7fefffffffffffff), "1.7976931348623157e+308"},
+	{numberFromBits(1), "5e-324"},
+	{2.98023223876953125e-8, "2.9802322387695312e-8"},
+	{-2.109808898695963e16, "-21098088986959630"},
+	{4.940656e-318, "4.940656e-318"},
+	{1.18575755e-316, "1.18575755e-316"},
+	{2.989102097996e-312, "2.989102097996e-312"},
+	{9.0608011534336e15, "9060801153433600"},
+	{4.708356024711512e18, "4708356024711512000"},
+	{9.409340012568248e18, "9409340012568248000"},
+	{1.2345678, "1.2345678"},
+	{numberFromBits(0x4830F0CF064DD592), "5.764607523034235e+39"},
+	{numberFromBits(0x4840F0CF064DD592), "1.152921504606847e+40"},
+	{numberFromBits(0x4850F0CF064DD592), "2.305843009213694e+40"},
+	{1.2, "1.2"},
+	{1.23, "1.23"},
+	{1.234, "1.234"},
+	{1.2345, "1.2345"},
+	{1.23456, "1.23456"},
+	{1.234567, "1.234567"},
+	{1.2345678, "1.2345678"},
+	{1.23456789, "1.23456789"},
+	{1.234567895, "1.234567895"},
+	{1.2345678901, "1.2345678901"},
+	{1.23456789012, "1.23456789012"},
+	{1.234567890123, "1.234567890123"},
+	{1.2345678901234, "1.2345678901234"},
+	{1.23456789012345, "1.23456789012345"},
+	{1.234567890123456, "1.234567890123456"},
+	{1.2345678901234567, "1.2345678901234567"},
+	{4.294967294, "4.294967294"},
+	{4.294967295, "4.294967295"},
+	{4.294967296, "4.294967296"},
+	{4.294967297, "4.294967297"},
+	{4.294967298, "4.294967298"},
+	{ieeeParts2Double(false, 4, 0), "1.7800590868057611e-307"},
+	{ieeeParts2Double(false, 6, maxMantissa), "2.8480945388892175e-306"},
+	{ieeeParts2Double(false, 41, 0), "2.446494580089078e-296"},
+	{ieeeParts2Double(false, 40, maxMantissa), "4.8929891601781557e-296"},
+	{ieeeParts2Double(false, 1077, 0), "18014398509481984"},
+	{ieeeParts2Double(false, 1076, maxMantissa), "36028797018963964"},
+	{ieeeParts2Double(false, 307, 0), "2.900835519859558e-216"},
+	{ieeeParts2Double(false, 306, maxMantissa), "5.801671039719115e-216"},
+	{ieeeParts2Double(false, 934, 0x000FA7161A4D6E0C), "3.196104012172126e-27"},
+	{9007199254740991.0, "9007199254740991"},
+	{9007199254740992.0, "9007199254740992"},
+	{1.0e+0, "1"},
+	{1.2e+1, "12"},
+	{1.23e+2, "123"},
+	{1.234e+3, "1234"},
+	{1.2345e+4, "12345"},
+	{1.23456e+5, "123456"},
+	{1.234567e+6, "1234567"},
+	{1.2345678e+7, "12345678"},
+	{1.23456789e+8, "123456789"},
+	{1.23456789e+9, "1234567890"},
+	{1.234567895e+9, "1234567895"},
+	{1.2345678901e+10, "12345678901"},
+	{1.23456789012e+11, "123456789012"},
+	{1.234567890123e+12, "1234567890123"},
+	{1.2345678901234e+13, "12345678901234"},
+	{1.23456789012345e+14, "123456789012345"},
+	{1.234567890123456e+15, "1234567890123456"},
+	{1.0e+0, "1"},
+	{1.0e+1, "10"},
+	{1.0e+2, "100"},
+	{1.0e+3, "1000"},
+	{1.0e+4, "10000"},
+	{1.0e+5, "100000"},
+	{1.0e+6, "1000000"},
+	{1.0e+7, "10000000"},
+	{1.0e+8, "100000000"},
+	{1.0e+9, "1000000000"},
+	{1.0e+10, "10000000000"},
+	{1.0e+11, "100000000000"},
+	{1.0e+12, "1000000000000"},
+	{1.0e+13, "10000000000000"},
+	{1.0e+14, "100000000000000"},
+	{1.0e+15, "1000000000000000"},
+	{1000000000000001, "1000000000000001"},
+	{1000000000000010, "1000000000000010"},
+	{1000000000000100, "1000000000000100"},
+	{1000000000001000, "1000000000001000"},
+	{1000000000010000, "1000000000010000"},
+	{1000000000100000, "1000000000100000"},
+	{1000000001000000, "1000000001000000"},
+	{1000000010000000, "1000000010000000"},
+	{1000000100000000, "1000000100000000"},
+	{1000001000000000, "1000001000000000"},
+	{1000010000000000, "1000010000000000"},
+	{1000100000000000, "1000100000000000"},
+	{1001000000000000, "1001000000000000"},
+	{1010000000000000, "1010000000000000"},
+	{1100000000000000, "1100000000000000"},
+	{8.0, "8"},
+	{64.0, "64"},
+	{512.0, "512"},
+	{8192.0, "8192"},
+	{65536.0, "65536"},
+	{524288.0, "524288"},
+	{8388608.0, "8388608"},
+	{67108864.0, "67108864"},
+	{536870912.0, "536870912"},
+	{8589934592.0, "8589934592"},
+	{68719476736.0, "68719476736"},
+	{549755813888.0, "549755813888"},
+	{8796093022208.0, "8796093022208"},
+	{70368744177664.0, "70368744177664"},
+	{562949953421312.0, "562949953421312"},
+	{9007199254740992.0, "9007199254740992"},
+	{8.0e+3, "8000"},
+	{64.0e+3, "64000"},
+	{512.0e+3, "512000"},
+	{8192.0e+3, "8192000"},
+	{65536.0e+3, "65536000"},
+	{524288.0e+3, "524288000"},
+	{8388608.0e+3, "8388608000"},
+	{67108864.0e+3, "67108864000"},
+	{536870912.0e+3, "536870912000"},
+	{8589934592.0e+3, "8589934592000"},
+	{68719476736.0e+3, "68719476736000"},
+	{549755813888.0e+3, "549755813888000"},
+	{8796093022208.0e+3, "8796093022208000"},
+}

internal/jsnum/string.go

@@ -0,0 +1,341 @@
+package jsnum
+
+import (
+	"encoding/json"
+	"errors"
+	"math"
+	"math/big"
+	"strconv"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+
+	"github.com/microsoft/typescript-go/internal/stringutil"
+)
+
+// https://tc39.es/ecma262/2024/multipage/ecmascript-data-types-and-values.html#sec-numeric-types-number-tostring
+func (n Number) String() string {
+	switch {
+	case n.IsNaN():
+		return "NaN"
+	case n.IsInf():
+		if n < 0 {
+			return "-Infinity"
+		}
+		return "Infinity"
+	}
+
+	// Fast path: for safe integers, directly convert to string.
+	if MinSafeInteger <= n && n <= MaxSafeInteger {
+		if i := int64(n); float64(i) == float64(n) {
+			return strconv.FormatInt(i, 10)
+		}
+	}
+
+	// Otherwise, the Go json package handles this correctly.
+	b, _ := json.Marshal(float64(n)) //nolint:errchkjson
+	return string(b)
+}
+
+// https://tc39.es/ecma262/2024/multipage/abstract-operations.html#sec-stringtonumber
+func FromString(s string) Number {
+	// Implementing StringToNumber exactly as written in the spec involves
+	// writing a parser, along with the conversion of the parsed AST into the
+	// actual value.
+	//
+	// We've already implemented a number parser in the scanner, but we can't
+	// import it here. We also do not have the conversion implemented since we
+	// previously just wrote `+literal` and let the runtime handle it.
+	//
+	// The strategy below is to instead break the number apart and fix it up
+	// such that Go's own parsing functionality can handle it. This won't be
+	// the fastest method, but it saves us from writing the full parser and
+	// conversion logic.
+
+	s = strings.TrimFunc(s, isStrWhiteSpace)
+
+	switch s {
+	case "":
+		return 0
+	case "Infinity", "+Infinity":
+		return Inf(1)
+	case "-Infinity":
+		return Inf(-1)
+	}
+
+	for _, r := range s {
+		if !isNumberRune(r) {
+			return NaN()
+		}
+	}
+
+	if n, ok := tryParseInt(s); ok {
+		return n
+	}
+
+	// Cut this off first so we can ensure -0 is returned as -0.
+	s, negative := strings.CutPrefix(s, "-")
+
+	if !negative {
+		s, _ = strings.CutPrefix(s, "+")
+	}
+
+	if first, _ := utf8.DecodeRuneInString(s); !stringutil.IsDigit(first) && first != '.' {
+		return NaN()
+	}
+
+	f := parseFloatString(s)
+	if math.IsNaN(f) {
+		return NaN()
+	}
+
+	sign := 1.0
+	if negative {
+		sign = -1.0
+	}
+	return Number(math.Copysign(f, sign))
+}
+
+func isStrWhiteSpace(r rune) bool {
+	// This is different than stringutil.IsWhiteSpaceLike.
+
+	// https://tc39.es/ecma262/2024/multipage/ecmascript-language-lexical-grammar.html#prod-LineTerminator
+	// https://tc39.es/ecma262/2024/multipage/ecmascript-language-lexical-grammar.html#prod-WhiteSpace
+
+	switch r {
+	// LineTerminator
+	case '\n', '\r', 0x2028, 0x2029:
+		return true
+	// WhiteSpace
+	case '\t', '\v', '\f', 0xFEFF:
+		return true
+	}
+
+	// WhiteSpace
+	return unicode.Is(unicode.Zs, r)
+}
+
+var errUnknownPrefix = errors.New("unknown number prefix")
+
+func tryParseInt(s string) (Number, bool) {
+	var i int64
+	var err error
+	var hasIntResult bool
+
+	if len(s) > 2 {
+		prefix, rest := s[:2], s[2:]
+		switch prefix {
+		case "0b", "0B":
+			if !isAllBinaryDigits(rest) {
+				return NaN(), true
+			}
+			i, err = strconv.ParseInt(rest, 2, 64)
+			hasIntResult = true
+		case "0o", "0O":
+			if !isAllOctalDigits(rest) {
+				return NaN(), true
+			}
+			i, err = strconv.ParseInt(rest, 8, 64)
+			hasIntResult = true
+		case "0x", "0X":
+			if !isAllHexDigits(rest) {
+				return NaN(), true
+			}
+			i, err = strconv.ParseInt(rest, 16, 64)
+			hasIntResult = true
+		}
+	}
+
+	if !hasIntResult {
+		// StringToNumber does not parse leading zeros as octal.
+		s = trimLeadingZeros(s)
+		if !isAllDigits(s) {
+			return 0, false
+		}
+		i, err = strconv.ParseInt(s, 10, 64)
+		hasIntResult = true
+	}
+
+	if hasIntResult && err == nil {
+		return Number(i), true
+	}
+
+	// Using this to parse large integers.
+	bi, ok := new(big.Int).SetString(s, 0)
+	if !ok {
+		return NaN(), true
+	}
+
+	f, _ := bi.Float64()
+	return Number(f), true
+}
+
+func parseFloatString(s string) float64 {
+	var hasDot, hasExp bool
+
+	// <a>
+	// <a>.<b>
+	// <a>.<b>e<c>
+	// <a>e<c>
+	var a, b, c, rest string
+
+	a, rest, hasDot = strings.Cut(s, ".")
+	if hasDot {
+		// <a>.<b>
+		// <a>.<b>e<c>
+		b, c, hasExp = cutAny(rest, "eE")
+	} else {
+		// <a>
+		// <a>e<c>
+		a, c, hasExp = cutAny(s, "eE")
+	}
+
+	var sb strings.Builder
+	sb.Grow(len(a) + len(b) + len(c) + 3)
+
+	if a == "" {
+		if hasDot && b == "" {
+			return math.NaN()
+		}
+		if hasExp && c == "" {
+			return math.NaN()
+		}
+		sb.WriteString("0")
+	} else {
+		a = trimLeadingZeros(a)
+		if !isAllDigits(a) {
+			return math.NaN()
+		}
+		sb.WriteString(a)
+	}
+
+	if hasDot {
+		sb.WriteString(".")
+		if b == "" {
+			sb.WriteString("0")
+		} else {
+			b = trimTrailingZeros(b)
+			if !isAllDigits(b) {
+				return math.NaN()
+			}
+			sb.WriteString(b)
+		}
+	}
+
+	if hasExp {
+		sb.WriteString("e")
+
+		c, negative := strings.CutPrefix(c, "-")
+		if negative {
+			sb.WriteString("-")
+		} else {
+			c, _ = strings.CutPrefix(c, "+")
+		}
+		c = trimLeadingZeros(c)
+		if !isAllDigits(c) {
+			return math.NaN()
+		}
+		sb.WriteString(c)
+	}
+
+	return stringToFloat64(sb.String())
+}
+
+func cutAny(s string, cutset string) (before, after string, found bool) {
+	if i := strings.IndexAny(s, cutset); i >= 0 {
+		before = s[:i]
+		afterAndFound := s[i:]
+		_, size := utf8.DecodeRuneInString(afterAndFound)
+		after = afterAndFound[size:]
+		return before, after, true
+	}
+	return s, "", false
+}
+
+func trimLeadingZeros(s string) string {
+	if strings.HasPrefix(s, "0") {
+		s = strings.TrimLeft(s, "0")
+		if s == "" {
+			return "0"
+		}
+	}
+	return s
+}
+
+func trimTrailingZeros(s string) string {
+	if strings.HasSuffix(s, "0") {
+		s = strings.TrimRight(s, "0")
+		if s == "" {
+			return "0"
+		}
+	}
+	return s
+}
+
+func stringToFloat64(s string) float64 {
+	if f, err := strconv.ParseFloat(s, 64); err == nil {
+		return f
+	} else {
+		if errors.Is(err, strconv.ErrRange) {
+			return f
+		}
+	}
+	return math.NaN()
+}
+
+func isAllDigits(s string) bool {
+	for _, r := range s {
+		if !stringutil.IsDigit(r) {
+			return false
+		}
+	}
+	return true
+}
+
+func isAllBinaryDigits(s string) bool {
+	for _, r := range s {
+		if r != '0' && r != '1' {
+			return false
+		}
+	}
+	return true
+}
+
+func isAllOctalDigits(s string) bool {
+	for _, r := range s {
+		if !stringutil.IsOctalDigit(r) {
+			return false
+		}
+	}
+	return true
+}
+
+func isAllHexDigits(s string) bool {
+	for _, r := range s {
+		if !stringutil.IsHexDigit(r) {
+			return false
+		}
+	}
+	return true
+}
+
+func isNumberRune(r rune) bool {
+	if stringutil.IsDigit(r) {
+		return true
+	}
+
+	if 'a' <= r && r <= 'f' {
+		return true
+	}
+
+	if 'A' <= r && r <= 'F' {
+		return true
+	}
+
+	switch r {
+	case '.', '-', '+', 'x', 'X', 'o', 'O':
+		return true
+	}
+
+	return false
+}

internal/jsnum/string_test.go

@@ -0,0 +1,396 @@
+package jsnum
+
+import (
+	"encoding/json"
+	"errors"
+	"flag"
+	"fmt"
+	"math"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"slices"
+	"testing"
+
+	"gotest.tools/v3/assert"
+)
+
+type stringTest struct {
+	number Number
+	str    string
+}
+
+var stringTests = slices.Concat([]stringTest{
+	{NaN(), "NaN"},
+	{Inf(1), "Infinity"},
+	{Inf(-1), "-Infinity"},
+	{0, "0"},
+	{negativeZero, "0"},
+	{1, "1"},
+	{-1, "-1"},
+	{0.3, "0.3"},
+	{-0.3, "-0.3"},
+	{1.5, "1.5"},
+	{-1.5, "-1.5"},
+	{1e308, "1e+308"},
+	{-1e308, "-1e+308"},
+	{math.Pi, "3.141592653589793"},
+	{-math.Pi, "-3.141592653589793"},
+	{MaxSafeInteger, "9007199254740991"},
+	{MinSafeInteger, "-9007199254740991"},
+	{numberFromBits(0x000FFFFFFFFFFFFF), "2.225073858507201e-308"},
+	{numberFromBits(0x0010000000000000), "2.2250738585072014e-308"},
+	{1234567.8, "1234567.8"},
+	{19686109595169230000, "19686109595169230000"},
+	{123.456, "123.456"},
+	{-123.456, "-123.456"},
+	{444123, "444123"},
+	{-444123, "-444123"},
+	{444123.789123456789875436, "444123.7891234568"},
+	{-444123.78963636363636363636, "-444123.7896363636"},
+	{1e21, "1e+21"},
+	{1e20, "100000000000000000000"},
+}, ryuTests)
+
+func TestString(t *testing.T) {
+	t.Parallel()
+
+	for _, test := range stringTests {
+		fInput := float64(test.number)
+
+		t.Run(fmt.Sprintf("%v", fInput), func(t *testing.T) {
+			t.Parallel()
+			assert.Equal(t, test.number.String(), test.str)
+		})
+	}
+}
+
+var fromStringTests = []stringTest{
+	{NaN(), "    NaN"},
+	{Inf(1), "Infinity    "},
+	{Inf(-1), "    -Infinity"},
+	{1, "1."},
+	{1, "1.0   "},
+	{1, "+1"},
+	{1, "+1."},
+	{1, "+1.0"},
+	{NaN(), "whoops"},
+	{0, ""},
+	{0, "0"},
+	{0, "0."},
+	{0, "0.0"},
+	{0, "0.0000"},
+	{0, ".0000"},
+	{negativeZero, "-0"},
+	{negativeZero, "-0."},
+	{negativeZero, "-0.0"},
+	{negativeZero, "-.0"},
+	{NaN(), "."},
+	{NaN(), "e"},
+	{NaN(), ".e"},
+	{NaN(), "+"},
+	{0, "0X0"},
+	{NaN(), "e0"},
+	{NaN(), "E0"},
+	{NaN(), "1e"},
+	{NaN(), "1e+"},
+	{NaN(), "1e-"},
+	{1, "1e+0"},
+	{NaN(), "++0"},
+	{NaN(), "0_0"},
+	{Inf(1), "1e1000"},
+	{Inf(-1), "-1e1000"},
+	{0, ".0e0"},
+	{NaN(), "0e++0"},
+	{10, "0XA"},
+	{0b1010, "0b1010"},
+	{0b1010, "0B1010"},
+	{0o12, "0o12"},
+	{0o12, "0O12"},
+	{0x123456789abcdef0, "0x123456789abcdef0"},
+	{0x123456789abcdef0, "0X123456789ABCDEF0"},
+	{18446744073709552000, "0X10000000000000000"},
+	{18446744073709597000, "0X1000000000000A801"},
+	{NaN(), "0B0.0"},
+	{1.231235345083403e+91, "12312353450834030486384068034683603046834603806830644850340602384608368034634603680348603864"},
+	{NaN(), "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX8OOOOOOOOOOOOOOOOOOO"},
+	{Inf(1), "+Infinity"},
+	{1234.56, "  \t1234.56  "},
+	{NaN(), "\u200b"},
+	{0, " "},
+	{0, "\n"},
+	{0, "\r"},
+	{0, "\r\n"},
+	{0, "\u2028"},
+	{0, "\u2029"},
+	{0, "\t"},
+	{0, "\v"},
+	{0, "\f"},
+	{0, "\uFEFF"},
+	{0, "\u00A0"},
+	{10000000000000000000, "010000000000000000000"},
+	{NaN(), "0x1.fffffffffffffp1023"}, // Make sure Go's extended float syntax doesn't work.
+	{NaN(), "0X_1FFFP-16"},
+	{NaN(), "1_000"}, // NumberToString doesn't handle underscores.
+	{0, "0x0"},
+	{0, "0X0"},
+	{NaN(), "0xOOPS"},
+	{0xABCDEF, "0xABCDEF"},
+	{0xABCDEF, "0xABCDEF"},
+	{0, "0o0"},
+	{0, "0O0"},
+	{NaN(), "0o8"},
+	{NaN(), "0O8"},
+	{0o12345, "0o12345"},
+	{0o12345, "0O12345"},
+	{0, "0b0"},
+	{0, "0B0"},
+	{NaN(), "0b2"},
+	{NaN(), "0b2"},
+	{0b10101, "0b10101"},
+	{0b10101, "0B10101"},
+	{NaN(), "1.f"},
+	{NaN(), "1.e"},
+	{NaN(), "1.0ef"},
+	{NaN(), "1.0e"},
+	{NaN(), ".f"},
+	{NaN(), ".e"},
+	{NaN(), ".0ef"},
+	{NaN(), ".0e"},
+	{NaN(), "a.f"},
+	{NaN(), "a.e"},
+	{NaN(), "a.0ef"},
+	{NaN(), "a.0e"},
+}
+
+func TestFromString(t *testing.T) {
+	t.Parallel()
+
+	t.Run("stringTests", func(t *testing.T) {
+		t.Parallel()
+		for _, test := range stringTests {
+			t.Run(test.str, func(t *testing.T) {
+				t.Parallel()
+				assertEqualNumber(t, FromString(test.str), test.number)
+				assertEqualNumber(t, FromString(test.str+" "), test.number)
+				assertEqualNumber(t, FromString(" "+test.str), test.number)
+			})
+		}
+	})
+
+	t.Run("fromStringTests", func(t *testing.T) {
+		t.Parallel()
+		for _, test := range fromStringTests {
+			t.Run(test.str, func(t *testing.T) {
+				t.Parallel()
+				assertEqualNumber(t, FromString(test.str), test.number)
+			})
+		}
+	})
+}
+
+func TestStringRoundtrip(t *testing.T) {
+	t.Parallel()
+
+	for _, test := range stringTests {
+		t.Run(test.str, func(t *testing.T) {
+			t.Parallel()
+			assert.Equal(t, FromString(test.str).String(), test.str)
+		})
+	}
+}
+
+func getNodeExe(t testing.TB) string {
+	t.Helper()
+
+	const exeName = "node"
+	exe, err := exec.LookPath(exeName)
+	if err != nil {
+		t.Skipf("%s not found: %v", exeName, err)
+	}
+	return exe
+}
+
+func TestStringJS(t *testing.T) {
+	t.Parallel()
+
+	exe := getNodeExe(t)
+
+	t.Run("stringTests", func(t *testing.T) {
+		t.Parallel()
+
+		// These tests should roundtrip both ways.
+		stringTestsResults := getStringResultsFromJS(t, exe, stringTests)
+		for i, test := range stringTests {
+			t.Run(fmt.Sprintf("%v", float64(test.number)), func(t *testing.T) {
+				t.Parallel()
+				assertEqualNumber(t, stringTestsResults[i].number, test.number)
+				assert.Equal(t, stringTestsResults[i].str, test.str)
+			})
+		}
+	})
+
+	t.Run("fromStringTests", func(t *testing.T) {
+		t.Parallel()
+
+		// These tests should convert the string to the same number.
+		fromStringTestsResults := getStringResultsFromJS(t, exe, fromStringTests)
+		for i, test := range fromStringTests {
+			t.Run(fmt.Sprintf("fromString %q", test.str), func(t *testing.T) {
+				t.Parallel()
+				assertEqualNumber(t, fromStringTestsResults[i].number, test.number)
+			})
+		}
+	})
+}
+
+func isFuzzing() bool {
+	return flag.CommandLine.Lookup("test.fuzz").Value.String() != ""
+}
+
+func FuzzStringJS(f *testing.F) {
+	exe := getNodeExe(f)
+
+	if isFuzzing() {
+		// Avoid running anything other than regressions in the fuzzing mode.
+		for _, test := range stringTests {
+			f.Add(float64(test.number))
+		}
+		for _, test := range fromStringTests {
+			f.Add(float64(test.number))
+		}
+	}
+
+	f.Fuzz(func(t *testing.T, f float64) {
+		n := Number(f)
+		nStr := n.String()
+
+		results := getStringResultsFromJS(t, exe, []stringTest{{number: n, str: nStr}})
+		assert.Equal(t, len(results), 1)
+
+		nToJSStr := results[0].str
+		nStrToJSNumber := results[0].number
+
+		assert.Equal(t, nStr, nToJSStr)
+		assertEqualNumber(t, n, nStrToJSNumber)
+	})
+}
+
+func FuzzFromStringJS(f *testing.F) {
+	exe := getNodeExe(f)
+
+	if isFuzzing() {
+		// Avoid running anything other than regressions in the fuzzing mode.
+		for _, test := range stringTests {
+			f.Add(test.str)
+		}
+		for _, test := range fromStringTests {
+			f.Add(test.str)
+		}
+	}
+
+	f.Fuzz(func(t *testing.T, s string) {
+		if len(s) > 350 {
+			t.Skip()
+		}
+
+		n := FromString(s)
+		results := getStringResultsFromJS(t, exe, []stringTest{{str: s}})
+		assert.Equal(t, len(results), 1)
+		assertEqualNumber(t, n, results[0].number)
+	})
+}
+
+func getStringResultsFromJS(t testing.TB, exe string, tests []stringTest) []stringTest {
+	t.Helper()
+	tmpdir := t.TempDir()
+
+	type data struct {
+		Bits [2]uint32 `json:"bits"`
+		Str  string    `json:"str"`
+	}
+
+	inputData := make([]data, len(tests))
+	for i, test := range tests {
+		inputData[i] = data{
+			Bits: numberToUint32Array(test.number),
+			Str:  test.str,
+		}
+	}
+
+	jsonInput, err := json.Marshal(inputData)
+	assert.NilError(t, err)
+
+	jsonInputPath := filepath.Join(tmpdir, "input.json")
+	err = os.WriteFile(jsonInputPath, jsonInput, 0o644)
+	assert.NilError(t, err)
+
+	script := `
+		const fs = require('fs');
+
+		function fromBits(bits) {
+			const buffer = new ArrayBuffer(8);
+			(new Uint32Array(buffer))[0] = bits[0];
+			(new Uint32Array(buffer))[1] = bits[1];
+			return new Float64Array(buffer)[0];
+		}
+
+		function toBits(number) {
+			const buffer = new ArrayBuffer(8);
+			(new Float64Array(buffer))[0] = number;
+			return [(new Uint32Array(buffer))[0], (new Uint32Array(buffer))[1]];
+		}
+
+		const input = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
+
+		const output = input.map((input) => ({
+			str: ""+fromBits(input.bits),
+			bits: toBits(+input.str),	
+		}));
+
+		process.stdout.write(JSON.stringify(output));
+	`
+
+	scriptPath := filepath.Join(tmpdir, "script.cjs")
+	err = os.WriteFile(scriptPath, []byte(script), 0o644)
+	assert.NilError(t, err)
+
+	execCmd := exec.Command(exe, scriptPath, jsonInputPath)
+
+	stdout, err := execCmd.Output()
+	if err != nil {
+		var exitErr *exec.ExitError
+		if errors.As(err, &exitErr) {
+			t.Fatalf("failed to execute: %v\n%s", err, exitErr.Stderr)
+		} else {
+			t.Fatalf("failed to execute: %v", err)
+		}
+	}
+
+	var outputData []data
+
+	err = json.Unmarshal(stdout, &outputData)
+	assert.NilError(t, err)
+
+	assert.Equal(t, len(outputData), len(tests))
+
+	output := make([]stringTest, len(tests))
+	for i, outputDatum := range outputData {
+		output[i] = stringTest{
+			number: uint32ArrayToNumber(outputDatum.Bits),
+			str:    outputDatum.Str,
+		}
+	}
+
+	return output
+}
+
+func numberToUint32Array(n Number) [2]uint32 {
+	bits := numberToBits(n)
+	return [2]uint32{uint32(bits), uint32(bits >> 32)}
+}
+
+func uint32ArrayToNumber(a [2]uint32) Number {
+	bits := uint64(a[0]) | uint64(a[1])<<32
+	return numberFromBits(bits)
+}