typia 15.0.0 → 15.0.1

package/native/core/programmers/http/HttpQueryProgrammer.go

@@ -30,6 +30,14 @@ type HttpQueryProgrammer_DecomposeProps struct {
   AllowOptional bool
   Type          *shimchecker.Type
   Name          *string
+
+  // Missing makes the decoder throw `Error("missing <key>")` for an absent
+  // required non-array property. Only `http.query`, which validates nothing
+  // else, asks for it. The `is`, `assert`, and `validate` variants decode
+  // through this same function and must report the absence through their own
+  // contract instead (`null`, an `IValidation` failure, `TypeGuardError`), so
+  // they leave it off (samchon/typia#2444).
+  Missing bool
 }
 
 var httpQueryProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
@@ -78,9 +86,11 @@ func (httpQueryProgrammerNamespace) Decompose(props HttpQueryProgrammer_Decompos
   statements := httpQueryProgrammer_decode_object(struct {
     Context nativecontext.ITypiaContext
     Object  *schemametadata.MetadataObjectType
+    Missing bool
   }{
     Context: props.Context,
     Object:  object,
+    Missing: props.Missing,
   })
   return nativeinternal.FeatureProgrammer_IDecomposed{
     Functions:  map[string]*shimast.Node{},
@@ -124,6 +134,7 @@ func (httpQueryProgrammerNamespace) Write(props HttpQueryProgrammer_IProps) *shi
     AllowOptional: props.AllowOptional,
     Type:          props.Type,
     Name:          props.Name,
+    Missing:       true,
   })
   return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
     Modulo:  props.Modulo,
