typia 13.0.0-dev.20260430 → 13.0.0-dev.20260502-2

package/native/core/programmers/helpers/FunctionProgrammer.go

@@ -1,116 +1,116 @@
 package helpers
 
 import (
-	"fmt"
+  "fmt"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
 )
 
 type FunctionProgrammer struct {
-	Method         string
-	local_         map[string]bool
-	unions_        map[string]*functionProgrammer_union
-	unionOrder_    []string
-	variables_     map[string]*shimast.Node
-	variableOrder_ []string
-	sequence_      int
-	disableDeclare bool
+  Method         string
+  local_         map[string]bool
+  unions_        map[string]*functionProgrammer_union
+  unionOrder_    []string
+  variables_     map[string]*shimast.Node
+  variableOrder_ []string
+  sequence_      int
+  disableDeclare bool
 }
 
 type functionProgrammer_union struct {
-	name  string
-	value *shimast.Node
+  name  string
+  value *shimast.Node
 }
 
 var functionProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
 func NewFunctionProgrammer(method string) *FunctionProgrammer {
-	return &FunctionProgrammer{
-		Method:         method,
-		local_:         map[string]bool{},
-		unions_:        map[string]*functionProgrammer_union{},
-		unionOrder_:    []string{},
-		variables_:     map[string]*shimast.Node{},
-		variableOrder_: []string{},
-	}
+  return &FunctionProgrammer{
+    Method:         method,
+    local_:         map[string]bool{},
+    unions_:        map[string]*functionProgrammer_union{},
+    unionOrder_:    []string{},
+    variables_:     map[string]*shimast.Node{},
+    variableOrder_: []string{},
+  }
 }
 
 func (p *FunctionProgrammer) UseLocal(name string) string {
-	p.local_[name] = true
-	return name
+  p.local_[name] = true
+  return name
 }
 
 func (p *FunctionProgrammer) HasLocal(name string) bool {
-	return p.local_[name]
+  return p.local_[name]
 }
 
 func (p *FunctionProgrammer) Declare(includeUnions ...bool) []*shimast.Node {
-	if p.disableDeclare {
-		return []*shimast.Node{}
-	}
-	output := []*shimast.Node{}
-	for _, name := range p.variableOrder_ {
-		value := p.variables_[name]
-		output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-			Name:  name,
-			Value: value,
-		}))
-	}
-	enabled := true
-	if len(includeUnions) != 0 {
-		enabled = includeUnions[0]
-	}
-	if enabled {
-		for _, key := range p.unionOrder_ {
-			tuple := p.unions_[key]
-			output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-				Name:  tuple.name,
-				Value: tuple.value,
-			}))
-		}
-	}
-	return output
+  if p.disableDeclare {
+    return []*shimast.Node{}
+  }
+  output := []*shimast.Node{}
+  for _, name := range p.variableOrder_ {
+    value := p.variables_[name]
+    output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+      Name:  name,
+      Value: value,
+    }))
+  }
+  enabled := true
+  if len(includeUnions) != 0 {
+    enabled = includeUnions[0]
+  }
+  if enabled {
+    for _, key := range p.unionOrder_ {
+      tuple := p.unions_[key]
+      output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+        Name:  tuple.name,
+        Value: tuple.value,
+      }))
+    }
+  }
+  return output
 }
 
 func (p *FunctionProgrammer) DeclareUnions() []*shimast.Node {
-	if p.disableDeclare {
-		return []*shimast.Node{}
-	}
-	output := []*shimast.Node{}
-	for _, key := range p.unionOrder_ {
-		tuple := p.unions_[key]
-		output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-			Name:  tuple.name,
-			Value: tuple.value,
-		}))
-	}
-	return output
+  if p.disableDeclare {
+    return []*shimast.Node{}
+  }
+  output := []*shimast.Node{}
+  for _, key := range p.unionOrder_ {
+    tuple := p.unions_[key]
+    output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+      Name:  tuple.name,
+      Value: tuple.value,
+    }))
+  }
+  return output
 }
 
 func (p *FunctionProgrammer) Increment() int {
-	p.sequence_++
-	return p.sequence_
+  p.sequence_++
+  return p.sequence_
 }
 
 func (p *FunctionProgrammer) EmplaceUnion(prefix string, name string, factory func() *shimast.Node) string {
-	key := prefix + "::" + name
-	if oldbie, ok := p.unions_[key]; ok {
-		return oldbie.name
-	}
-	index := len(p.unions_)
-	accessor := fmt.Sprintf("%sp%d", prefix, index)
-	tuple := &functionProgrammer_union{name: accessor}
-	p.unions_[key] = tuple
-	p.unionOrder_ = append(p.unionOrder_, key)
-	tuple.value = factory()
-	return accessor
+  key := prefix + "::" + name
+  if oldbie, ok := p.unions_[key]; ok {
+    return oldbie.name
+  }
+  index := len(p.unions_)
+  accessor := fmt.Sprintf("%sp%d", prefix, index)
+  tuple := &functionProgrammer_union{name: accessor}
+  p.unions_[key] = tuple
+  p.unionOrder_ = append(p.unionOrder_, key)
+  tuple.value = factory()
+  return accessor
 }
 
 func (p *FunctionProgrammer) EmplaceVariable(name string, value *shimast.Expression) *shimast.Node {
-	if _, ok := p.variables_[name]; !ok {
-		p.variableOrder_ = append(p.variableOrder_, name)
-	}
-	p.variables_[name] = value
-	return functionProgrammer_factory.NewIdentifier(name)
+  if _, ok := p.variables_[name]; !ok {
+    p.variableOrder_ = append(p.variableOrder_, name)
+  }
+  p.variables_[name] = value
+  return functionProgrammer_factory.NewIdentifier(name)
 }

