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

package/native/core/factories/StatementFactory.go

@@ -7,99 +7,99 @@ type statementFactoryNamespace struct{}
 var StatementFactory = statementFactoryNamespace{}
 
 type StatementFactory_MutProps struct {
-	Name        string
-	Type        *shimast.TypeNode
-	Initializer *shimast.Expression
+  Name        string
+  Type        *shimast.TypeNode
+  Initializer *shimast.Expression
 }
 
 type StatementFactory_ConstantProps struct {
-	Name  string
-	Type  *shimast.TypeNode
-	Value *shimast.Expression
+  Name  string
+  Type  *shimast.TypeNode
+  Value *shimast.Expression
 }
 
 type StatementFactory_EntryProps struct {
-	Key   string
-	Value string
+  Key   string
+  Value string
 }
 
 var statementFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
 func (statementFactoryNamespace) Mut(props StatementFactory_MutProps) *shimast.Node {
-	typeNode := props.Type
-	if typeNode == nil && props.Initializer == nil {
-		typeNode = TypeFactory.Keyword("any")
-	}
-	declaration := statementFactory_factory.NewVariableDeclaration(
-		statementFactory_factory.NewIdentifier(props.Name),
-		nil,
-		typeNode,
-		props.Initializer,
-	)
-	return statementFactory_factory.NewVariableStatement(
-		nil,
-		statementFactory_factory.NewVariableDeclarationList(
-			statementFactory_factory.NewNodeList([]*shimast.Node{declaration}),
-			shimast.NodeFlagsLet,
-		),
-	)
+  typeNode := props.Type
+  if typeNode == nil && props.Initializer == nil {
+    typeNode = TypeFactory.Keyword("any")
+  }
+  declaration := statementFactory_factory.NewVariableDeclaration(
+    statementFactory_factory.NewIdentifier(props.Name),
+    nil,
+    typeNode,
+    props.Initializer,
+  )
+  return statementFactory_factory.NewVariableStatement(
+    nil,
+    statementFactory_factory.NewVariableDeclarationList(
+      statementFactory_factory.NewNodeList([]*shimast.Node{declaration}),
+      shimast.NodeFlagsLet,
+    ),
+  )
 }
 
 func (statementFactoryNamespace) Constant(props StatementFactory_ConstantProps) *shimast.Node {
-	typeNode := props.Type
-	if typeNode == nil && props.Value == nil {
-		typeNode = TypeFactory.Keyword("any")
-	}
-	declaration := statementFactory_factory.NewVariableDeclaration(
-		statementFactory_factory.NewIdentifier(props.Name),
-		nil,
-		typeNode,
-		props.Value,
-	)
-	return statementFactory_factory.NewVariableStatement(
-		nil,
-		statementFactory_factory.NewVariableDeclarationList(
-			statementFactory_factory.NewNodeList([]*shimast.Node{declaration}),
-			shimast.NodeFlagsConst,
-		),
-	)
+  typeNode := props.Type
+  if typeNode == nil && props.Value == nil {
+    typeNode = TypeFactory.Keyword("any")
+  }
+  declaration := statementFactory_factory.NewVariableDeclaration(
+    statementFactory_factory.NewIdentifier(props.Name),
+    nil,
+    typeNode,
+    props.Value,
+  )
+  return statementFactory_factory.NewVariableStatement(
+    nil,
+    statementFactory_factory.NewVariableDeclarationList(
+      statementFactory_factory.NewNodeList([]*shimast.Node{declaration}),
+      shimast.NodeFlagsConst,
+    ),
+  )
 }
 
 func (statementFactoryNamespace) Entry(props StatementFactory_EntryProps) *shimast.Node {
-	key := statementFactory_factory.NewBindingElement(
-		nil,
-		nil,
-		statementFactory_factory.NewIdentifier(props.Key),
-		nil,
-	)
-	value := statementFactory_factory.NewBindingElement(
-		nil,
-		nil,
-		statementFactory_factory.NewIdentifier(props.Value),
-		nil,
-	)
-	pattern := statementFactory_factory.NewBindingPattern(
-		shimast.KindArrayBindingPattern,
-		statementFactory_factory.NewNodeList([]*shimast.Node{key, value}),
-	)
-	declaration := statementFactory_factory.NewVariableDeclaration(pattern, nil, nil, nil)
-	return statementFactory_factory.NewVariableDeclarationList(
-		statementFactory_factory.NewNodeList([]*shimast.Node{declaration}),
-		shimast.NodeFlagsConst,
-	)
+  key := statementFactory_factory.NewBindingElement(
+    nil,
+    nil,
+    statementFactory_factory.NewIdentifier(props.Key),
+    nil,
+  )
+  value := statementFactory_factory.NewBindingElement(
+    nil,
+    nil,
+    statementFactory_factory.NewIdentifier(props.Value),
+    nil,
+  )
+  pattern := statementFactory_factory.NewBindingPattern(
+    shimast.KindArrayBindingPattern,
+    statementFactory_factory.NewNodeList([]*shimast.Node{key, value}),
+  )
+  declaration := statementFactory_factory.NewVariableDeclaration(pattern, nil, nil, nil)
+  return statementFactory_factory.NewVariableDeclarationList(
+    statementFactory_factory.NewNodeList([]*shimast.Node{declaration}),
+    shimast.NodeFlagsConst,
+  )
 }
 
 func (statementFactoryNamespace) Transpile(script string) *shimast.Node {
-	return statementFactory_factory.NewExpressionStatement(
-		statementFactory_factory.NewIdentifier(script),
-	)
+  return statementFactory_factory.NewExpressionStatement(
+    statementFactory_factory.NewIdentifier(script),
+  )
 }
 
 func (statementFactoryNamespace) Block(expression *shimast.Expression) *shimast.Node {
-	return statementFactory_factory.NewBlock(
-		statementFactory_factory.NewNodeList([]*shimast.Node{
-			statementFactory_factory.NewExpressionStatement(expression),
-		}),
-		true,
-	)
+  return statementFactory_factory.NewBlock(
+    statementFactory_factory.NewNodeList([]*shimast.Node{
+      statementFactory_factory.NewExpressionStatement(expression),
+    }),
+    true,
+  )
 }