@@ -203,6 +214,7 @@ func (httpQueryProgrammerNamespace) Validate(props struct {
 func httpQueryProgrammer_decode_object(props struct {
   Context nativecontext.ITypiaContext
   Object  *schemametadata.MetadataObjectType
+  Missing bool
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(httpQueryProgrammer_factory, props.Context.Emit)
   input := f.NewIdentifier("input")
@@ -212,9 +224,11 @@ func httpQueryProgrammer_decode_object(props struct {
     properties = append(properties, httpQueryProgrammer_decode_regular_property(struct {
       Context  nativecontext.ITypiaContext
       Property *schemametadata.MetadataProperty
+      Missing  bool
     }{
       Context:  props.Context,
       Property: p,
+      Missing:  props.Missing,
     }))
   }
   return []*shimast.Node{
@@ -253,6 +267,7 @@ func httpQueryProgrammer_decode_object(props struct {
 func httpQueryProgrammer_decode_regular_property(props struct {
   Context  nativecontext.ITypiaContext
   Property *schemametadata.MetadataProperty
+  Missing  bool
 }) *shimast.Node {
   f := nativecontext.EmitFactoryOf(httpQueryProgrammer_factory, props.Context.Emit)
   key := httpProgrammer_property_key(props.Property)
@@ -277,9 +292,9 @@ func httpQueryProgrammer_decode_regular_property(props struct {
       }),
       shimast.NodeFlagsNone,
     )
-    if value.IsRequired() {
-      input = httpQueryProgrammer_assert_required_array(key, input, props.Context.Emit)
-    }
+    // An absent key reads as an empty list. A query string has no other
+    // spelling for `[]`, so a required array decodes it as `[]` rather than as
+    // a missing property, and a nullable one as `null` (samchon/typia#2444).
     input = f.NewCallExpression(
       nativefactories.IdentifierFactory.Access(
         props.Context.Emit,
@@ -301,11 +316,13 @@ func httpQueryProgrammer_decode_regular_property(props struct {
           httpQueryProgrammer_decode_value(struct {
             Context  nativecontext.ITypiaContext
             Type     string
+            Nullable bool
             Coalesce bool
             Input    *shimast.Node
           }{
             Context:  props.Context,
             Type:     typ,
+            Nullable: httpProgrammer_decode_nullable(value),
             Coalesce: false,
             Input:    f.NewIdentifier("elem"),
           }),
@@ -323,18 +340,20 @@ func httpQueryProgrammer_decode_regular_property(props struct {
       Input:    input,
     })
   } else {
-    if value.IsRequired() {
+    if value.IsRequired() && props.Missing {
       input = httpQueryProgrammer_assert_required_value(key, input, props.Context.Emit)
     }
     input = httpQueryProgrammer_decode_value(struct {
       Context  nativecontext.ITypiaContext
       Type     string
+      Nullable bool
       Coalesce bool
       Input    *shimast.Node
     }{
       Context:  props.Context,
       Type:     typ,
-      Coalesce: value.Nullable == false && value.IsRequired() == false,
+      Nullable: httpProgrammer_decode_nullable(value),
+      Coalesce: value.Nullable == false && value.Any == false && value.IsRequired() == false,
       Input:    input,
     })
   }
@@ -350,6 +369,7 @@ func httpQueryProgrammer_decode_regular_property(props struct {
 func httpQueryProgrammer_decode_value(props struct {
   Context  nativecontext.ITypiaContext
   Type     string
+  Nullable bool
   Coalesce bool
   Input    *shimast.Node
 }) *shimast.Node {
@@ -358,7 +378,7 @@ func httpQueryProgrammer_decode_value(props struct {
     httpParameterProgrammer_internal(props.Context, "httpQueryRead"+httpParameterProgrammer_capitalize(props.Type)),
     nil,
     nil,
-    f.NewNodeList([]*shimast.Node{props.Input}),
+    f.NewNodeList(httpProgrammer_read_arguments(props.Type, props.Nullable, props.Input, props.Context.Emit)),
     shimast.NodeFlagsNone,
   )
   if props.Coalesce == false {
@@ -410,43 +430,6 @@ func httpQueryProgrammer_assert_required_value(key string, input *shimast.Node,
   )
 }
 
-func httpQueryProgrammer_assert_required_array(key string, input *shimast.Node, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(httpQueryProgrammer_factory, emit...)
-  value := f.NewIdentifier("value")
-  return f.NewCallExpression(
-    f.NewArrowFunction(
-      nil,
-      nil,
-      f.NewNodeList(nil),
-      nil,
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
-      f.NewBlock(f.NewNodeList([]*shimast.Node{
-        nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-          Name:  "value",
-          Value: input,
-        }, emit...),
-        f.NewIfStatement(
-          f.NewBinaryExpression(
-            nil,
-            nativefactories.ExpressionFactory.Number(0, emit...),
-            nil,
-            f.NewToken(shimast.KindEqualsEqualsEqualsToken),
-            nativefactories.IdentifierFactory.Access(nil, value, "length"),
-          ),
-          f.NewThrowStatement(httpQueryProgrammer_missing_error(key, emit...)),
-          nil,
-        ),
-        f.NewReturnStatement(value),
-      }), true),
-    ),
-    nil,
-    nil,
-    nil,
-    shimast.NodeFlagsNone,
-  )
-}
-
 func httpQueryProgrammer_missing_error(key string, emit ...*shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(httpQueryProgrammer_factory, emit...)
   return f.NewNewExpression(

package/native/core/programmers/iterate/json_schema_jsDocTags.go

@@ -1,10 +1,10 @@
 package iterate
 
 import (
-  "strconv"
   "strings"
 
   nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativeutils "github.com/samchon/typia/packages/typia/native/core/utils"
 )
 
 func json_schema_jsDocTags(schema JsonSchema, jsDocTags []nativemetadata.IJsDocTagInfo) JsonSchema {
@@ -31,6 +31,13 @@ func json_schema_jsDocTags_value(tag nativemetadata.IJsDocTagInfo) (string, bool
   return "", false
 }
 
+// json_schema_jsDocTags_cast reads an `@x-*` tag's text as a JSON value.
+//
+// Numbers use JavaScript's `Number()` grammar, the grammar of the v12 cast this
+// ports (samchon/typia#2442), so `0x10` is 16 while Go-only spellings such as
+// `0x1p4`, `1_000`, and `inf` stay text. Only finite numbers become numbers: the
+// schema is JSON, which has no NaN or infinity, so `NaN`, `Infinity`, and an
+// overflowing `1e400` keep their text instead of degrading to `null`.
 func json_schema_jsDocTags_cast(value string) any {
   if value == "true" {
     return true
@@ -38,8 +45,8 @@ func json_schema_jsDocTags_cast(value string) any {
   if value == "false" {
     return false
   }
-  if num, err := strconv.ParseFloat(value, 64); err == nil {
-    return num
+  if reading := nativeutils.NumberUtil.Read(value); reading.Numeric && reading.Finite {
+    return reading.Value
   }
   if value == "null" {
     return nil

package/native/core/programmers/iterate/json_schema_jsdoc_tags_cast_reads_javascript_numbers_test.go

@@ -0,0 +1,64 @@
+package iterate
+
+import (
+  "encoding/json"
+  "math"
+  "reflect"
+  "testing"
+)
+
+// TestJsonSchemaJsDocTagsCastReadsJavaScriptNumbers verifies the `@x-*`
+// extension cast.
+//
+// The Go port swapped the v12 cast's JavaScript `Number()` grammar for Go's
+// float syntax (samchon/typia#2442). `NaN` and every `Inf` spelling then became
+// floats that `encoding/json` refuses and JavaScript prints as `null`, while
+// `0x10` stopped being a number and `0x1p4` / `1_000` started being one. The
+// expectations restore v12's numbers where they are finite and keep the text
+// where JSON has no number: a non-finite spelling stays a string instead of
+// degrading to `null`, and empty text stays `""` instead of v12's `0`.
+//
+//  1. Cast every row of the issue's table.
+//  2. Assert no result is NaN or an infinity, and every result marshals.
+func TestJsonSchemaJsDocTagsCastReadsJavaScriptNumbers(t *testing.T) {
+  for _, item := range []struct {
+    text     string
+    expected any
+  }{
+    {"NaN", "NaN"},
+    {"nan", "nan"},
+    {"Infinity", "Infinity"},
+    {"-Infinity", "-Infinity"},
+    {"infinity", "infinity"},
+    {"inf", "inf"},
+    {"Inf", "Inf"},
+    {"1e400", "1e400"},
+    {"0x10", float64(16)},
+    {"0b101", float64(5)},
+    {"0o7", float64(7)},
+    {"0x1p4", "0x1p4"},
+    {"1_000", "1_000"},
+    {"", ""},
+    {"-0", float64(0)},
+    {"+5", float64(5)},
+    {".5", 0.5},
+    {"1e3", float64(1000)},
+    {"true", true},
+    {"false", false},
+    {"null", nil},
+    {"text", "text"},
+  } {
+    actual := json_schema_jsDocTags_cast(item.text)
+    if reflect.DeepEqual(actual, item.expected) == false {
+      t.Fatalf("cast(%q) = %#v, expected %#v", item.text, actual, item.expected)
+    }
+    if number, ok := actual.(float64); ok {
+      if math.IsNaN(number) || math.IsInf(number, 0) || math.Signbit(number) && number == 0 {
+        t.Fatalf("cast(%q) = %v is not a JSON number", item.text, number)
+      }
+    }
+    if _, err := json.Marshal(actual); err != nil {
+      t.Fatalf("cast(%q) does not marshal: %v", item.text, err)
+    }
+  }
+}

package/native/core/programmers/llm/LlmEvaluationProgrammer.go

@@ -12,6 +12,7 @@ import (
   nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
   nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativeutils "github.com/samchon/typia/packages/typia/native/core/utils"
 )
 
 type llmEvaluationProgrammerNamespace struct{}
@@ -449,10 +450,13 @@ func llmEvaluation_parse_jsdoc_probability(tags []schemametadata.IJsDocTagInfo)
   if len(texts) != 1 {
     return 0, false, "LLM evaluation @probability is declared more than once; keep only one."
   }
-  value, err := strconv.ParseFloat(texts[0], 64)
-  if err != nil || math.IsNaN(value) || math.IsInf(value, 0) {
+  // The same JavaScript `Number()` grammar every other numeric JSDoc tag reads
+  // (samchon/typia#2442); Go's float syntax would also admit `0x1p-1`.
+  reading := nativeutils.NumberUtil.Read(texts[0])
+  if reading.Numeric == false || reading.Finite == false {
     return 0, false, fmt.Sprintf("LLM evaluation @probability must be a number in [0, 1], but got %q.", texts[0])
   }
+  value := reading.Value
   if value < 0 || value > 1 {
     return 0, false, fmt.Sprintf("LLM evaluation @probability must be in [0, 1], but got %s.", texts[0])
   }

package/native/core/programmers/llm/LlmSchemaProgrammer.go

@@ -15,6 +15,7 @@ import (
   nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
   nativejson "github.com/samchon/typia/packages/typia/native/core/programmers/json"
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativeutils "github.com/samchon/typia/packages/typia/native/core/utils"
 )
 
 type llmSchemaProgrammerNamespace struct{}
@@ -709,11 +710,11 @@ func llmSchemaProgrammer_shift_array(schema map[string]any) map[string]any {
   output := llmSchemaProgrammer_clone(schema)
   tags := []string{}
   if value, ok := output["minItems"]; ok {
-    tags = append(tags, "@minItems "+fmt.Sprint(value))
+    tags = append(tags, "@minItems "+llmSchemaProgrammer_tag_text(value))
     delete(output, "minItems")
   }
   if value, ok := output["maxItems"]; ok {
-    tags = append(tags, "@maxItems "+fmt.Sprint(value))
+    tags = append(tags, "@maxItems "+llmSchemaProgrammer_tag_text(value))
     delete(output, "maxItems")
   }
   if value, ok := output["uniqueItems"].(bool); ok {
@@ -732,7 +733,7 @@ func llmSchemaProgrammer_shift_numeric(schema map[string]any) map[string]any {
   tags := []string{}
   for _, key := range []string{"minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf", "default"} {
     if value, ok := output[key]; ok {
-      tags = append(tags, "@"+key+" "+fmt.Sprint(value))
+      tags = append(tags, "@"+key+" "+llmSchemaProgrammer_tag_text(value))
       delete(output, key)
     }
   }
@@ -745,7 +746,7 @@ func llmSchemaProgrammer_shift_string(schema map[string]any) map[string]any {
   tags := []string{}
   for _, key := range []string{"minLength", "maxLength", "format", "pattern", "contentMediaType", "default"} {
     if value, ok := output[key]; ok {
-      tags = append(tags, "@"+key+" "+fmt.Sprint(value))
+      tags = append(tags, "@"+key+" "+llmSchemaProgrammer_tag_text(value))
       delete(output, key)
     }
   }
@@ -753,6 +754,35 @@ func llmSchemaProgrammer_shift_string(schema map[string]any) map[string]any {
   return output
 }
 
+// llmSchemaProgrammer_tag_text writes a shifted constraint value as `@typia/utils`'
+// OpenApiConstraintShifter does, through JavaScript's template interpolation.
+//
+// A numeric literal from a type tag arrives as the compiler's `jsnum.Number`,
+// whose `String()` already follows JavaScript, but a comment tag's value is a
+// plain float64, and `fmt.Sprint` spells it the Go way: `1e+06` for 1000000,
+// `1e-07` for 1e-7, `+Inf` for an infinity (samchon/typia#2452). Every float is
+// therefore spelled by `NumberUtil.String`, whatever its defined type, and a
+// pointer is followed to the value it holds.
+func llmSchemaProgrammer_tag_text(value any) string {
+  reflected := reflect.ValueOf(value)
+  for reflected.IsValid() && reflected.Kind() == reflect.Pointer && reflected.IsNil() == false {
+    reflected = reflected.Elem()
+  }
+  if reflected.IsValid() == false {
+    return fmt.Sprint(value)
+  }
+  switch reflected.Kind() {
+  case reflect.Float32, reflect.Float64:
+    return nativeutils.NumberUtil.String(reflected.Float())
+  case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+    // JavaScript holds the count as a double, rounding past 2^53.
+    return nativeutils.NumberUtil.String(float64(reflected.Int()))
+  case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+    return nativeutils.NumberUtil.String(float64(reflected.Uint()))
+  }
+  return fmt.Sprint(reflected.Interface())
+}
+
 func llmSchemaProgrammer_write_tag_with_description(schema map[string]any, tags []string) {
   if len(tags) == 0 {
     return

package/native/core/utils/NumberUtil.go

@@ -0,0 +1,195 @@
+package utils
+
+import (
+  "math"
+  "math/big"
+  "regexp"
+  "strconv"
+  "strings"
+  "unicode"
+)
+
+// NumberUtil reads numeric text the way JavaScript's `Number()` does.
+//
+// Tag values and JSDoc extensions are written in TypeScript source, and typia
+// splices numbers it reads from them into the JavaScript it emits, so their
+// grammar is JavaScript's StringNumericLiteral, not Go's float syntax. The two
+// differ in both directions: `strconv.ParseFloat` accepts `NaN`, `Inf`, and
+// `infinity` in any case, hexadecimal floats (`0x1p4`), and digit separators
+// (`1_000`), all of which `Number()` reads as NaN, while it rejects the
+// `0x`/`0o`/`0b` integers that `Number()` accepts. A spelling Go accepts but
+// JavaScript does not also becomes invalid emitted code once it is spliced into
+// a validator (samchon/typia#2442).
+type numberUtilNamespace struct{}
+
+var NumberUtil = numberUtilNamespace{}
+
+// NumberUtil_Reading is the outcome of reading one numeric text.
+type NumberUtil_Reading struct {
+  // Value is what `Number(text)` evaluates to, with negative zero read as zero.
+  Value float64
+
+  // Numeric is false when `Number(text)` is NaN, or when the text is blank.
+  Numeric bool
+
+  // Finite is false for `Infinity`, `-Infinity`, and values that overflow to
+  // them, such as `1e400`. JSON has no spelling for either.
+  Finite bool
+}
+
+// Read evaluates text with the grammar of JavaScript's `Number()`.
+//
+// Surrounding JavaScript whitespace is ignored, as `Number()` ignores it. One
+// deliberate difference remains: `Number("")` and `Number("  ")` are 0, but
+// blank text names no number, so it reads as non-numeric here.
+func (numberUtilNamespace) Read(text string) NumberUtil_Reading {
+  text = strings.TrimFunc(text, numberUtil_isWhiteSpace)
+  if text == "" {
+    return NumberUtil_Reading{}
+  }
+  if match := numberUtil_NON_DECIMAL.FindStringSubmatch(text); match != nil {
+    base := 16
+    switch match[1] {
+    case "o", "O":
+      base = 8
+    case "b", "B":
+      base = 2
+    }
+    integer, ok := new(big.Int).SetString(match[2], base)
+    if ok == false {
+      return NumberUtil_Reading{}
+    }
+    // big.Float rounds to nearest, ties to even, as the specification's
+    // mathematical-value conversion does, and reports overflow as an infinity.
+    value, _ := new(big.Float).SetInt(integer).Float64()
+    return numberUtil_reading(value)
+  }
+  if numberUtil_DECIMAL.MatchString(text) == false {
+    return NumberUtil_Reading{}
+  }
+  if strings.HasSuffix(text, "Infinity") {
+    if strings.HasPrefix(text, "-") {
+      return numberUtil_reading(math.Inf(-1))
+    }
+    return numberUtil_reading(math.Inf(1))
+  }
+  // The pattern admits only plain decimal notation, which ParseFloat reads with
+  // IEEE round-to-nearest. An out-of-range magnitude comes back as an infinity
+  // with ErrRange, which is exactly what `Number()` yields; underflow comes back
+  // as zero without an error, as it does in JavaScript.
+  value, err := strconv.ParseFloat(text, 64)
+  if err != nil && math.IsInf(value, 0) == false {
+    return NumberUtil_Reading{}
+  }
+  return numberUtil_reading(value)
+}
+
+// Integer reads text that spells an integer exactly: decimal digits with an
+// optional sign, or an unsigned `0x` / `0o` / `0b` literal.
+//
+// `Number()` rounds such text to the nearest double, so `9007199254740993`
+// reads as 9007199254740992. Splicing the digits as written keeps a check that
+// reads them as a BigInt literal (`$input % 9007199254740993n`) exact. Any
+// other spelling, including an integer written with an exponent or a point
+// (`1e3`, `1.0`), reports false; its value is the double `Read` returns.
+func (numberUtilNamespace) Integer(text string) (*big.Int, bool) {
+  text = strings.TrimFunc(text, numberUtil_isWhiteSpace)
+  if match := numberUtil_NON_DECIMAL.FindStringSubmatch(text); match != nil {
+    base := 16
+    switch match[1] {
+    case "o", "O":
+      base = 8
+    case "b", "B":
+      base = 2
+    }
+    return new(big.Int).SetString(match[2], base)
+  }
+  if numberUtil_INTEGER.MatchString(text) == false {
+    return nil, false
+  }
+  return new(big.Int).SetString(strings.TrimPrefix(text, "+"), 10)
+}
+
+// Rational is the exact value a finite numeric text writes.
+//
+// `Read` evaluates the text as `Number()` does, rounding it to the nearest
+// double; this keeps what the text says, so a caller can tell whether that
+// double is the written value itself. `9007199254740993` and
+// `9007199254740993.0` both read as 9007199254740992, but their rational value
+// is 9007199254740993. Text `Read` does not find numeric and finite reports
+// false, and so does text `big.Rat` refuses to expand: an exponent outside the
+// int64 range, or a non-zero mantissa whose exponent, net of its fraction
+// digits, lies beyond a million in magnitude (`1e-1000001` reads as 0 but has
+// no exact value here).
+func (numberUtilNamespace) Rational(text string) (*big.Rat, bool) {
+  if reading := NumberUtil.Read(text); reading.Numeric == false || reading.Finite == false {
+    return nil, false
+  }
+  if integer, ok := NumberUtil.Integer(text); ok {
+    return new(big.Rat).SetInt(integer), true
+  }
+  // `Read` admitted only StrDecimalLiteral here, whose spellings `big.Rat`
+  // parses: `5.`, `.5`, `+5`, and `1E3` included.
+  return new(big.Rat).SetString(strings.TrimFunc(text, numberUtil_isWhiteSpace))
+}
+
+// String spells a value exactly as JavaScript's `String(value)` does.
+//
+// That is `Number.prototype.toString`: positional notation from 1e-6 up to
+// 1e21, exponent notation outside with a signed exponent of no padded zeros
+// (`1e+21`, `1e-7`), and `NaN`, `Infinity`, `-Infinity`, and `0` for negative
+// zero. Each result is also JavaScript source text that evaluates to the value,
+// negative zero reading back as zero.
+func (numberUtilNamespace) String(value float64) string {
+  switch {
+  case math.IsNaN(value):
+    return "NaN"
+  case math.IsInf(value, 1):
+    return "Infinity"
+  case math.IsInf(value, -1):
+    return "-Infinity"
+  case value == 0:
+    return "0"
+  }
+  magnitude := math.Abs(value)
+  if magnitude >= 1e-6 && magnitude < 1e21 {
+    return strconv.FormatFloat(value, 'f', -1, 64)
+  }
+  // Go pads the exponent to two digits (`1e-07`); JavaScript does not.
+  text := strconv.FormatFloat(value, 'e', -1, 64)
+  index := strings.IndexByte(text, 'e')
+  mantissa, sign, digits := text[:index], text[index+1:index+2], strings.TrimLeft(text[index+2:], "0")
+  return mantissa + "e" + sign + digits
+}
+
+func numberUtil_reading(value float64) NumberUtil_Reading {
+  if value == 0 {
+    value = 0 // negative zero
+  }
+  return NumberUtil_Reading{
+    Value:   value,
+    Numeric: true,
+    Finite:  math.IsInf(value, 0) == false,
+  }
+}
+
+// numberUtil_isWhiteSpace is StrWhiteSpaceChar: WhiteSpace and LineTerminator.
+func numberUtil_isWhiteSpace(r rune) bool {
+  switch r {
+  case '\t', '\v', '\f', ' ', 0x00a0, 0xfeff, '\n', '\r', 0x2028, 0x2029:
+    return true
+  }
+  return unicode.Is(unicode.Zs, r)
+}
+
+// numberUtil_NON_DECIMAL is NonDecimalIntegerLiteral without separators. It
+// takes no sign: `Number("-0x10")` is NaN.
+var numberUtil_NON_DECIMAL = regexp.MustCompile(`^0([xXoObB])([0-9a-fA-F]+)$`)
+
+// numberUtil_INTEGER is a decimal integer with an optional sign.
+var numberUtil_INTEGER = regexp.MustCompile(`^[+-]?[0-9]+$`)
+
+// numberUtil_DECIMAL is StrDecimalLiteral: an optional sign before `Infinity`
+// or a decimal literal whose digits may omit either side of the point, with an
+// optional exponent. Separators are not part of it.
+var numberUtil_DECIMAL = regexp.MustCompile(`^[+-]?(?:Infinity|(?:[0-9]+\.?[0-9]*|\.[0-9]+)(?:[eE][+-]?[0-9]+)?)$`)

package/native/core/utils/number_util_rational_keeps_written_value_test.go

@@ -0,0 +1,62 @@
+package utils
+
+import (
+  "math/big"
+  "testing"
+)
+
+// TestNumberUtilRationalKeepsWrittenValue verifies NumberUtil.Rational keeps the
+// value a numeric text writes, not the double `Number()` rounds it to.
+//
+// A bigint comment tag must know whether a double is the written integer itself
+// before it states a bound with it (samchon/typia#2457), so the exact value has
+// to survive every spelling `Read` admits: points, exponents, signs, radix
+// prefixes, and surrounding whitespace. Text `Read` refuses, or finds infinite,
+// has no exact value.
+//
+//  1. Keep integers past 2^53, in every spelling.
+//  2. Keep fractions and point-edge spellings exactly.
+//  3. Refuse what `Read` refuses, and infinities.
+func TestNumberUtilRationalKeepsWrittenValue(t *testing.T) {
+  exact := func(text string) *big.Rat {
+    value, ok := new(big.Rat).SetString(text)
+    if ok == false {
+      t.Fatalf("bad expectation %s", text)
+    }
+    return value
+  }
+  for _, item := range []struct {
+    text     string
+    expected string
+  }{
+    // 1. integers past 2^53
+    {"9007199254740993", "9007199254740993"},
+    {"9007199254740993.0", "9007199254740993"},
+    {"9.007199254740993e15", "9007199254740993"},
+    {"+9007199254740993", "9007199254740993"},
+    {"-9007199254740993", "-9007199254740993"},
+    {"0x20000000000001", "9007199254740993"},
+    {"0o400000000000000001", "9007199254740993"},
+    {" 9007199254740993\t", "9007199254740993"},
+    {"\u00a09007199254740993.0 ", "9007199254740993"},
+    {"\t.5\u2028", "1/2"},
+    // 2. fractions and point edges
+    {".5", "1/2"},
+    {"5.", "5"},
+    {"-.5e1", "-5"},
+    {"1e-3", "1/1000"},
+    {"-0", "0"},
+  } {
+    value, ok := NumberUtil.Rational(item.text)
+    if ok == false || value.Cmp(exact(item.expected)) != 0 {
+      t.Fatalf("%q must be exactly %s, got %v (ok=%v)", item.text, item.expected, value, ok)
+    }
+  }
+
+  // 3. what Read refuses, and infinities
+  for _, text := range []string{"", " ", "1_000", "0x1p4", "inf", "NaN", "-0x10", "Infinity", "-Infinity", "1e400"} {
+    if value, ok := NumberUtil.Rational(text); ok {
+      t.Fatalf("%q must have no exact value, got %v", text, value)
+    }
+  }
+}