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

package/native/transform/features/llm/LlmParseTransformer.go

@@ -1,11 +1,11 @@
 package llm
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-	nativellmprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/llm"
-	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
-	nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativellmprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/llm"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
 )
 
 type llmParseTransformerNamespace struct{}
@@ -13,49 +13,49 @@ type llmParseTransformerNamespace struct{}
 var LlmParseTransformer = llmParseTransformerNamespace{}
 
 func (llmParseTransformerNamespace) Transform(props nativetransform.ITransformProps) *shimast.Node {
-	llmTransformer_require_argument(props, "typia.llm.parse", 0, "no input value.")
-	top, typ, ok := llmTransformer_type_argument(props, "typia.llm.parse")
-	if ok == false {
-		return props.Expression.AsNode()
-	}
-	config := llmTransformer_config(props, "parse")
-	if typ != nil && typ.IsTypeParameter() {
-		panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{Code: "typia.llm.parse", Message: "non-specified generic argument."}))
-	}
-	analyze := func(validate bool) *schemametadata.MetadataSchema {
-		return llmTransformer_analyze(llmTransformer_analyzeProps{
-			Context: props.Context,
-			Type:    typ,
-			Code:    "typia.llm.parse",
-			Absorb:  validate,
-			Validate: func(next struct {
-				Metadata *schemametadata.MetadataSchema
-				Explore  nativefactories.MetadataFactory_IExplore
-				Top      *schemametadata.MetadataSchema
-			}) []string {
-				if validate == false {
-					return nil
-				}
-				return nativellmprogrammers.LlmParseProgrammer.Validate(struct {
-					Config   map[string]any
-					Metadata *schemametadata.MetadataSchema
-					Explore  nativefactories.MetadataFactory_IExplore
-				}{Config: config, Metadata: next.Metadata, Explore: next.Explore})
-			},
-		})
-	}
-	analyze(true)
-	return llmTransformer_factory.NewCallExpression(
-		nativellmprogrammers.LlmParseProgrammer.Write(nativellmprogrammers.LlmParseProgrammer_IWriteProps{
-			Context:  props.Context,
-			Modulo:   props.Modulo,
-			Metadata: analyze(false),
-			Name:     llmTransformer_type_name(top),
-			Config:   config,
-		}),
-		nil,
-		nil,
-		props.Expression.Arguments,
-		shimast.NodeFlagsNone,
-	)
+  llmTransformer_require_argument(props, "typia.llm.parse", 0, "no input value.")
+  top, typ, ok := llmTransformer_type_argument(props, "typia.llm.parse")
+  if ok == false {
+    return props.Expression.AsNode()
+  }
+  config := llmTransformer_config(props, "parse")
+  if typ != nil && typ.IsTypeParameter() {
+    panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{Code: "typia.llm.parse", Message: "non-specified generic argument."}))
+  }
+  analyze := func(validate bool) *schemametadata.MetadataSchema {
+    return llmTransformer_analyze(llmTransformer_analyzeProps{
+      Context: props.Context,
+      Type:    typ,
+      Code:    "typia.llm.parse",
+      Absorb:  validate,
+      Validate: func(next struct {
+        Metadata *schemametadata.MetadataSchema
+        Explore  nativefactories.MetadataFactory_IExplore
+        Top      *schemametadata.MetadataSchema
+      }) []string {
+        if validate == false {
+          return nil
+        }
+        return nativellmprogrammers.LlmParseProgrammer.Validate(struct {
+          Config   map[string]any
+          Metadata *schemametadata.MetadataSchema
+          Explore  nativefactories.MetadataFactory_IExplore
+        }{Config: config, Metadata: next.Metadata, Explore: next.Explore})
+      },
+    })
+  }
+  analyze(true)
+  return llmTransformer_factory.NewCallExpression(
+    nativellmprogrammers.LlmParseProgrammer.Write(nativellmprogrammers.LlmParseProgrammer_IWriteProps{
+      Context:  props.Context,
+      Modulo:   props.Modulo,
+      Metadata: analyze(false),
+      Name:     llmTransformer_type_name(top),
+      Config:   config,
+    }),
+    nil,
+    nil,
+    props.Expression.Arguments,
+    shimast.NodeFlagsNone,
+  )
 }