package/native/core/factories/TemplateFactory.go

@@ -9,69 +9,69 @@ type templateFactoryNamespace struct{}
 var TemplateFactory = templateFactoryNamespace{}
 
 type TemplateFactory_IIterator struct {
-	Value string
-	Index int
+  Value string
+  Index int
 }
 
 var templateFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
 func (templateFactoryNamespace) Generate(expressions []*shimast.Expression) *shimast.Node {
-	allString := true
-	for _, exp := range expressions {
-		if !shimast.IsStringLiteral(exp) {
-			allString = false
-			break
-		}
-	}
-	if allString {
-		values := make([]string, 0, len(expressions))
-		for _, str := range expressions {
-			values = append(values, str.Text())
-		}
-		return templateFactory_factory.NewStringLiteral(strings.Join(values, ""), shimast.TokenFlagsNone)
-	}
-	iterator := &TemplateFactory_IIterator{Value: "", Index: 0}
-	templateFactory_gather(expressions, iterator)
-	head := templateFactory_factory.NewTemplateHead(iterator.Value, iterator.Value, shimast.TokenFlagsNone)
-	spans := []*shimast.Node{}
-	for {
-		elem := expressions[iterator.Index]
-		iterator.Index++
-		templateFactory_gather(expressions, iterator)
-		broken := iterator.Index == len(expressions)
-		var literal *shimast.TemplateMiddleOrTail
-		if broken {
-			literal = templateFactory_factory.NewTemplateTail(iterator.Value, iterator.Value, shimast.TokenFlagsNone)
-		} else {
-			literal = templateFactory_factory.NewTemplateMiddle(iterator.Value, iterator.Value, shimast.TokenFlagsNone)
-		}
-		spans = append(spans, templateFactory_factory.NewTemplateSpan(elem, literal))
-		if broken {
-			break
-		}
-	}
-	return templateFactory_factory.NewTemplateExpression(
-		head,
-		templateFactory_factory.NewNodeList(spans),
-	)
+  allString := true
+  for _, exp := range expressions {
+    if !shimast.IsStringLiteral(exp) {
+      allString = false
+      break
+    }
+  }
+  if allString {
+    values := make([]string, 0, len(expressions))
+    for _, str := range expressions {
+      values = append(values, str.Text())
+    }
+    return templateFactory_factory.NewStringLiteral(strings.Join(values, ""), shimast.TokenFlagsNone)
+  }
+  iterator := &TemplateFactory_IIterator{Value: "", Index: 0}
+  templateFactory_gather(expressions, iterator)
+  head := templateFactory_factory.NewTemplateHead(iterator.Value, iterator.Value, shimast.TokenFlagsNone)
+  spans := []*shimast.Node{}
+  for {
+    elem := expressions[iterator.Index]
+    iterator.Index++
+    templateFactory_gather(expressions, iterator)
+    broken := iterator.Index == len(expressions)
+    var literal *shimast.TemplateMiddleOrTail
+    if broken {
+      literal = templateFactory_factory.NewTemplateTail(iterator.Value, iterator.Value, shimast.TokenFlagsNone)
+    } else {
+      literal = templateFactory_factory.NewTemplateMiddle(iterator.Value, iterator.Value, shimast.TokenFlagsNone)
+    }
+    spans = append(spans, templateFactory_factory.NewTemplateSpan(elem, literal))
+    if broken {
+      break
+    }
+  }
+  return templateFactory_factory.NewTemplateExpression(
+    head,
+    templateFactory_factory.NewNodeList(spans),
+  )
 }
 
 func templateFactory_gather(expressions []*shimast.Expression, iterator *TemplateFactory_IIterator) {
-	found := -1
-	for i := iterator.Index; i < len(expressions); i++ {
-		if !shimast.IsStringLiteral(expressions[i]) {
-			found = i
-			break
-		}
-	}
-	last := len(expressions)
-	if found != -1 {
-		last = found
-	}
-	values := make([]string, 0, last-iterator.Index)
-	for _, elem := range expressions[iterator.Index:last] {
-		values = append(values, elem.Text())
-	}
-	iterator.Value = strings.Join(values, "")
-	iterator.Index = last
+  found := -1
+  for i := iterator.Index; i < len(expressions); i++ {
+    if !shimast.IsStringLiteral(expressions[i]) {
+      found = i
+      break
+    }
+  }
+  last := len(expressions)
+  if found != -1 {
+    last = found
+  }
+  values := make([]string, 0, last-iterator.Index)
+  for _, elem := range expressions[iterator.Index:last] {
+    values = append(values, elem.Text())
+  }
+  iterator.Value = strings.Join(values, "")
+  iterator.Index = last
 }

