typia 13.0.0-dev.20260501 → 13.0.0-dev.20260506

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

@@ -1,169 +1,169 @@
 package iterate
 
 import (
-	"fmt"
+  "fmt"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-	nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
-	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 type Check_numberProps struct {
-	Numeric bool
-	Context nativecontext.ITypiaContext
-	Atomic  *nativemetadata.MetadataAtomic
-	Input   *shimast.Expression
+  Numeric bool
+  Context nativecontext.ITypiaContext
+  Atomic  *nativemetadata.MetadataAtomic
+  Input   *shimast.Expression
 }
 
 func Check_number(props Check_numberProps) nativehelpers.ICheckEntry {
-	base := check_number_factory.NewBinaryExpression(
-		nil,
-		check_number_factory.NewStringLiteral("number", shimast.TokenFlagsNone),
-		nil,
-		check_number_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
-		check_number_factory.NewTypeOfExpression(props.Input),
-	)
-	var addition *shimast.Node
-	if props.Numeric {
-		if nativehelpers.OptionPredicator.Finite(props.Context.Options) {
-			addition = check_number_factory.NewCallExpression(
-				check_number_factory.NewIdentifier("Number.isFinite"),
-				nil,
-				nil,
-				check_number_factory.NewNodeList([]*shimast.Node{props.Input}),
-				shimast.NodeFlagsNone,
-			)
-		} else if nativehelpers.OptionPredicator.Numeric(props.Context.Options) {
-			addition = check_number_factory.NewPrefixUnaryExpression(
-				shimast.KindExclamationToken,
-				check_number_factory.NewCallExpression(
-					check_number_factory.NewIdentifier("Number.isNaN"),
-					nil,
-					nil,
-					check_number_factory.NewNodeList([]*shimast.Node{props.Input}),
-					shimast.NodeFlagsNone,
-				),
-			)
-		}
-	}
-	conditions := check_numeric_type_tags(check_numeric_type_tagsProps{
-		Context:  props.Context,
-		Atomic:   props.Atomic,
-		Input:    props.Input,
-		Addition: addition,
-	})
-	expression := base
-	if addition != nil && len(conditions) == 0 {
-		expression = check_number_factory.NewBinaryExpression(
-			nil,
-			base,
-			nil,
-			check_number_factory.NewToken(shimast.KindAmpersandAmpersandToken),
-			addition,
-		)
-	}
-	return nativehelpers.ICheckEntry{
-		Expected:   props.Atomic.GetName(),
-		Expression: expression,
-		Conditions: conditions,
-	}
+  base := check_number_factory.NewBinaryExpression(
+    nil,
+    check_number_factory.NewStringLiteral("number", shimast.TokenFlagsNone),
+    nil,
+    check_number_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+    check_number_factory.NewTypeOfExpression(props.Input),
+  )
+  var addition *shimast.Node
+  if props.Numeric {
+    if nativehelpers.OptionPredicator.Finite(props.Context.Options) {
+      addition = check_number_factory.NewCallExpression(
+        check_number_factory.NewIdentifier("Number.isFinite"),
+        nil,
+        nil,
+        check_number_factory.NewNodeList([]*shimast.Node{props.Input}),
+        shimast.NodeFlagsNone,
+      )
+    } else if nativehelpers.OptionPredicator.Numeric(props.Context.Options) {
+      addition = check_number_factory.NewPrefixUnaryExpression(
+        shimast.KindExclamationToken,
+        check_number_factory.NewCallExpression(
+          check_number_factory.NewIdentifier("Number.isNaN"),
+          nil,
+          nil,
+          check_number_factory.NewNodeList([]*shimast.Node{props.Input}),
+          shimast.NodeFlagsNone,
+        ),
+      )
+    }
+  }
+  conditions := check_numeric_type_tags(check_numeric_type_tagsProps{
+    Context:  props.Context,
+    Atomic:   props.Atomic,
+    Input:    props.Input,
+    Addition: addition,
+  })
+  expression := base
+  if addition != nil && len(conditions) == 0 {
+    expression = check_number_factory.NewBinaryExpression(
+      nil,
+      base,
+      nil,
+      check_number_factory.NewToken(shimast.KindAmpersandAmpersandToken),
+      addition,
+    )
+  }
+  return nativehelpers.ICheckEntry{
+    Expected:   props.Atomic.GetName(),
+    Expression: expression,
+    Conditions: conditions,
+  }
 }
 
 type check_numeric_type_tagsProps struct {
-	Context  nativecontext.ITypiaContext
-	Atomic   *nativemetadata.MetadataAtomic
-	Addition *shimast.Expression
-	Input    *shimast.Expression
+  Context  nativecontext.ITypiaContext
+  Atomic   *nativemetadata.MetadataAtomic
+  Addition *shimast.Expression
+  Input    *shimast.Expression
 }
 
 func check_numeric_type_tags(props check_numeric_type_tagsProps) [][]nativehelpers.ICheckEntry_ICondition {
-	output := [][]nativehelpers.ICheckEntry_ICondition{}
-	for _, row := range props.Atomic.Tags {
-		tags := check_number_filter_validate(row)
-		if len(tags) == 0 {
-			continue
-		}
-		conditions := []nativehelpers.ICheckEntry_ICondition{}
-		if props.Addition != nil && !check_numeric_type_tags_covers_addition(tags) {
-			conditions = append(conditions, nativehelpers.ICheckEntry_ICondition{
-				Expected:   "number",
-				Expression: props.Addition,
-			})
-		}
-		for _, tag := range tags {
-			conditions = append(conditions, nativehelpers.ICheckEntry_ICondition{
-				Expected:   fmt.Sprintf("number & %s", tag.Name),
-				Expression: check_number_transpile(props.Context, tag.Validate)(props.Input),
-			})
-		}
-		output = append(output, conditions)
-	}
-	return output
+  output := [][]nativehelpers.ICheckEntry_ICondition{}
+  for _, row := range props.Atomic.Tags {
+    tags := check_number_filter_validate(row)
+    if len(tags) == 0 {
+      continue
+    }
+    conditions := []nativehelpers.ICheckEntry_ICondition{}
+    if props.Addition != nil && !check_numeric_type_tags_covers_addition(tags) {
+      conditions = append(conditions, nativehelpers.ICheckEntry_ICondition{
+        Expected:   "number",
+        Expression: props.Addition,
+      })
+    }
+    for _, tag := range tags {
+      conditions = append(conditions, nativehelpers.ICheckEntry_ICondition{
+        Expected:   fmt.Sprintf("number & %s", tag.Name),
+        Expression: check_number_transpile(props.Context, tag.Validate)(props.Input),
+      })
+    }
+    output = append(output, conditions)
+  }
+  return output
 }
 
 func check_numeric_type_tags_covers_addition(row []nativemetadata.IMetadataTypeTag) bool {
-	if check_number_some(row, func(tag nativemetadata.IMetadataTypeTag) bool {
-		return tag.Kind == "type" &&
-			(tag.Value == "int32" ||
-				tag.Value == "uint32" ||
-				tag.Value == "int64" ||
-				tag.Value == "uint64" ||
-				tag.Value == "float")
-	}) {
-		return true
-	}
-	if check_number_some(row, func(tag nativemetadata.IMetadataTypeTag) bool {
-		return tag.Kind == "multipleOf" && check_number_is_number(tag.Value)
-	}) {
-		return true
-	}
-	return check_number_some(row, func(tag nativemetadata.IMetadataTypeTag) bool {
-		return (tag.Kind == "minimum" || tag.Kind == "exclusiveMinimum") && check_number_is_number(tag.Value)
-	}) && check_number_some(row, func(tag nativemetadata.IMetadataTypeTag) bool {
-		return (tag.Kind == "maximum" || tag.Kind == "exclusiveMaximum") && check_number_is_number(tag.Value)
-	})
+  if check_number_some(row, func(tag nativemetadata.IMetadataTypeTag) bool {
+    return tag.Kind == "type" &&
+      (tag.Value == "int32" ||
+        tag.Value == "uint32" ||
+        tag.Value == "int64" ||
+        tag.Value == "uint64" ||
+        tag.Value == "float")
+  }) {
+    return true
+  }
+  if check_number_some(row, func(tag nativemetadata.IMetadataTypeTag) bool {
+    return tag.Kind == "multipleOf" && check_number_is_number(tag.Value)
+  }) {
+    return true
+  }
+  return check_number_some(row, func(tag nativemetadata.IMetadataTypeTag) bool {
+    return (tag.Kind == "minimum" || tag.Kind == "exclusiveMinimum") && check_number_is_number(tag.Value)
+  }) && check_number_some(row, func(tag nativemetadata.IMetadataTypeTag) bool {
+    return (tag.Kind == "maximum" || tag.Kind == "exclusiveMaximum") && check_number_is_number(tag.Value)
+  })
 }
 
 func check_number_filter_validate(row []nativemetadata.IMetadataTypeTag) []nativemetadata.IMetadataTypeTag {
-	tags := []nativemetadata.IMetadataTypeTag{}
-	for _, tag := range row {
-		if tag.Validate != "" {
-			tags = append(tags, tag)
-		}
-	}
-	return tags
+  tags := []nativemetadata.IMetadataTypeTag{}
+  for _, tag := range row {
+    if tag.Validate != "" {
+      tags = append(tags, tag)
+    }
+  }
+  return tags
 }
 
 func check_number_some(row []nativemetadata.IMetadataTypeTag, pred func(tag nativemetadata.IMetadataTypeTag) bool) bool {
-	for _, tag := range row {
-		if pred(tag) {
-			return true
-		}
-	}
-	return false
+  for _, tag := range row {
+    if pred(tag) {
+      return true
+    }
+  }
+  return false
 }
 
 func check_number_is_number(value any) bool {
-	switch value.(type) {
-	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64:
-		return true
-	default:
-		return false
-	}
+  switch value.(type) {
+  case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64:
+    return true
+  default:
+    return false
+  }
 }
 
 func check_number_transpile(context nativecontext.ITypiaContext, script string) func(input *shimast.Expression) *shimast.Node {
-	var importer nativefactories.ExpressionFactory_Importer
-	if v, ok := context.Importer.(nativefactories.ExpressionFactory_Importer); ok {
-		importer = v
-	}
-	return nativefactories.ExpressionFactory.Transpile(nativefactories.ExpressionFactory_TranspileProps{
-		Transformer: context.Transformer,
-		Importer:    importer,
-		Script:      script,
-	})
+  var importer nativefactories.ExpressionFactory_Importer
+  if v, ok := context.Importer.(nativefactories.ExpressionFactory_Importer); ok {
+    importer = v
+  }
+  return nativefactories.ExpressionFactory.Transpile(nativefactories.ExpressionFactory_TranspileProps{
+    Transformer: context.Transformer,
+    Importer:    importer,
+    Script:      script,
+  })
 }
 
 var check_number_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

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

@@ -1,89 +1,89 @@
 package iterate
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
 )
 
 type Check_objectProps struct {
-	Config  Check_object_IConfig
-	Context nativecontext.ITypiaContext
-	Input   *shimast.Expression
-	Entries []nativehelpers.IExpressionEntry
+  Config  Check_object_IConfig
+  Context nativecontext.ITypiaContext
+  Input   *shimast.Expression
+  Entries []nativehelpers.IExpressionEntry
 }
 
 type Check_object_IConfig struct {
-	Equals      bool
-	Assert      bool
-	Undefined   bool
-	Halt        func(exp *shimast.Expression) *shimast.Node
-	Reduce      func(a *shimast.Expression, b *shimast.Expression) *shimast.Node
-	Positive    *shimast.Expression
-	Superfluous func(value *shimast.Expression, description *shimast.Expression) *shimast.Node
-	Entries     *shimast.Expression
+  Equals      bool
+  Assert      bool
+  Undefined   bool
+  Halt        func(exp *shimast.Expression) *shimast.Node
+  Reduce      func(a *shimast.Expression, b *shimast.Expression) *shimast.Node
+  Positive    *shimast.Expression
+  Superfluous func(value *shimast.Expression, description *shimast.Expression) *shimast.Node
+  Entries     *shimast.Expression
 }
 
 func Check_object(props Check_objectProps) *shimast.Node {
-	regular := []nativehelpers.IExpressionEntry{}
-	dynamic := []nativehelpers.IExpressionEntry{}
-	for _, entry := range props.Entries {
-		if entry.Key.IsSoleLiteral() {
-			regular = append(regular, entry)
-		} else {
-			dynamic = append(dynamic, entry)
-		}
-	}
-	flags := make([]*shimast.Node, 0, len(regular)+1)
-	for _, entry := range regular {
-		flags = append(flags, entry.Expression)
-	}
+  regular := []nativehelpers.IExpressionEntry{}
+  dynamic := []nativehelpers.IExpressionEntry{}
+  for _, entry := range props.Entries {
+    if entry.Key.IsSoleLiteral() {
+      regular = append(regular, entry)
+    } else {
+      dynamic = append(dynamic, entry)
+    }
+  }
+  flags := make([]*shimast.Node, 0, len(regular)+1)
+  for _, entry := range regular {
+    flags = append(flags, entry.Expression)
+  }
 
-	if props.Config.Equals == false && len(dynamic) == 0 {
-		if len(regular) == 0 {
-			return props.Config.Positive
-		}
-		return check_object_reduce(check_object_reduceProps{
-			Config:      props.Config,
-			Expressions: flags,
-		})
-	}
+  if props.Config.Equals == false && len(dynamic) == 0 {
+    if len(regular) == 0 {
+      return props.Config.Positive
+    }
+    return check_object_reduce(check_object_reduceProps{
+      Config:      props.Config,
+      Expressions: flags,
+    })
+  }
 
-	flags = append(flags, Check_dynamic_properties(Check_dynamic_propertiesProps{
-		Config:  props.Config,
-		Context: props.Context,
-		Input:   props.Input,
-		Regular: regular,
-		Dynamic: dynamic,
-	}))
-	return check_object_reduce(check_object_reduceProps{
-		Config:      props.Config,
-		Expressions: flags,
-	})
+  flags = append(flags, Check_dynamic_properties(Check_dynamic_propertiesProps{
+    Config:  props.Config,
+    Context: props.Context,
+    Input:   props.Input,
+    Regular: regular,
+    Dynamic: dynamic,
+  }))
+  return check_object_reduce(check_object_reduceProps{
+    Config:      props.Config,
+    Expressions: flags,
+  })
 }
 
 type check_object_reduceProps struct {
-	Config      Check_object_IConfig
-	Expressions []*shimast.Node
+  Config      Check_object_IConfig
+  Expressions []*shimast.Node
 }
 
 func check_object_reduce(props check_object_reduceProps) *shimast.Node {
-	if len(props.Expressions) == 0 {
-		return props.Config.Positive
-	}
-	if props.Config.Assert {
-		output := props.Expressions[0]
-		for _, next := range props.Expressions[1:] {
-			output = props.Config.Reduce(output, next)
-		}
-		return output
-	}
-	return Check_everything(
-		check_object_factory.NewArrayLiteralExpression(
-			check_object_factory.NewNodeList(props.Expressions),
-			false,
-		),
-	)
+  if len(props.Expressions) == 0 {
+    return props.Config.Positive
+  }
+  if props.Config.Assert {
+    output := props.Expressions[0]
+    for _, next := range props.Expressions[1:] {
+      output = props.Config.Reduce(output, next)
+    }
+    return output
+  }
+  return Check_everything(
+    check_object_factory.NewArrayLiteralExpression(
+      check_object_factory.NewNodeList(props.Expressions),
+      false,
+    ),
+  )
 }
 
 var check_object_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

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