package/native/transform/features/llm/LlmSchemaTransformer.go

@@ -1,16 +1,16 @@
 package llm
 
 import (
-	"strings"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimchecker "github.com/microsoft/typescript-go/shim/checker"
-	shimscanner "github.com/microsoft/typescript-go/shim/scanner"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-	nativellmprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/llm"
-	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
-	nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativellmprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/llm"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
 )
 
 type llmSchemaTransformerNamespace struct{}
@@ -20,148 +20,148 @@ var LlmSchemaTransformer = llmSchemaTransformerNamespace{}
 var llmTransformer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
 func (llmSchemaTransformerNamespace) Transform(props nativetransform.ITransformProps) *shimast.Node {
-	top, typ, ok := llmTransformer_type_argument(props, "typia.llm.schema")
-	if ok == false {
-		return props.Expression.AsNode()
-	}
-	config := llmTransformer_config(props, "schema")
-	analyze := func(validate bool) *schemametadata.MetadataSchema {
-		return llmTransformer_analyze(llmTransformer_analyzeProps{
-			Context: props.Context,
-			Type:    typ,
-			Code:    "typia.llm.schema",
-			Absorb:  validate,
-			Validate: func(next struct {
-				Metadata *schemametadata.MetadataSchema
-				Explore  nativefactories.MetadataFactory_IExplore
-				Top      *schemametadata.MetadataSchema
-			}) []string {
-				if validate == false {
-					return nil
-				}
-				return nativellmprogrammers.LlmSchemaProgrammer.Validate(struct {
-					Config   map[string]any
-					Metadata *schemametadata.MetadataSchema
-					Explore  nativefactories.MetadataFactory_IExplore
-				}{Config: config, Metadata: next.Metadata, Explore: next.Explore})
-			},
-		})
-	}
-	analyze(true)
-	expr := nativellmprogrammers.LlmSchemaProgrammer.Write(nativellmprogrammers.LlmSchemaProgrammer_IWriteProps{
-		Context:  props.Context,
-		Metadata: analyze(false),
-		Config:   config,
-	})
-	if props.Expression.Arguments != nil && len(props.Expression.Arguments.Nodes) != 0 && expr.Kind == shimast.KindArrowFunction {
-		return llmTransformer_factory.NewCallExpression(
-			expr,
-			nil,
-			nil,
-			llmTransformer_factory.NewNodeList([]*shimast.Node{props.Expression.Arguments.Nodes[0]}),
-			shimast.NodeFlagsNone,
-		)
-	}
-	_ = top
-	return expr
+  top, typ, ok := llmTransformer_type_argument(props, "typia.llm.schema")
+  if ok == false {
+    return props.Expression.AsNode()
+  }
+  config := llmTransformer_config(props, "schema")
+  analyze := func(validate bool) *schemametadata.MetadataSchema {
+    return llmTransformer_analyze(llmTransformer_analyzeProps{
+      Context: props.Context,
+      Type:    typ,
+      Code:    "typia.llm.schema",
+      Absorb:  validate,
+      Validate: func(next struct {
+        Metadata *schemametadata.MetadataSchema
+        Explore  nativefactories.MetadataFactory_IExplore
+        Top      *schemametadata.MetadataSchema
+      }) []string {
+        if validate == false {
+          return nil
+        }
+        return nativellmprogrammers.LlmSchemaProgrammer.Validate(struct {
+          Config   map[string]any
+          Metadata *schemametadata.MetadataSchema
+          Explore  nativefactories.MetadataFactory_IExplore
+        }{Config: config, Metadata: next.Metadata, Explore: next.Explore})
+      },
+    })
+  }
+  analyze(true)
+  expr := nativellmprogrammers.LlmSchemaProgrammer.Write(nativellmprogrammers.LlmSchemaProgrammer_IWriteProps{
+    Context:  props.Context,
+    Metadata: analyze(false),
+    Config:   config,
+  })
+  if props.Expression.Arguments != nil && len(props.Expression.Arguments.Nodes) != 0 && expr.Kind == shimast.KindArrowFunction {
+    return llmTransformer_factory.NewCallExpression(
+      expr,
+      nil,
+      nil,
+      llmTransformer_factory.NewNodeList([]*shimast.Node{props.Expression.Arguments.Nodes[0]}),
+      shimast.NodeFlagsNone,
+    )
+  }
+  _ = top
+  return expr
 }
 
 type llmTransformer_analyzeProps struct {
-	Context    nativecontext.ITypiaContext
-	Type       *shimchecker.Type
-	Code       string
-	Absorb     bool
-	Functional bool
-	Validate   func(props struct {
-		Metadata *schemametadata.MetadataSchema
-		Explore  nativefactories.MetadataFactory_IExplore
-		Top      *schemametadata.MetadataSchema
-	}) []string
+  Context    nativecontext.ITypiaContext
+  Type       *shimchecker.Type
+  Code       string
+  Absorb     bool
+  Functional bool
+  Validate   func(props struct {
+    Metadata *schemametadata.MetadataSchema
+    Explore  nativefactories.MetadataFactory_IExplore
+    Top      *schemametadata.MetadataSchema
+  }) []string
 }
 
 func llmTransformer_type_argument(props nativetransform.ITransformProps, code string) (*shimast.Node, *shimchecker.Type, bool) {
-	if props.Expression == nil || props.Expression.TypeArguments == nil || len(props.Expression.TypeArguments.Nodes) == 0 {
-		panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{Code: code, Message: "no generic argument."}))
-	}
-	top := props.Expression.TypeArguments.Nodes[0]
-	typ := props.Context.Checker.GetTypeFromTypeNode(top)
-	return top, typ, true
+  if props.Expression == nil || props.Expression.TypeArguments == nil || len(props.Expression.TypeArguments.Nodes) == 0 {
+    panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{Code: code, Message: "no generic argument."}))
+  }
+  top := props.Expression.TypeArguments.Nodes[0]
+  typ := props.Context.Checker.GetTypeFromTypeNode(top)
+  return top, typ, true
 }
 
 func llmTransformer_config(props nativetransform.ITransformProps, method string) map[string]any {
-	var node *shimast.Node
-	if props.Expression != nil && props.Expression.TypeArguments != nil && len(props.Expression.TypeArguments.Nodes) > 1 {
-		node = props.Expression.TypeArguments.Nodes[1]
-	}
-	return nativellmprogrammers.LlmMetadataFactory.GetConfig(struct {
-		Context nativecontext.ITypiaContext
-		Method  string
-		Node    *shimast.Node
-	}{Context: props.Context, Method: method, Node: node})
+  var node *shimast.Node
+  if props.Expression != nil && props.Expression.TypeArguments != nil && len(props.Expression.TypeArguments.Nodes) > 1 {
+    node = props.Expression.TypeArguments.Nodes[1]
+  }
+  return nativellmprogrammers.LlmMetadataFactory.GetConfig(struct {
+    Context nativecontext.ITypiaContext
+    Method  string
+    Node    *shimast.Node
+  }{Context: props.Context, Method: method, Node: node})
 }
 
 func llmTransformer_analyze(props llmTransformer_analyzeProps) *schemametadata.MetadataSchema {
-	result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
-		Checker:     props.Context.Checker,
-		Transformer: props.Context.Transformer,
-		Options: nativefactories.MetadataFactory_IOptions{
-			Absorb:     props.Absorb,
-			Escape:     true,
-			Constant:   true,
-			Functional: props.Functional,
-			Validate:   props.Validate,
-		},
-		Components: schemametadata.NewMetadataCollection(&schemametadata.MetadataCollection_IOptions{
-			Replace: schemametadata.MetadataCollection_replace,
-		}),
-		Type: props.Type,
-	})
-	if result.Success == false {
-		panic(nativetransform.TransformerError_from(struct {
-			Code   string
-			Errors []nativetransform.TransformerError_MetadataFactory_IError
-		}{
-			Code:   props.Code,
-			Errors: llmTransformer_errors(result.Errors),
-		}))
-	}
-	return result.Data
+  result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
+    Checker:     props.Context.Checker,
+    Transformer: props.Context.Transformer,
+    Options: nativefactories.MetadataFactory_IOptions{
+      Absorb:     props.Absorb,
+      Escape:     true,
+      Constant:   true,
+      Functional: props.Functional,
+      Validate:   props.Validate,
+    },
+    Components: schemametadata.NewMetadataCollection(&schemametadata.MetadataCollection_IOptions{
+      Replace: schemametadata.MetadataCollection_replace,
+    }),
+    Type: props.Type,
+  })
+  if result.Success == false {
+    panic(nativetransform.TransformerError_from(struct {
+      Code   string
+      Errors []nativetransform.TransformerError_MetadataFactory_IError
+    }{
+      Code:   props.Code,
+      Errors: llmTransformer_errors(result.Errors),
+    }))
+  }
+  return result.Data
 }
 
 func llmTransformer_errors(errors []nativefactories.MetadataFactory_IError) []nativetransform.TransformerError_MetadataFactory_IError {
-	output := make([]nativetransform.TransformerError_MetadataFactory_IError, 0, len(errors))
-	for _, err := range errors {
-		output = append(output, nativetransform.TransformerError_MetadataFactory_IError{
-			Name: err.Name,
-			Explore: nativetransform.TransformerError_MetadataFactory_IExplore{
-				Object:    err.Explore.Object,
-				Property:  err.Explore.Property,
-				Parameter: err.Explore.Parameter,
-				Output:    err.Explore.Output,
-			},
-			Messages: append([]string{}, err.Messages...),
-		})
-	}
-	return output
+  output := make([]nativetransform.TransformerError_MetadataFactory_IError, 0, len(errors))
+  for _, err := range errors {
+    output = append(output, nativetransform.TransformerError_MetadataFactory_IError{
+      Name: err.Name,
+      Explore: nativetransform.TransformerError_MetadataFactory_IExplore{
+        Object:    err.Explore.Object,
+        Property:  err.Explore.Property,
+        Parameter: err.Explore.Parameter,
+        Output:    err.Explore.Output,
+      },
+      Messages: append([]string{}, err.Messages...),
+    })
+  }
+  return output
 }
 
 func llmTransformer_type_name(node *shimast.Node) *string {
-	if node == nil {
-		return nil
-	}
-	name := strings.TrimSpace(shimscanner.GetTextOfNode(node))
-	return &name
+  if node == nil {
+    return nil
+  }
+  name := strings.TrimSpace(shimscanner.GetTextOfNode(node))
+  return &name
 }
 
 func llmTransformer_argument(props nativetransform.ITransformProps, index int) *shimast.Node {
-	if props.Expression == nil || props.Expression.Arguments == nil || len(props.Expression.Arguments.Nodes) <= index {
-		return nil
-	}
-	return props.Expression.Arguments.Nodes[index]
+  if props.Expression == nil || props.Expression.Arguments == nil || len(props.Expression.Arguments.Nodes) <= index {
+    return nil
+  }
+  return props.Expression.Arguments.Nodes[index]
 }
 
 func llmTransformer_require_argument(props nativetransform.ITransformProps, code string, index int, message string) {
-	if llmTransformer_argument(props, index) == nil {
-		panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{Code: code, Message: message}))
-	}
+  if llmTransformer_argument(props, index) == nil {
+    panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{Code: code, Message: message}))
+  }
 }