package/native/core/factories/TypeFactory.go

@@ -1,10 +1,10 @@
 package factories
 
 import (
-	"strings"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
 )
 
 type typeFactoryNamespace struct{}
@@ -12,152 +12,152 @@ type typeFactoryNamespace struct{}
 var TypeFactory = typeFactoryNamespace{}
 
 type TypeFactory_GetReturnTypeOfClassMethodProps struct {
-	Checker  *shimchecker.Checker
-	Class    *shimchecker.Type
-	Function string
+  Checker  *shimchecker.Checker
+  Class    *shimchecker.Type
+  Function string
 }
 
 type TypeFactory_GetFullNameProps struct {
-	Checker            *shimchecker.Checker
-	Type               *shimchecker.Type
-	Symbol             *shimast.Symbol
-	AliasTypeArguments *bool
+  Checker            *shimchecker.Checker
+  Type               *shimchecker.Type
+  Symbol             *shimast.Symbol
+  AliasTypeArguments *bool
 }
 
 var typeFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
 func (typeFactoryNamespace) IsFunction(t *shimchecker.Type) bool {
-	return TypeFactory.GetFunction(t) != nil
+  return TypeFactory.GetFunction(t) != nil
 }
 
 func (typeFactoryNamespace) GetFunction(t *shimchecker.Type) *shimast.Node {
-	if t == nil {
-		return nil
-	}
-	symbol := t.Symbol()
-	if symbol == nil || len(symbol.Declarations) == 0 {
-		return nil
-	}
-	node := symbol.Declarations[0]
-	if shimast.IsFunctionLike(node) {
-		return node
-	}
-	if shimast.IsPropertyAssignment(node) {
-		initializer := node.AsPropertyAssignment().Initializer
-		if shimast.IsFunctionLike(initializer) {
-			return initializer
-		}
-		return nil
-	}
-	if shimast.IsPropertyDeclaration(node) {
-		initializer := node.AsPropertyDeclaration().Initializer
-		if shimast.IsFunctionLike(initializer) {
-			return initializer
-		}
-	}
-	return nil
+  if t == nil {
+    return nil
+  }
+  symbol := t.Symbol()
+  if symbol == nil || len(symbol.Declarations) == 0 {
+    return nil
+  }
+  node := symbol.Declarations[0]
+  if shimast.IsFunctionLike(node) {
+    return node
+  }
+  if shimast.IsPropertyAssignment(node) {
+    initializer := node.AsPropertyAssignment().Initializer
+    if shimast.IsFunctionLike(initializer) {
+      return initializer
+    }
+    return nil
+  }
+  if shimast.IsPropertyDeclaration(node) {
+    initializer := node.AsPropertyDeclaration().Initializer
+    if shimast.IsFunctionLike(initializer) {
+      return initializer
+    }
+  }
+  return nil
 }
 
 func (typeFactoryNamespace) GetReturnTypeOfClassMethod(props TypeFactory_GetReturnTypeOfClassMethodProps) *shimchecker.Type {
-	if props.Checker == nil || props.Class == nil {
-		return nil
-	}
-	symbol := props.Checker.GetPropertyOfType(props.Class, props.Function)
-	if symbol == nil || symbol.ValueDeclaration == nil {
-		return nil
-	}
-	functor := props.Checker.GetTypeOfSymbolAtLocation(symbol, symbol.ValueDeclaration)
-	signatures := props.Checker.GetSignaturesOfType(functor, shimchecker.SignatureKindCall)
-	if len(signatures) == 0 {
-		return nil
-	}
-	return props.Checker.GetReturnTypeOfSignature(signatures[0])
+  if props.Checker == nil || props.Class == nil {
+    return nil
+  }
+  symbol := props.Checker.GetPropertyOfType(props.Class, props.Function)
+  if symbol == nil || symbol.ValueDeclaration == nil {
+    return nil
+  }
+  functor := props.Checker.GetTypeOfSymbolAtLocation(symbol, symbol.ValueDeclaration)
+  signatures := props.Checker.GetSignaturesOfType(functor, shimchecker.SignatureKindCall)
+  if len(signatures) == 0 {
+    return nil
+  }
+  return props.Checker.GetReturnTypeOfSignature(signatures[0])
 }
 
 func (typeFactoryNamespace) GetFullName(props TypeFactory_GetFullNameProps) string {
-	if props.Checker == nil || props.Type == nil {
-		return ""
-	}
-	symbol := props.Symbol
-	if symbol == nil {
-		symbol = props.Type.Symbol()
-	}
-	if symbol == nil {
-		if props.Type.IsUnion() || props.Type.IsIntersection() {
-			joiner := " | "
-			if props.Type.IsIntersection() {
-				joiner = " & "
-			}
-			children := props.Type.Types()
-			names := make([]string, 0, len(children))
-			for _, child := range children {
-				names = append(names, TypeFactory.GetFullName(TypeFactory_GetFullNameProps{
-					Checker: props.Checker,
-					Type:    child,
-				}))
-			}
-			return strings.Join(names, joiner)
-		}
-		return props.Checker.TypeToString(props.Type)
-	}
-	name := typeFactory_get_name(symbol)
-	generic := props.Checker.GetTypeArguments(props.Type)
-	if len(generic) == 0 {
-		return name
-	}
-	if name == "Promise" {
-		return TypeFactory.GetFullName(TypeFactory_GetFullNameProps{
-			Checker: props.Checker,
-			Type:    generic[0],
-		})
-	}
-	names := make([]string, 0, len(generic))
-	for _, child := range generic {
-		names = append(names, TypeFactory.GetFullName(TypeFactory_GetFullNameProps{
-			Checker: props.Checker,
-			Type:    child,
-		}))
-	}
-	return name + "<" + strings.Join(names, ", ") + ">"
+  if props.Checker == nil || props.Type == nil {
+    return ""
+  }
+  symbol := props.Symbol
+  if symbol == nil {
+    symbol = props.Type.Symbol()
+  }
+  if symbol == nil {
+    if props.Type.IsUnion() || props.Type.IsIntersection() {
+      joiner := " | "
+      if props.Type.IsIntersection() {
+        joiner = " & "
+      }
+      children := props.Type.Types()
+      names := make([]string, 0, len(children))
+      for _, child := range children {
+        names = append(names, TypeFactory.GetFullName(TypeFactory_GetFullNameProps{
+          Checker: props.Checker,
+          Type:    child,
+        }))
+      }
+      return strings.Join(names, joiner)
+    }
+    return props.Checker.TypeToString(props.Type)
+  }
+  name := typeFactory_get_name(symbol)
+  generic := props.Checker.GetTypeArguments(props.Type)
+  if len(generic) == 0 {
+    return name
+  }
+  if name == "Promise" {
+    return TypeFactory.GetFullName(TypeFactory_GetFullNameProps{
+      Checker: props.Checker,
+      Type:    generic[0],
+    })
+  }
+  names := make([]string, 0, len(generic))
+  for _, child := range generic {
+    names = append(names, TypeFactory.GetFullName(TypeFactory_GetFullNameProps{
+      Checker: props.Checker,
+      Type:    child,
+    }))
+  }
+  return name + "<" + strings.Join(names, ", ") + ">"
 }
 
 func typeFactory_explore_name(node *shimast.Node, name string) string {
-	if node != nil && shimast.IsModuleBlock(node) && node.Parent != nil && node.Parent.Parent != nil {
-		parentName := ""
-		if node.Parent.Name() != nil {
-			parentName = strings.TrimSpace(node.Parent.Name().Text())
-		}
-		if parentName != "" {
-			return typeFactory_explore_name(node.Parent.Parent, parentName+"."+name)
-		}
-	}
-	return name
+  if node != nil && shimast.IsModuleBlock(node) && node.Parent != nil && node.Parent.Parent != nil {
+    parentName := ""
+    if node.Parent.Name() != nil {
+      parentName = strings.TrimSpace(node.Parent.Name().Text())
+    }
+    if parentName != "" {
+      return typeFactory_explore_name(node.Parent.Parent, parentName+"."+name)
+    }
+  }
+  return name
 }
 
 func typeFactory_get_name(symbol *shimast.Symbol) string {
-	if symbol == nil || len(symbol.Declarations) == 0 || symbol.Declarations[0].Parent == nil {
-		return "__type"
-	}
-	return typeFactory_explore_name(symbol.Declarations[0].Parent, symbol.Name)
+  if symbol == nil || len(symbol.Declarations) == 0 || symbol.Declarations[0].Parent == nil {
+    return "__type"
+  }
+  return typeFactory_explore_name(symbol.Declarations[0].Parent, symbol.Name)
 }
 
 func (typeFactoryNamespace) Keyword(t string) *shimast.Node {
-	var kind shimast.KeywordTypeSyntaxKind
-	switch t {
-	case "void":
-		kind = shimast.KindVoidKeyword
-	case "any":
-		kind = shimast.KindAnyKeyword
-	case "unknown":
-		kind = shimast.KindUnknownKeyword
-	case "boolean":
-		kind = shimast.KindBooleanKeyword
-	case "number":
-		kind = shimast.KindNumberKeyword
-	case "bigint":
-		kind = shimast.KindBigIntKeyword
-	default:
-		kind = shimast.KindStringKeyword
-	}
-	return typeFactory_factory.NewKeywordTypeNode(kind)
+  var kind shimast.KeywordTypeSyntaxKind
+  switch t {
+  case "void":
+    kind = shimast.KindVoidKeyword
+  case "any":
+    kind = shimast.KindAnyKeyword
+  case "unknown":
+    kind = shimast.KindUnknownKeyword
+  case "boolean":
+    kind = shimast.KindBooleanKeyword
+  case "number":
+    kind = shimast.KindNumberKeyword
+  case "bigint":
+    kind = shimast.KindBigIntKeyword
+  default:
+    kind = shimast.KindStringKeyword
+  }
+  return typeFactory_factory.NewKeywordTypeNode(kind)
 }