package/native/core/programmers/helpers/HttpMetadataUtil.go

@@ -7,24 +7,24 @@ type httpMetadataUtilNamespace struct{}
 var HttpMetadataUtil = httpMetadataUtilNamespace{}
 
 func (httpMetadataUtilNamespace) Atomics(metadata *nativemetadata.MetadataSchema) map[string]struct{} {
-	output := map[string]struct{}{}
-	for _, atomic := range metadata.Atomics {
-		output[atomic.Type] = struct{}{}
-	}
-	for _, constant := range metadata.Constants {
-		output[constant.Type] = struct{}{}
-	}
-	if len(metadata.Templates) != 0 {
-		output["string"] = struct{}{}
-	}
-	return output
+  output := map[string]struct{}{}
+  for _, atomic := range metadata.Atomics {
+    output[atomic.Type] = struct{}{}
+  }
+  for _, constant := range metadata.Constants {
+    output[constant.Type] = struct{}{}
+  }
+  if len(metadata.Templates) != 0 {
+    output["string"] = struct{}{}
+  }
+  return output
 }
 
 func (httpMetadataUtilNamespace) IsUnion(metadata *nativemetadata.MetadataSchema) bool {
-	return len(HttpMetadataUtil.Atomics(metadata))+
-		len(metadata.Arrays)+
-		len(metadata.Tuples)+
-		len(metadata.Natives)+
-		len(metadata.Maps)+
-		len(metadata.Objects) > 1
+  return len(HttpMetadataUtil.Atomics(metadata))+
+    len(metadata.Arrays)+
+    len(metadata.Tuples)+
+    len(metadata.Natives)+
+    len(metadata.Maps)+
+    len(metadata.Objects) > 1
 }

package/native/core/programmers/helpers/ICheckEntry.go

@@ -3,12 +3,12 @@ package helpers
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
 type ICheckEntry struct {
-	Expected   string
-	Expression *shimast.Node
-	Conditions [][]ICheckEntry_ICondition
+  Expected   string
+  Expression *shimast.Node
+  Conditions [][]ICheckEntry_ICondition
 }
 
 type ICheckEntry_ICondition struct {
-	Expected   string
-	Expression *shimast.Node
+  Expected   string
+  Expression *shimast.Node
 }

package/native/core/programmers/helpers/IExpressionEntry.go