package/native/transform/features/llm/LlmStructuredOutputTransformer.go

@@ -1,11 +1,11 @@
 package llm
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-	nativellmprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/llm"
-	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
-	nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativellmprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/llm"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
 )
 
 type llmStructuredOutputTransformerNamespace struct{}
@@ -13,43 +13,43 @@ type llmStructuredOutputTransformerNamespace struct{}
 var LlmStructuredOutputTransformer = llmStructuredOutputTransformerNamespace{}
 
 func (llmStructuredOutputTransformerNamespace) Transform(props nativetransform.ITransformProps) *shimast.Node {
-	top, typ, ok := llmTransformer_type_argument(props, "typia.llm.structuredOutput")
-	if ok == false {
-		return props.Expression.AsNode()
-	}
-	config := llmTransformer_config(props, "structuredOutput")
-	if typ != nil && typ.IsTypeParameter() {
-		panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{Code: "typia.llm.structuredOutput", Message: "non-specified generic argument."}))
-	}
-	analyze := func(validate bool) *schemametadata.MetadataSchema {
-		return llmTransformer_analyze(llmTransformer_analyzeProps{
-			Context: props.Context,
-			Type:    typ,
-			Code:    "typia.llm.structuredOutput",
-			Absorb:  validate,
-			Validate: func(next struct {
-				Metadata *schemametadata.MetadataSchema
-				Explore  nativefactories.MetadataFactory_IExplore
-				Top      *schemametadata.MetadataSchema
-			}) []string {
-				if validate == false {
-					return nil
-				}
-				return nativellmprogrammers.LlmStructuredOutputProgrammer.Validate(struct {
-					Config   map[string]any
-					Metadata *schemametadata.MetadataSchema
-					Explore  nativefactories.MetadataFactory_IExplore
-				}{Config: config, Metadata: next.Metadata, Explore: next.Explore})
-			},
-		})
-	}
-	analyze(true)
-	return nativellmprogrammers.LlmStructuredOutputProgrammer.Write(nativellmprogrammers.LlmStructuredOutputProgrammer_IWriteProps{
-		Context:  props.Context,
-		Modulo:   props.Modulo,
-		Type:     typ,
-		Metadata: analyze(false),
-		Config:   config,
-		Name:     llmTransformer_type_name(top),
-	})
+  top, typ, ok := llmTransformer_type_argument(props, "typia.llm.structuredOutput")
+  if ok == false {
+    return props.Expression.AsNode()
+  }
+  config := llmTransformer_config(props, "structuredOutput")
+  if typ != nil && typ.IsTypeParameter() {
+    panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{Code: "typia.llm.structuredOutput", Message: "non-specified generic argument."}))
+  }
+  analyze := func(validate bool) *schemametadata.MetadataSchema {
+    return llmTransformer_analyze(llmTransformer_analyzeProps{
+      Context: props.Context,
+      Type:    typ,
+      Code:    "typia.llm.structuredOutput",
+      Absorb:  validate,
+      Validate: func(next struct {
+        Metadata *schemametadata.MetadataSchema
+        Explore  nativefactories.MetadataFactory_IExplore
+        Top      *schemametadata.MetadataSchema
+      }) []string {
+        if validate == false {
+          return nil
+        }
+        return nativellmprogrammers.LlmStructuredOutputProgrammer.Validate(struct {
+          Config   map[string]any
+          Metadata *schemametadata.MetadataSchema
+          Explore  nativefactories.MetadataFactory_IExplore
+        }{Config: config, Metadata: next.Metadata, Explore: next.Explore})
+      },
+    })
+  }
+  analyze(true)
+  return nativellmprogrammers.LlmStructuredOutputProgrammer.Write(nativellmprogrammers.LlmStructuredOutputProgrammer_IWriteProps{
+    Context:  props.Context,
+    Modulo:   props.Modulo,
+    Type:     typ,
+    Metadata: analyze(false),
+    Config:   config,
+    Name:     llmTransformer_type_name(top),
+  })
 }