@@ -1,73 +1,73 @@
 package iterate
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-	nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
-	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 type Check_stringProps struct {
-	Context nativecontext.ITypiaContext
-	Atomic  *nativemetadata.MetadataAtomic
-	Input   *shimast.Expression
+  Context nativecontext.ITypiaContext
+  Atomic  *nativemetadata.MetadataAtomic
+  Input   *shimast.Expression
 }
 
 func Check_string(props Check_stringProps) nativehelpers.ICheckEntry {
-	conditions := check_string_type_tags(props)
-	return nativehelpers.ICheckEntry{
-		Expected: props.Atomic.GetName(),
-		Expression: check_string_factory.NewBinaryExpression(
-			nil,
-			check_string_factory.NewStringLiteral("string", shimast.TokenFlagsNone),
-			nil,
-			check_string_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
-			check_string_factory.NewTypeOfExpression(props.Input),
-		),
-		Conditions: conditions,
-	}
+  conditions := check_string_type_tags(props)
+  return nativehelpers.ICheckEntry{
+    Expected: props.Atomic.GetName(),
+    Expression: check_string_factory.NewBinaryExpression(
+      nil,
+      check_string_factory.NewStringLiteral("string", shimast.TokenFlagsNone),
+      nil,
+      check_string_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+      check_string_factory.NewTypeOfExpression(props.Input),
+    ),
+    Conditions: conditions,
+  }
 }
 
 func check_string_type_tags(props Check_stringProps) [][]nativehelpers.ICheckEntry_ICondition {
-	output := [][]nativehelpers.ICheckEntry_ICondition{}
-	for _, row := range props.Atomic.Tags {
-		tags := check_string_filter_validate(row)
-		if len(tags) == 0 {
-			continue
-		}
-		conditions := make([]nativehelpers.ICheckEntry_ICondition, 0, len(tags))
-		for _, tag := range tags {
-			conditions = append(conditions, nativehelpers.ICheckEntry_ICondition{
-				Expected:   "string & " + tag.Name,
-				Expression: check_string_transpile(props.Context, tag.Validate)(props.Input),
-			})
-		}
-		output = append(output, conditions)
-	}
-	return output
+  output := [][]nativehelpers.ICheckEntry_ICondition{}
+  for _, row := range props.Atomic.Tags {
+    tags := check_string_filter_validate(row)
+    if len(tags) == 0 {
+      continue
+    }
+    conditions := make([]nativehelpers.ICheckEntry_ICondition, 0, len(tags))
+    for _, tag := range tags {
+      conditions = append(conditions, nativehelpers.ICheckEntry_ICondition{
+        Expected:   "string & " + tag.Name,
+        Expression: check_string_transpile(props.Context, tag.Validate)(props.Input),
+      })
+    }
+    output = append(output, conditions)
+  }
+  return output
 }
 
 func check_string_filter_validate(row []nativemetadata.IMetadataTypeTag) []nativemetadata.IMetadataTypeTag {
-	tags := []nativemetadata.IMetadataTypeTag{}
-	for _, tag := range row {
-		if tag.Validate != "" {
-			tags = append(tags, tag)
-		}
-	}
-	return tags
+  tags := []nativemetadata.IMetadataTypeTag{}
+  for _, tag := range row {
+    if tag.Validate != "" {
+      tags = append(tags, tag)
+    }
+  }
+  return tags
 }
 
 func check_string_transpile(context nativecontext.ITypiaContext, script string) func(input *shimast.Expression) *shimast.Node {
-	var importer nativefactories.ExpressionFactory_Importer
-	if v, ok := context.Importer.(nativefactories.ExpressionFactory_Importer); ok {
-		importer = v
-	}
-	return nativefactories.ExpressionFactory.Transpile(nativefactories.ExpressionFactory_TranspileProps{
-		Transformer: context.Transformer,
-		Importer:    importer,
-		Script:      script,
-	})
+  var importer nativefactories.ExpressionFactory_Importer
+  if v, ok := context.Importer.(nativefactories.ExpressionFactory_Importer); ok {
+    importer = v
+  }
+  return nativefactories.ExpressionFactory.Transpile(nativefactories.ExpressionFactory_TranspileProps{
+    Transformer: context.Transformer,
+    Importer:    importer,
+    Script:      script,
+  })
 }
 
 var check_string_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})