package/native/core/factories/ValueFactory.go

@@ -9,28 +9,28 @@ var ValueFactory = valueFactoryNamespace{}
 var valueFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
 func (valueFactoryNamespace) NULL() *shimast.Node {
-	return valueFactory_factory.NewKeywordExpression(shimast.KindNullKeyword)
+  return valueFactory_factory.NewKeywordExpression(shimast.KindNullKeyword)
 }
 
 func (valueFactoryNamespace) UNDEFINED() *shimast.Node {
-	return valueFactory_factory.NewIdentifier("undefined")
+  return valueFactory_factory.NewIdentifier("undefined")
 }
 
 func (valueFactoryNamespace) BOOLEAN(value bool) *shimast.Node {
-	if value {
-		return valueFactory_factory.NewKeywordExpression(shimast.KindTrueKeyword)
-	}
-	return valueFactory_factory.NewKeywordExpression(shimast.KindFalseKeyword)
+  if value {
+    return valueFactory_factory.NewKeywordExpression(shimast.KindTrueKeyword)
+  }
+  return valueFactory_factory.NewKeywordExpression(shimast.KindFalseKeyword)
 }
 
 func (valueFactoryNamespace) INPUT(str ...string) *shimast.Node {
-	name := "input"
-	if len(str) != 0 {
-		name = str[0]
-	}
-	return valueFactory_factory.NewIdentifier(name)
+  name := "input"
+  if len(str) != 0 {
+    name = str[0]
+  }
+  return valueFactory_factory.NewIdentifier(name)
 }
 
 func (valueFactoryNamespace) TYPEOF(input *shimast.Expression) *shimast.Node {
-	return valueFactory_factory.NewTypeOfExpression(input)
+  return valueFactory_factory.NewTypeOfExpression(input)
 }