package/native/transform/features/misc/MiscAssertCloneTransformer.go

@@ -1,10 +1,10 @@
 package misc
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativemiscprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/misc"
-	nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativemiscprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/misc"
+  nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
 )
 
 type miscAssertCloneTransformerNamespace struct{}
@@ -12,11 +12,11 @@ type miscAssertCloneTransformerNamespace struct{}
 var MiscAssertCloneTransformer = miscAssertCloneTransformerNamespace{}
 
 func (miscAssertCloneTransformerNamespace) Transform(props nativeinternal.ITransformProps) *shimast.Node {
-	return nativeinternal.GenericTransformer.Scalar(nativeinternal.GenericTransformer_IProps{
-		ITransformProps: props,
-		Method:          "misc.assertClone",
-		Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
-			return nativemiscprogrammers.MiscAssertCloneProgrammer.Write(x)
-		},
-	})
+  return nativeinternal.GenericTransformer.Scalar(nativeinternal.GenericTransformer_IProps{
+    ITransformProps: props,
+    Method:          "misc.assertClone",
+    Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
+      return nativemiscprogrammers.MiscAssertCloneProgrammer.Write(x)
+    },
+  })
 }

package/native/transform/features/misc/MiscAssertPruneTransformer.go

@@ -1,10 +1,10 @@
 package misc
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativemiscprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/misc"
-	nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativemiscprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/misc"
+  nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
 )
 
 type miscAssertPruneTransformerNamespace struct{}