@@ -1,13 +1,13 @@
 package helpers
 
 import (
-	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 IExpressionEntry struct {
-	Input      *shimast.Node
-	Key        *nativemetadata.MetadataSchema
-	Meta       *nativemetadata.MetadataSchema
-	Expression *shimast.Node
+  Input      *shimast.Node
+  Key        *nativemetadata.MetadataSchema
+  Meta       *nativemetadata.MetadataSchema
+  Expression *shimast.Node
 }

package/native/core/programmers/helpers/NotationJoiner.go

@@ -1,9 +1,9 @@
 package helpers
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 type notationJoinerNamespace struct{}
@@ -11,184 +11,184 @@ type notationJoinerNamespace struct{}
 var NotationJoiner = notationJoinerNamespace{}
 
 type NotationJoiner_ObjectProps struct {
-	Rename  func(str string) string
-	Input   *shimast.Expression
-	Entries []IExpressionEntry
+  Rename  func(str string) string
+  Input   *shimast.Expression
+  Entries []IExpressionEntry
 }
 
 type NotationJoiner_TupleProps struct {
-	Elements []*shimast.Expression
-	Rest     *shimast.Expression
+  Elements []*shimast.Expression
+  Rest     *shimast.Expression
 }
 
 type NotationJoiner_ArrayProps struct {
-	Input *shimast.Expression
-	Arrow *shimast.Expression
+  Input *shimast.Expression
+  Arrow *shimast.Expression
 }
 
 var notationJoiner_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
 func (notationJoinerNamespace) Object(props NotationJoiner_ObjectProps) *shimast.Node {
-	if len(props.Entries) == 0 {
-		return notationJoiner_factory.NewIdentifier("{}")
-	}
+  if len(props.Entries) == 0 {
+    return notationJoiner_factory.NewIdentifier("{}")
+  }
 
-	regular := []IExpressionEntry{}
-	dynamic := []IExpressionEntry{}
-	for _, entry := range props.Entries {
-		if entry.Key.IsSoleLiteral() {
-			regular = append(regular, entry)
-		} else {
-			dynamic = append(dynamic, entry)
-		}
-	}
+  regular := []IExpressionEntry{}
+  dynamic := []IExpressionEntry{}
+  for _, entry := range props.Entries {
+    if entry.Key.IsSoleLiteral() {
+      regular = append(regular, entry)
+    } else {
+      dynamic = append(dynamic, entry)
+    }
+  }
 
-	properties := make([]*shimast.Node, 0, len(regular))
-	for _, entry := range regular {
-		str := props.Rename(*entry.Key.GetSoleLiteral())
-		properties = append(properties, notationJoiner_factory.NewPropertyAssignment(
-			nil,
-			nativefactories.IdentifierFactory.Identifier(str),
-			nil,
-			nil,
-			entry.Expression,
-		))
-	}
-	literal := notationJoiner_factory.NewObjectLiteralExpression(
-		notationJoiner_factory.NewNodeList(properties),
-		true,
-	)
-	if len(dynamic) == 0 {
-		return literal
-	}
+  properties := make([]*shimast.Node, 0, len(regular))
+  for _, entry := range regular {
+    str := props.Rename(*entry.Key.GetSoleLiteral())
+    properties = append(properties, notationJoiner_factory.NewPropertyAssignment(
+      nil,
+      nativefactories.IdentifierFactory.Identifier(str),
+      nil,
+      nil,
+      entry.Expression,
+    ))
+  }
+  literal := notationJoiner_factory.NewObjectLiteralExpression(
+    notationJoiner_factory.NewNodeList(properties),
+    true,
+  )
+  if len(dynamic) == 0 {
+    return literal
+  }
 
-	key := notationJoiner_factory.NewIdentifier("key")
-	output := notationJoiner_factory.NewIdentifier("output")
-	statements := []*shimast.Node{}
-	if len(regular) != 0 {
-		statements = append(statements, notationJoiner_regular_skip(regular))
-	}
-	for _, entry := range dynamic {
-		statements = append(statements, notationJoiner_factory.NewIfStatement(
-			notationJoiner_factory.NewCallExpression(
-				notationJoiner_factory.NewIdentifier("RegExp(/"+cloneJoiner_metadata_to_pattern(struct {
-					top      bool
-					metadata *nativemetadata.MetadataSchema
-				}{top: true, metadata: entry.Key})+"/).test"),
-				nil,
-				nil,
-				notationJoiner_factory.NewNodeList([]*shimast.Node{key}),
-				shimast.NodeFlagsNone,
-			),
-			notationJoiner_factory.NewBlock(
-				notationJoiner_factory.NewNodeList([]*shimast.Node{
-					notationJoiner_factory.NewExpressionStatement(
-						notationJoiner_factory.NewBinaryExpression(
-							nil,
-							notationJoiner_factory.NewElementAccessExpression(output, nil, key, shimast.NodeFlagsNone),
-							nil,
-							notationJoiner_factory.NewToken(shimast.KindEqualsToken),
-							entry.Expression,
-						),
-					),
-					notationJoiner_factory.NewContinueStatement(nil),
-				}),
-				false,
-			),
-			nil,
-		))
-	}
+  key := notationJoiner_factory.NewIdentifier("key")
+  output := notationJoiner_factory.NewIdentifier("output")
+  statements := []*shimast.Node{}
+  if len(regular) != 0 {
+    statements = append(statements, notationJoiner_regular_skip(regular))
+  }
+  for _, entry := range dynamic {
+    statements = append(statements, notationJoiner_factory.NewIfStatement(
+      notationJoiner_factory.NewCallExpression(
+        notationJoiner_factory.NewIdentifier("RegExp(/"+cloneJoiner_metadata_to_pattern(struct {
+          top      bool
+          metadata *nativemetadata.MetadataSchema
+        }{top: true, metadata: entry.Key})+"/).test"),
+        nil,
+        nil,
+        notationJoiner_factory.NewNodeList([]*shimast.Node{key}),
+        shimast.NodeFlagsNone,
+      ),
+      notationJoiner_factory.NewBlock(
+        notationJoiner_factory.NewNodeList([]*shimast.Node{
+          notationJoiner_factory.NewExpressionStatement(
+            notationJoiner_factory.NewBinaryExpression(
+              nil,
+              notationJoiner_factory.NewElementAccessExpression(output, nil, key, shimast.NodeFlagsNone),
+              nil,
+              notationJoiner_factory.NewToken(shimast.KindEqualsToken),
+              entry.Expression,
+            ),
+          ),
+          notationJoiner_factory.NewContinueStatement(nil),
+        }),
+        false,
+      ),
+      nil,
+    ))
+  }
 
-	return notationJoiner_factory.NewBlock(
-		notationJoiner_factory.NewNodeList([]*shimast.Node{
-			nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-				Name: "output",
-				Value: notationJoiner_factory.NewAsExpression(
-					literal,
-					nativefactories.TypeFactory.Keyword("any"),
-				),
-			}),
-			notationJoiner_factory.NewForInOrOfStatement(
-				shimast.KindForOfStatement,
-				nil,
-				nativefactories.StatementFactory.Entry(nativefactories.StatementFactory_EntryProps{Key: "key", Value: "value"}),
-				notationJoiner_factory.NewCallExpression(
-					notationJoiner_factory.NewIdentifier("Object.entries"),
-					nil,
-					nil,
-					notationJoiner_factory.NewNodeList([]*shimast.Node{props.Input}),
-					shimast.NodeFlagsNone,
-				),
-				notationJoiner_factory.NewBlock(notationJoiner_factory.NewNodeList(statements), false),
-			),
-			notationJoiner_factory.NewReturnStatement(output),
-		}),
-		false,
-	)
+  return notationJoiner_factory.NewBlock(
+    notationJoiner_factory.NewNodeList([]*shimast.Node{
+      nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+        Name: "output",
+        Value: notationJoiner_factory.NewAsExpression(
+          literal,
+          nativefactories.TypeFactory.Keyword("any"),
+        ),
+      }),
+      notationJoiner_factory.NewForInOrOfStatement(
+        shimast.KindForOfStatement,
+        nil,
+        nativefactories.StatementFactory.Entry(nativefactories.StatementFactory_EntryProps{Key: "key", Value: "value"}),
+        notationJoiner_factory.NewCallExpression(
+          notationJoiner_factory.NewIdentifier("Object.entries"),
+          nil,
+          nil,
+          notationJoiner_factory.NewNodeList([]*shimast.Node{props.Input}),
+          shimast.NodeFlagsNone,
+        ),
+        notationJoiner_factory.NewBlock(notationJoiner_factory.NewNodeList(statements), false),
+      ),
+      notationJoiner_factory.NewReturnStatement(output),
+    }),
+    false,
+  )
 }
 
 func (notationJoinerNamespace) Tuple(props NotationJoiner_TupleProps) *shimast.Node {
-	elements := make([]*shimast.Node, 0, len(props.Elements)+1)
-	for _, elem := range props.Elements {
-		elements = append(elements, elem)
-	}
-	if props.Rest != nil {
-		elements = append(elements, notationJoiner_factory.NewSpreadElement(props.Rest))
-	}
-	return notationJoiner_factory.NewAsExpression(
-		notationJoiner_factory.NewArrayLiteralExpression(
-			notationJoiner_factory.NewNodeList(elements),
-			true,
-		),
-		nativefactories.TypeFactory.Keyword("any"),
-	)
+  elements := make([]*shimast.Node, 0, len(props.Elements)+1)
+  for _, elem := range props.Elements {
+    elements = append(elements, elem)
+  }
+  if props.Rest != nil {
+    elements = append(elements, notationJoiner_factory.NewSpreadElement(props.Rest))
+  }
+  return notationJoiner_factory.NewAsExpression(
+    notationJoiner_factory.NewArrayLiteralExpression(
+      notationJoiner_factory.NewNodeList(elements),
+      true,
+    ),
+    nativefactories.TypeFactory.Keyword("any"),
+  )
 }
 
 func (notationJoinerNamespace) Array(props NotationJoiner_ArrayProps) *shimast.Node {
-	return notationJoiner_factory.NewCallExpression(
-		nativefactories.IdentifierFactory.Access(props.Input, "map"),
-		nil,
-		nil,
-		notationJoiner_factory.NewNodeList([]*shimast.Node{props.Arrow}),
-		shimast.NodeFlagsNone,
-	)
+  return notationJoiner_factory.NewCallExpression(
+    nativefactories.IdentifierFactory.Access(props.Input, "map"),
+    nil,
+    nil,
+    notationJoiner_factory.NewNodeList([]*shimast.Node{props.Arrow}),
+    shimast.NodeFlagsNone,
+  )
 }
 
 func notationJoiner_regular_skip(regular []IExpressionEntry) *shimast.Node {
-	elements := make([]*shimast.Node, 0, len(regular))
-	for _, entry := range regular {
-		elements = append(elements, notationJoiner_factory.NewStringLiteral(*entry.Key.GetSoleLiteral(), shimast.TokenFlagsNone))
-	}
-	return notationJoiner_factory.NewIfStatement(
-		notationJoiner_factory.NewCallExpression(
-			nativefactories.IdentifierFactory.Access(
-				notationJoiner_factory.NewArrayLiteralExpression(notationJoiner_factory.NewNodeList(elements), false),
-				"some",
-			),
-			nil,
-			nil,
-			notationJoiner_factory.NewNodeList([]*shimast.Node{
-				notationJoiner_factory.NewArrowFunction(
-					nil,
-					nil,
-					notationJoiner_factory.NewNodeList([]*shimast.Node{
-						nativefactories.IdentifierFactory.Parameter("regular", nil, nil),
-					}),
-					nil,
-					nil,
-					notationJoiner_factory.NewToken(shimast.KindEqualsGreaterThanToken),
-					notationJoiner_factory.NewBinaryExpression(
-						nil,
-						notationJoiner_factory.NewIdentifier("regular"),
-						nil,
-						notationJoiner_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
-						notationJoiner_factory.NewIdentifier("key"),
-					),
-				),
-			}),
-			shimast.NodeFlagsNone,
-		),
-		notationJoiner_factory.NewContinueStatement(nil),
-		nil,
-	)
+  elements := make([]*shimast.Node, 0, len(regular))
+  for _, entry := range regular {
+    elements = append(elements, notationJoiner_factory.NewStringLiteral(*entry.Key.GetSoleLiteral(), shimast.TokenFlagsNone))
+  }
+  return notationJoiner_factory.NewIfStatement(
+    notationJoiner_factory.NewCallExpression(
+      nativefactories.IdentifierFactory.Access(
+        notationJoiner_factory.NewArrayLiteralExpression(notationJoiner_factory.NewNodeList(elements), false),
+        "some",
+      ),
+      nil,
+      nil,
+      notationJoiner_factory.NewNodeList([]*shimast.Node{
+        notationJoiner_factory.NewArrowFunction(
+          nil,
+          nil,
+          notationJoiner_factory.NewNodeList([]*shimast.Node{
+            nativefactories.IdentifierFactory.Parameter("regular", nil, nil),
+          }),
+          nil,
+          nil,
+          notationJoiner_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+          notationJoiner_factory.NewBinaryExpression(
+            nil,
+            notationJoiner_factory.NewIdentifier("regular"),
+            nil,
+            notationJoiner_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+            notationJoiner_factory.NewIdentifier("key"),
+          ),
+        ),
+      }),
+      shimast.NodeFlagsNone,
+    ),
+    notationJoiner_factory.NewContinueStatement(nil),
+    nil,
+  )
 }

package/native/core/programmers/helpers/OptionPredicator.go

@@ -7,17 +7,17 @@ type optionPredicatorNamespace struct{}
 var OptionPredicator optionPredicatorNamespace
 
 func (optionPredicatorNamespace) Numeric(options nativecontext.ITransformOptions) bool {
-	return OptionPredicator.Finite(options) || options.Numeric != nil && *options.Numeric
+  return OptionPredicator.Finite(options) || options.Numeric != nil && *options.Numeric
 }
 
 func (optionPredicatorNamespace) Functional(options nativecontext.ITransformOptions) bool {
-	return options.Functional != nil && *options.Functional
+  return options.Functional != nil && *options.Functional
 }
 
 func (optionPredicatorNamespace) Finite(options nativecontext.ITransformOptions) bool {
-	return options.Finite != nil && *options.Finite
+  return options.Finite != nil && *options.Finite
 }
 
 func (optionPredicatorNamespace) Undefined(options nativecontext.ITransformOptions) bool {
-	return options.Undefined == nil || *options.Undefined
+  return options.Undefined == nil || *options.Undefined
 }