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

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

@@ -1,150 +1,150 @@
 package iterate
 
 import (
-	"strings"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 type Decode_union_objectProps struct {
-	Checker func(next Decode_union_object_next) *shimast.Node
-	Decoder func(next Decode_union_object_next) *shimast.Node
-	Success func(exp *shimast.Expression) *shimast.Node
-	Escaper func(next Decode_union_object_escape) *shimast.Node
-	Objects []*nativemetadata.MetadataObjectType
-	Input   *shimast.Expression
-	Explore any
+  Checker func(next Decode_union_object_next) *shimast.Node
+  Decoder func(next Decode_union_object_next) *shimast.Node
+  Success func(exp *shimast.Expression) *shimast.Node
+  Escaper func(next Decode_union_object_escape) *shimast.Node
+  Objects []*nativemetadata.MetadataObjectType
+  Input   *shimast.Expression
+  Explore any
 }
 
 type Decode_union_object_next struct {
-	Input   *shimast.Expression
-	Object  *nativemetadata.MetadataObjectType
-	Explore any
+  Input   *shimast.Expression
+  Object  *nativemetadata.MetadataObjectType
+  Explore any
 }
 
 type Decode_union_object_escape struct {
-	Input    *shimast.Expression
-	Expected string
+  Input    *shimast.Expression
+  Expected string
 }
 
 func Decode_union_object(props Decode_union_objectProps) *shimast.Node {
-	unions := make([]decode_union_object_IUnion, 0, len(props.Objects))
-	names := make([]string, 0, len(props.Objects))
-	for _, object := range props.Objects {
-		obj := object
-		names = append(names, obj.Name)
-		unions = append(unions, decode_union_object_IUnion{
-			Type: "object",
-			Is: func() *shimast.Node {
-				return props.Success(props.Checker(Decode_union_object_next{
-					Input:   props.Input,
-					Explore: props.Explore,
-					Object:  obj,
-				}))
-			},
-			Value: func() *shimast.Node {
-				return props.Decoder(Decode_union_object_next{
-					Input:   props.Input,
-					Explore: props.Explore,
-					Object:  obj,
-				})
-			},
-		})
-	}
-	return decode_union_object_factory.NewCallExpression(
-		decode_union_object_factory.NewArrowFunction(
-			nil,
-			nil,
-			decode_union_object_factory.NewNodeList(nil),
-			nil,
-			nil,
-			decode_union_object_factory.NewToken(shimast.KindEqualsGreaterThanToken),
-			decode_union_object_iterate(decode_union_object_iterateProps{
-				Escaper:  props.Escaper,
-				Input:    props.Input,
-				Unions:   unions,
-				Expected: "(" + strings.Join(names, " | ") + ")",
-			}),
-		),
-		nil,
-		nil,
-		nil,
-		shimast.NodeFlagsNone,
-	)
+  unions := make([]decode_union_object_IUnion, 0, len(props.Objects))
+  names := make([]string, 0, len(props.Objects))
+  for _, object := range props.Objects {
+    obj := object
+    names = append(names, obj.Name)
+    unions = append(unions, decode_union_object_IUnion{
+      Type: "object",
+      Is: func() *shimast.Node {
+        return props.Success(props.Checker(Decode_union_object_next{
+          Input:   props.Input,
+          Explore: props.Explore,
+          Object:  obj,
+        }))
+      },
+      Value: func() *shimast.Node {
+        return props.Decoder(Decode_union_object_next{
+          Input:   props.Input,
+          Explore: props.Explore,
+          Object:  obj,
+        })
+      },
+    })
+  }
+  return decode_union_object_factory.NewCallExpression(
+    decode_union_object_factory.NewArrowFunction(
+      nil,
+      nil,
+      decode_union_object_factory.NewNodeList(nil),
+      nil,
+      nil,
+      decode_union_object_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+      decode_union_object_iterate(decode_union_object_iterateProps{
+        Escaper:  props.Escaper,
+        Input:    props.Input,
+        Unions:   unions,
+        Expected: "(" + strings.Join(names, " | ") + ")",
+      }),
+    ),
+    nil,
+    nil,
+    nil,
+    shimast.NodeFlagsNone,
+  )
 }
 
 type decode_union_object_iterateProps struct {
-	Escaper  func(next Decode_union_object_escape) *shimast.Node
-	Unions   []decode_union_object_IUnion
-	Expected string
-	Input    *shimast.Expression
+  Escaper  func(next Decode_union_object_escape) *shimast.Node
+  Unions   []decode_union_object_IUnion
+  Expected string
+  Input    *shimast.Expression
 }
 
 type decode_union_object_IBranch struct {
-	Condition *shimast.Node
-	Value     *shimast.Node
+  Condition *shimast.Node
+  Value     *shimast.Node
 }
 
 func decode_union_object_iterate(props decode_union_object_iterateProps) *shimast.Node {
-	branches := []decode_union_object_IBranch{}
-	for _, u := range props.Unions {
-		condition := u.Is()
-		if condition.Kind == shimast.KindTrueKeyword {
-			branches = append(branches, decode_union_object_IBranch{
-				Condition: nil,
-				Value:     u.Value(),
-			})
-			break
-		}
-		branches = append(branches, decode_union_object_IBranch{
-			Condition: condition,
-			Value:     u.Value(),
-		})
-	}
-	if len(branches) == 0 {
-		return decode_union_object_factory.NewBlock(
-			decode_union_object_factory.NewNodeList([]*shimast.Node{
-				props.Escaper(Decode_union_object_escape{
-					Input:    props.Input,
-					Expected: props.Expected,
-				}),
-			}),
-			true,
-		)
-	}
-	if len(branches) == 1 && branches[0].Condition == nil {
-		return branches[0].Value
-	}
+  branches := []decode_union_object_IBranch{}
+  for _, u := range props.Unions {
+    condition := u.Is()
+    if condition.Kind == shimast.KindTrueKeyword {
+      branches = append(branches, decode_union_object_IBranch{
+        Condition: nil,
+        Value:     u.Value(),
+      })
+      break
+    }
+    branches = append(branches, decode_union_object_IBranch{
+      Condition: condition,
+      Value:     u.Value(),
+    })
+  }
+  if len(branches) == 0 {
+    return decode_union_object_factory.NewBlock(
+      decode_union_object_factory.NewNodeList([]*shimast.Node{
+        props.Escaper(Decode_union_object_escape{
+          Input:    props.Input,
+          Expected: props.Expected,
+        }),
+      }),
+      true,
+    )
+  }
+  if len(branches) == 1 && branches[0].Condition == nil {
+    return branches[0].Value
+  }
 
-	statements := make([]*shimast.Node, 0, len(branches)+1)
-	for _, b := range branches {
-		if b.Condition != nil {
-			statements = append(statements, decode_union_object_factory.NewIfStatement(
-				b.Condition,
-				decode_union_object_factory.NewReturnStatement(b.Value),
-				nil,
-			))
-		} else {
-			statements = append(statements, decode_union_object_factory.NewReturnStatement(b.Value))
-		}
-	}
-	if branches[len(branches)-1].Condition != nil {
-		statements = append(statements, props.Escaper(Decode_union_object_escape{
-			Input:    props.Input,
-			Expected: props.Expected,
-		}))
-	}
-	return decode_union_object_factory.NewBlock(
-		decode_union_object_factory.NewNodeList(statements),
-		true,
-	)
+  statements := make([]*shimast.Node, 0, len(branches)+1)
+  for _, b := range branches {
+    if b.Condition != nil {
+      statements = append(statements, decode_union_object_factory.NewIfStatement(
+        b.Condition,
+        decode_union_object_factory.NewReturnStatement(b.Value),
+        nil,
+      ))
+    } else {
+      statements = append(statements, decode_union_object_factory.NewReturnStatement(b.Value))
+    }
+  }
+  if branches[len(branches)-1].Condition != nil {
+    statements = append(statements, props.Escaper(Decode_union_object_escape{
+      Input:    props.Input,
+      Expected: props.Expected,
+    }))
+  }
+  return decode_union_object_factory.NewBlock(
+    decode_union_object_factory.NewNodeList(statements),
+    true,
+  )
 }
 
 type decode_union_object_IUnion struct {
-	Type  string
-	Is    func() *shimast.Node
-	Value func() *shimast.Node
+  Type  string
+  Is    func() *shimast.Node
+  Value func() *shimast.Node
 }
 
 var decode_union_object_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

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

@@ -1,172 +1,172 @@
 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 Feature_object_entriesProps struct {
-	Config  Feature_object_entriesConfig
-	Context nativecontext.ITypiaContext
-	Object  *nativemetadata.MetadataObjectType
-	Input   *shimast.Expression
-	From    string
+  Config  Feature_object_entriesConfig
+  Context nativecontext.ITypiaContext
+  Object  *nativemetadata.MetadataObjectType
+  Input   *shimast.Expression
+  From    string
 }
 
 type Feature_object_entriesConfig struct {
-	Decoder func(props Feature_object_entriesDecoderProps) *shimast.Node
-	Path    bool
-	Trace   bool
+  Decoder func(props Feature_object_entriesDecoderProps) *shimast.Node
+  Path    bool
+  Trace   bool
 }
 
 type Feature_object_entriesDecoderProps struct {
-	Metadata *nativemetadata.MetadataSchema
-	Input    *shimast.Expression
-	Explore  Feature_object_entriesExplore
+  Metadata *nativemetadata.MetadataSchema
+  Input    *shimast.Expression
+  Explore  Feature_object_entriesExplore
 }
 
 type Feature_object_entriesExplore struct {
-	Tracable bool
-	Source   string
-	From     string
-	Postfix  string
+  Tracable bool
+  Source   string
+  From     string
+  Postfix  string
 }
 
 func Feature_object_entries(props Feature_object_entriesProps) []nativehelpers.IExpressionEntry {
-	output := make([]nativehelpers.IExpressionEntry, 0, len(props.Object.Properties))
-	from := props.From
-	if from == "" {
-		from = "object"
-	}
-	for _, next := range props.Object.Properties {
-		sole := next.Key.GetSoleLiteral()
-		propInput := feature_object_entries_property_input(props.Input, sole)
-		postfix := ""
-		if props.Config.Trace {
-			if sole != nil {
-				postfix = nativefactories.IdentifierFactory.Postfix(*sole)
-			} else {
-				feature_object_entries_internal(props.Context, feature_object_entries_ACCESSOR)
-				postfix = feature_object_entries_get_internal_text(props.Context, feature_object_entries_ACCESSOR) + "(key)"
-			}
-		}
-		output = append(output, nativehelpers.IExpressionEntry{
-			Input: propInput,
-			Key:   next.Key,
-			Meta:  next.Value,
-			Expression: props.Config.Decoder(Feature_object_entriesDecoderProps{
-				Input:    propInput,
-				Metadata: next.Value,
-				Explore: Feature_object_entriesExplore{
-					Tracable: props.Config.Path || props.Config.Trace,
-					Source:   "function",
-					From:     from,
-					Postfix:  postfix,
-				},
-			}),
-		})
-	}
-	return output
+  output := make([]nativehelpers.IExpressionEntry, 0, len(props.Object.Properties))
+  from := props.From
+  if from == "" {
+    from = "object"
+  }
+  for _, next := range props.Object.Properties {
+    sole := next.Key.GetSoleLiteral()
+    propInput := feature_object_entries_property_input(props.Input, sole)
+    postfix := ""
+    if props.Config.Trace {
+      if sole != nil {
+        postfix = nativefactories.IdentifierFactory.Postfix(*sole)
+      } else {
+        feature_object_entries_internal(props.Context, feature_object_entries_ACCESSOR)
+        postfix = feature_object_entries_get_internal_text(props.Context, feature_object_entries_ACCESSOR) + "(key)"
+      }
+    }
+    output = append(output, nativehelpers.IExpressionEntry{
+      Input: propInput,
+      Key:   next.Key,
+      Meta:  next.Value,
+      Expression: props.Config.Decoder(Feature_object_entriesDecoderProps{
+        Input:    propInput,
+        Metadata: next.Value,
+        Explore: Feature_object_entriesExplore{
+          Tracable: props.Config.Path || props.Config.Trace,
+          Source:   "function",
+          From:     from,
+          Postfix:  postfix,
+        },
+      }),
+    })
+  }
+  return output
 }
 
 func feature_object_entries_property_input(input *shimast.Expression, sole *string) *shimast.Node {
-	if sole == nil {
-		return feature_object_entries_factory.NewIdentifier("value")
-	}
-	if feature_object_entries_variable(*sole) {
-		return feature_object_entries_factory.NewPropertyAccessExpression(
-			input,
-			nil,
-			feature_object_entries_factory.NewIdentifier(*sole),
-			shimast.NodeFlagsNone,
-		)
-	}
-	return feature_object_entries_factory.NewElementAccessExpression(
-		input,
-		nil,
-		feature_object_entries_factory.NewStringLiteral(*sole, shimast.TokenFlagsNone),
-		shimast.NodeFlagsNone,
-	)
+  if sole == nil {
+    return feature_object_entries_factory.NewIdentifier("value")
+  }
+  if feature_object_entries_variable(*sole) {
+    return feature_object_entries_factory.NewPropertyAccessExpression(
+      input,
+      nil,
+      feature_object_entries_factory.NewIdentifier(*sole),
+      shimast.NodeFlagsNone,
+    )
+  }
+  return feature_object_entries_factory.NewElementAccessExpression(
+    input,
+    nil,
+    feature_object_entries_factory.NewStringLiteral(*sole, shimast.TokenFlagsNone),
+    shimast.NodeFlagsNone,
+  )
 }
 
 func feature_object_entries_variable(str string) bool {
-	if len(str) == 0 || feature_object_entries_reserved[str] {
-		return false
-	}
-	for i := 0; i < len(str); i++ {
-		c := str[i]
-		if i == 0 {
-			if !(('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_' || c == '$') {
-				return false
-			}
-		} else if !(('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || ('0' <= c && c <= '9') || c == '_' || c == '$') {
-			return false
-		}
-	}
-	return true
+  if len(str) == 0 || feature_object_entries_reserved[str] {
+    return false
+  }
+  for i := 0; i < len(str); i++ {
+    c := str[i]
+    if i == 0 {
+      if !(('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_' || c == '$') {
+        return false
+      }
+    } else if !(('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || ('0' <= c && c <= '9') || c == '_' || c == '$') {
+      return false
+    }
+  }
+  return true
 }
 
 func feature_object_entries_internal(context nativecontext.ITypiaContext, name string) *shimast.Node {
-	if importer, ok := context.Importer.(interface{ Internal(string) *shimast.Node }); ok {
-		return importer.Internal(name)
-	}
-	return feature_object_entries_factory.NewIdentifier(name)
+  if importer, ok := context.Importer.(interface{ Internal(string) *shimast.Node }); ok {
+    return importer.Internal(name)
+  }
+  return feature_object_entries_factory.NewIdentifier(name)
 }
 
 func feature_object_entries_get_internal_text(context nativecontext.ITypiaContext, name string) string {
-	if importer, ok := context.Importer.(interface{ GetInternalText(string) string }); ok {
-		return importer.GetInternalText(name)
-	}
-	return name
+  if importer, ok := context.Importer.(interface{ GetInternalText(string) string }); ok {
+    return importer.GetInternalText(name)
+  }
+  return name
 }
 
 const feature_object_entries_ACCESSOR = "accessExpressionAsString"
 
 var feature_object_entries_reserved = map[string]bool{
-	"break":      true,
-	"case":       true,
-	"catch":      true,
-	"class":      true,
-	"const":      true,
-	"continue":   true,
-	"debugger":   true,
-	"default":    true,
-	"delete":     true,
-	"do":         true,
-	"else":       true,
-	"enum":       true,
-	"export":     true,
-	"extends":    true,
-	"false":      true,
-	"finally":    true,
-	"for":        true,
-	"function":   true,
-	"if":         true,
-	"import":     true,
-	"in":         true,
-	"instanceof": true,
-	"module":     true,
-	"new":        true,
-	"null":       true,
-	"package":    true,
-	"public":     true,
-	"private":    true,
-	"protected":  true,
-	"return":     true,
-	"super":      true,
-	"switch":     true,
-	"this":       true,
-	"throw":      true,
-	"true":       true,
-	"try":        true,
-	"typeof":     true,
-	"var":        true,
-	"void":       true,
-	"while":      true,
-	"with":       true,
+  "break":      true,
+  "case":       true,
+  "catch":      true,
+  "class":      true,
+  "const":      true,
+  "continue":   true,
+  "debugger":   true,
+  "default":    true,
+  "delete":     true,
+  "do":         true,
+  "else":       true,
+  "enum":       true,
+  "export":     true,
+  "extends":    true,
+  "false":      true,
+  "finally":    true,
+  "for":        true,
+  "function":   true,
+  "if":         true,
+  "import":     true,
+  "in":         true,
+  "instanceof": true,
+  "module":     true,
+  "new":        true,
+  "null":       true,
+  "package":    true,
+  "public":     true,
+  "private":    true,
+  "protected":  true,
+  "return":     true,
+  "super":      true,
+  "switch":     true,
+  "this":       true,
+  "throw":      true,
+  "true":       true,
+  "try":        true,
+  "typeof":     true,
+  "var":        true,
+  "void":       true,
+  "while":      true,
+  "with":       true,
 }
 
 var feature_object_entries_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})