@@ -12,11 +12,11 @@ type miscAssertPruneTransformerNamespace struct{}
 var MiscAssertPruneTransformer = miscAssertPruneTransformerNamespace{}
 
 func (miscAssertPruneTransformerNamespace) Transform(props nativeinternal.ITransformProps) *shimast.Node {
-	return nativeinternal.GenericTransformer.Scalar(nativeinternal.GenericTransformer_IProps{
-		ITransformProps: props,
-		Method:          "misc.assertPrune",
-		Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
-			return nativemiscprogrammers.MiscAssertPruneProgrammer.Write(x)
-		},
-	})
+  return nativeinternal.GenericTransformer.Scalar(nativeinternal.GenericTransformer_IProps{
+    ITransformProps: props,
+    Method:          "misc.assertPrune",
+    Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
+      return nativemiscprogrammers.MiscAssertPruneProgrammer.Write(x)
+    },
+  })
 }

package/native/transform/features/misc/MiscCloneTransformer.go

@@ -1,10 +1,10 @@
 package misc
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativemiscprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/misc"
-	nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativemiscprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/misc"
+  nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
 )
 
 type miscCloneTransformerNamespace struct{}
@@ -12,11 +12,11 @@ type miscCloneTransformerNamespace struct{}
 var MiscCloneTransformer = miscCloneTransformerNamespace{}
 
 func (miscCloneTransformerNamespace) Transform(props nativeinternal.ITransformProps) *shimast.Node {
-	return nativeinternal.GenericTransformer.Scalar(nativeinternal.GenericTransformer_IProps{
-		ITransformProps: props,
-		Method:          "misc.clone",
-		Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
-			return nativemiscprogrammers.MiscCloneProgrammer.Write(x)
-		},
-	})
+  return nativeinternal.GenericTransformer.Scalar(nativeinternal.GenericTransformer_IProps{
+    ITransformProps: props,
+    Method:          "misc.clone",
+    Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
+      return nativemiscprogrammers.MiscCloneProgrammer.Write(x)
+    },
+  })
 }