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

package/native/transform/features/json/JsonSchemaTransformer.go

@@ -1,14 +1,14 @@
 package json
 
 import (
-	"fmt"
-
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimchecker "github.com/microsoft/typescript-go/shim/checker"
-	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-	nativejsonprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/json"
-	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
-	nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
+  "fmt"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativejsonprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/json"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
 )
 
 type jsonSchemaTransformerNamespace struct{}
@@ -16,161 +16,161 @@ type jsonSchemaTransformerNamespace struct{}
 var JsonSchemaTransformer = jsonSchemaTransformerNamespace{}
 
 func (jsonSchemaTransformerNamespace) Transform(props nativetransform.ITransformProps) *shimast.Node {
-	if props.Expression == nil || props.Expression.TypeArguments == nil || len(props.Expression.TypeArguments.Nodes) == 0 {
-		panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
-			Code:    "typia.json.schema",
-			Message: "no generic argument.",
-		}))
-	}
-
-	top := props.Expression.TypeArguments.Nodes[0]
-	if top == nil {
-		return props.Expression.AsNode()
-	}
-
-	typ := props.Context.Checker.GetTypeFromTypeNode(top)
-	if typ != nil && typ.IsTypeParameter() {
-		panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
-			Code:    "typia.json.schema",
-			Message: "non-specified generic argument.",
-		}))
-	}
-
-	var versionNode *shimast.Node
-	if len(props.Expression.TypeArguments.Nodes) > 1 {
-		versionNode = props.Expression.TypeArguments.Nodes[1]
-	}
-	version := jsonTransformer_getParameter(jsonTransformer_getParameterProps{
-		Checker: props.Context.Checker,
-		Code:    "typia.json.schema",
-		Name:    "Version",
-		Is: func(str string) bool {
-			return str == "3.0" || str == "3.1"
-		},
-		Default: func() string {
-			return "3.1"
-		},
-	})(versionNode)
-
-	analyze := func(validate bool) *schemametadata.MetadataSchema {
-		var validator nativefactories.MetadataFactory_Validator
-		if validate {
-			validator = jsonTransformer_schemasValidator
-		}
-		result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
-			Checker:     props.Context.Checker,
-			Transformer: props.Context.Transformer,
-			Options: nativefactories.MetadataFactory_IOptions{
-				Absorb:   validate,
-				Constant: true,
-				Escape:   true,
-				Validate: validator,
-			},
-			Components: schemametadata.NewMetadataCollection(&schemametadata.MetadataCollection_IOptions{
-				Replace: schemametadata.MetadataCollection_replace,
-			}),
-			Type: typ,
-		})
-		if result.Success == false {
-			panic(nativetransform.TransformerError_from(struct {
-				Code   string
-				Errors []nativetransform.TransformerError_MetadataFactory_IError
-			}{
-				Code:   "typia.json.schema",
-				Errors: jsonTransformer_errors(result.Errors),
-			}))
-		}
-		return result.Data
-	}
-	analyze(true)
-
-	return nativejsonprogrammers.JsonSchemaProgrammer.Write(nativejsonprogrammers.JsonSchemaProgrammer_IWriteProps{
-		Context:  props.Context,
-		Version:  version,
-		Metadata: analyze(false),
-	})
+  if props.Expression == nil || props.Expression.TypeArguments == nil || len(props.Expression.TypeArguments.Nodes) == 0 {
+    panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
+      Code:    "typia.json.schema",
+      Message: "no generic argument.",
+    }))
+  }
+
+  top := props.Expression.TypeArguments.Nodes[0]
+  if top == nil {
+    return props.Expression.AsNode()
+  }
+
+  typ := props.Context.Checker.GetTypeFromTypeNode(top)
+  if typ != nil && typ.IsTypeParameter() {
+    panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
+      Code:    "typia.json.schema",
+      Message: "non-specified generic argument.",
+    }))
+  }
+
+  var versionNode *shimast.Node
+  if len(props.Expression.TypeArguments.Nodes) > 1 {
+    versionNode = props.Expression.TypeArguments.Nodes[1]
+  }
+  version := jsonTransformer_getParameter(jsonTransformer_getParameterProps{
+    Checker: props.Context.Checker,
+    Code:    "typia.json.schema",
+    Name:    "Version",
+    Is: func(str string) bool {
+      return str == "3.0" || str == "3.1"
+    },
+    Default: func() string {
+      return "3.1"
+    },
+  })(versionNode)
+
+  analyze := func(validate bool) *schemametadata.MetadataSchema {
+    var validator nativefactories.MetadataFactory_Validator
+    if validate {
+      validator = jsonTransformer_schemasValidator
+    }
+    result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
+      Checker:     props.Context.Checker,
+      Transformer: props.Context.Transformer,
+      Options: nativefactories.MetadataFactory_IOptions{
+        Absorb:   validate,
+        Constant: true,
+        Escape:   true,
+        Validate: validator,
+      },
+      Components: schemametadata.NewMetadataCollection(&schemametadata.MetadataCollection_IOptions{
+        Replace: schemametadata.MetadataCollection_replace,
+      }),
+      Type: typ,
+    })
+    if result.Success == false {
+      panic(nativetransform.TransformerError_from(struct {
+        Code   string
+        Errors []nativetransform.TransformerError_MetadataFactory_IError
+      }{
+        Code:   "typia.json.schema",
+        Errors: jsonTransformer_errors(result.Errors),
+      }))
+    }
+    return result.Data
+  }
+  analyze(true)
+
+  return nativejsonprogrammers.JsonSchemaProgrammer.Write(nativejsonprogrammers.JsonSchemaProgrammer_IWriteProps{
+    Context:  props.Context,
+    Version:  version,
+    Metadata: analyze(false),
+  })
 }
 
 type jsonTransformer_getParameterProps struct {
-	Checker *shimchecker.Checker
-	Code    string
-	Name    string
-	Is      func(value string) bool
-	Default func() string
+  Checker *shimchecker.Checker
+  Code    string
+  Name    string
+  Is      func(value string) bool
+  Default func() string
 }
 
 func jsonTransformer_getParameter(props jsonTransformer_getParameterProps) func(node *shimast.Node) string {
-	return func(node *shimast.Node) string {
-		if node == nil {
-			return props.Default()
-		}
-		typ := props.Checker.GetTypeFromTypeNode(node)
-		if typ == nil || (typ.Flags()&shimchecker.TypeFlagsLiteral) == 0 {
-			panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
-				Code:    props.Code,
-				Message: fmt.Sprintf("generic argument \"%s\" must be constant.", props.Name),
-			}))
-		}
-
-		value := ""
-		if typ.Flags()&shimchecker.TypeFlagsBooleanLiteral != 0 {
-			value = props.Checker.TypeToString(typ)
-		} else {
-			if str, ok := typ.AsLiteralType().Value().(string); ok {
-				value = str
-			}
-		}
-		if value == "" || props.Is(value) == false {
-			panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
-				Code:    props.Code,
-				Message: fmt.Sprintf("invalid value on generic argument \"%s\".", props.Name),
-			}))
-		}
-		return value
-	}
+  return func(node *shimast.Node) string {
+    if node == nil {
+      return props.Default()
+    }
+    typ := props.Checker.GetTypeFromTypeNode(node)
+    if typ == nil || (typ.Flags()&shimchecker.TypeFlagsLiteral) == 0 {
+      panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
+        Code:    props.Code,
+        Message: fmt.Sprintf("generic argument \"%s\" must be constant.", props.Name),
+      }))
+    }
+
+    value := ""
+    if typ.Flags()&shimchecker.TypeFlagsBooleanLiteral != 0 {
+      value = props.Checker.TypeToString(typ)
+    } else {
+      if str, ok := typ.AsLiteralType().Value().(string); ok {
+        value = str
+      }
+    }
+    if value == "" || props.Is(value) == false {
+      panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
+        Code:    props.Code,
+        Message: fmt.Sprintf("invalid value on generic argument \"%s\".", props.Name),
+      }))
+    }
+    return value
+  }
 }
 
 func jsonTransformer_schemasValidator(props struct {
-	Metadata *schemametadata.MetadataSchema
-	Explore  nativefactories.MetadataFactory_IExplore
-	Top      *schemametadata.MetadataSchema
+  Metadata *schemametadata.MetadataSchema
+  Explore  nativefactories.MetadataFactory_IExplore
+  Top      *schemametadata.MetadataSchema
 }) []string {
-	return nativejsonprogrammers.JsonSchemasProgrammer.Validate(struct {
-		Metadata *schemametadata.MetadataSchema
-		Explore  nativefactories.MetadataFactory_IExplore
-	}{
-		Metadata: props.Metadata,
-		Explore:  props.Explore,
-	})
+  return nativejsonprogrammers.JsonSchemasProgrammer.Validate(struct {
+    Metadata *schemametadata.MetadataSchema
+    Explore  nativefactories.MetadataFactory_IExplore
+  }{
+    Metadata: props.Metadata,
+    Explore:  props.Explore,
+  })
 }
 
 func jsonTransformer_applicationValidator(props struct {
-	Metadata *schemametadata.MetadataSchema
-	Explore  nativefactories.MetadataFactory_IExplore
-	Top      *schemametadata.MetadataSchema
+  Metadata *schemametadata.MetadataSchema
+  Explore  nativefactories.MetadataFactory_IExplore
+  Top      *schemametadata.MetadataSchema
 }) []string {
-	return nativejsonprogrammers.JsonApplicationProgrammer.Validate(struct {
-		Metadata *schemametadata.MetadataSchema
-		Explore  nativefactories.MetadataFactory_IExplore
-	}{
-		Metadata: props.Metadata,
-		Explore:  props.Explore,
-	})
+  return nativejsonprogrammers.JsonApplicationProgrammer.Validate(struct {
+    Metadata *schemametadata.MetadataSchema
+    Explore  nativefactories.MetadataFactory_IExplore
+  }{
+    Metadata: props.Metadata,
+    Explore:  props.Explore,
+  })
 }
 
 func jsonTransformer_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
 }

package/native/transform/features/json/JsonSchemasTransformer.go

@@ -1,12 +1,12 @@
 package json
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimchecker "github.com/microsoft/typescript-go/shim/checker"
-	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-	nativejsonprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/json"
-	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"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativejsonprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/json"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
 )
 
 type jsonSchemasTransformerNamespace struct{}
@@ -14,97 +14,97 @@ type jsonSchemasTransformerNamespace struct{}
 var JsonSchemasTransformer = jsonSchemasTransformerNamespace{}
 
 func (jsonSchemasTransformerNamespace) Transform(props nativetransform.ITransformProps) *shimast.Node {
-	if props.Expression == nil || props.Expression.TypeArguments == nil || len(props.Expression.TypeArguments.Nodes) == 0 {
-		panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
-			Code:    "typia.json.schemas",
-			Message: "no generic argument.",
-		}))
-	}
+  if props.Expression == nil || props.Expression.TypeArguments == nil || len(props.Expression.TypeArguments.Nodes) == 0 {
+    panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
+      Code:    "typia.json.schemas",
+      Message: "no generic argument.",
+    }))
+  }
 
-	top := props.Expression.TypeArguments.Nodes[0]
-	if top == nil || top.Kind != shimast.KindTupleType {
-		return props.Expression.AsNode()
-	}
-	elements := top.AsTupleTypeNode().Elements
-	if elements == nil {
-		return props.Expression.AsNode()
-	}
+  top := props.Expression.TypeArguments.Nodes[0]
+  if top == nil || top.Kind != shimast.KindTupleType {
+    return props.Expression.AsNode()
+  }
+  elements := top.AsTupleTypeNode().Elements
+  if elements == nil {
+    return props.Expression.AsNode()
+  }
 
-	types := make([]*shimchecker.Type, 0, len(elements.Nodes))
-	for _, child := range elements.Nodes {
-		if child == nil {
-			return props.Expression.AsNode()
-		}
-		typ := props.Context.Checker.GetTypeFromTypeNode(child)
-		if typ != nil && typ.IsTypeParameter() {
-			panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
-				Code:    "typia.json.schemas",
-				Message: "non-specified generic argument(s).",
-			}))
-		}
-		types = append(types, typ)
-	}
+  types := make([]*shimchecker.Type, 0, len(elements.Nodes))
+  for _, child := range elements.Nodes {
+    if child == nil {
+      return props.Expression.AsNode()
+    }
+    typ := props.Context.Checker.GetTypeFromTypeNode(child)
+    if typ != nil && typ.IsTypeParameter() {
+      panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
+        Code:    "typia.json.schemas",
+        Message: "non-specified generic argument(s).",
+      }))
+    }
+    types = append(types, typ)
+  }
 
-	var versionNode *shimast.Node
-	if len(props.Expression.TypeArguments.Nodes) > 1 {
-		versionNode = props.Expression.TypeArguments.Nodes[1]
-	}
-	version := jsonTransformer_getParameter(jsonTransformer_getParameterProps{
-		Checker: props.Context.Checker,
-		Code:    "typia.json.schemas",
-		Name:    "Version",
-		Is: func(str string) bool {
-			return str == "3.0" || str == "3.1"
-		},
-		Default: func() string {
-			return "3.1"
-		},
-	})(versionNode)
+  var versionNode *shimast.Node
+  if len(props.Expression.TypeArguments.Nodes) > 1 {
+    versionNode = props.Expression.TypeArguments.Nodes[1]
+  }
+  version := jsonTransformer_getParameter(jsonTransformer_getParameterProps{
+    Checker: props.Context.Checker,
+    Code:    "typia.json.schemas",
+    Name:    "Version",
+    Is: func(str string) bool {
+      return str == "3.0" || str == "3.1"
+    },
+    Default: func() string {
+      return "3.1"
+    },
+  })(versionNode)
 
-	analyze := func(validate bool) []*schemametadata.MetadataSchema {
-		metadatas := []*schemametadata.MetadataSchema{}
-		errors := []nativefactories.MetadataFactory_IError{}
-		var validator nativefactories.MetadataFactory_Validator
-		if validate {
-			validator = jsonTransformer_schemasValidator
-		}
-		for _, typ := range types {
-			result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
-				Checker:     props.Context.Checker,
-				Transformer: props.Context.Transformer,
-				Options: nativefactories.MetadataFactory_IOptions{
-					Absorb:   validate,
-					Constant: true,
-					Escape:   true,
-					Validate: validator,
-				},
-				Components: schemametadata.NewMetadataCollection(&schemametadata.MetadataCollection_IOptions{
-					Replace: schemametadata.MetadataCollection_replace,
-				}),
-				Type: typ,
-			})
-			if result.Success == false {
-				errors = append(errors, result.Errors...)
-			} else {
-				metadatas = append(metadatas, result.Data)
-			}
-		}
-		if len(errors) != 0 {
-			panic(nativetransform.TransformerError_from(struct {
-				Code   string
-				Errors []nativetransform.TransformerError_MetadataFactory_IError
-			}{
-				Code:   "typia.json.schemas",
-				Errors: jsonTransformer_errors(errors),
-			}))
-		}
-		return metadatas
-	}
-	analyze(true)
+  analyze := func(validate bool) []*schemametadata.MetadataSchema {
+    metadatas := []*schemametadata.MetadataSchema{}
+    errors := []nativefactories.MetadataFactory_IError{}
+    var validator nativefactories.MetadataFactory_Validator
+    if validate {
+      validator = jsonTransformer_schemasValidator
+    }
+    for _, typ := range types {
+      result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
+        Checker:     props.Context.Checker,
+        Transformer: props.Context.Transformer,
+        Options: nativefactories.MetadataFactory_IOptions{
+          Absorb:   validate,
+          Constant: true,
+          Escape:   true,
+          Validate: validator,
+        },
+        Components: schemametadata.NewMetadataCollection(&schemametadata.MetadataCollection_IOptions{
+          Replace: schemametadata.MetadataCollection_replace,
+        }),
+        Type: typ,
+      })
+      if result.Success == false {
+        errors = append(errors, result.Errors...)
+      } else {
+        metadatas = append(metadatas, result.Data)
+      }
+    }
+    if len(errors) != 0 {
+      panic(nativetransform.TransformerError_from(struct {
+        Code   string
+        Errors []nativetransform.TransformerError_MetadataFactory_IError
+      }{
+        Code:   "typia.json.schemas",
+        Errors: jsonTransformer_errors(errors),
+      }))
+    }
+    return metadatas
+  }
+  analyze(true)
 
-	return nativejsonprogrammers.JsonSchemasProgrammer.Write(nativejsonprogrammers.JsonSchemasProgrammer_IWriteProps{
-		Context:   props.Context,
-		Version:   version,
-		Metadatas: analyze(false),
-	})
+  return nativejsonprogrammers.JsonSchemasProgrammer.Write(nativejsonprogrammers.JsonSchemasProgrammer_IWriteProps{
+    Context:   props.Context,
+    Version:   version,
+    Metadatas: analyze(false),
+  })
 }

package/native/transform/features/json/JsonStringifyTransformer.go

@@ -1,10 +1,10 @@
 package json
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativejsonprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/json"
-	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"
+  nativejsonprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/json"
+  nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
 )
 
 type jsonStringifyTransformerNamespace struct{}
@@ -12,11 +12,11 @@ type jsonStringifyTransformerNamespace struct{}
 var JsonStringifyTransformer = jsonStringifyTransformerNamespace{}
 
 func (jsonStringifyTransformerNamespace) Transform(props nativeinternal.ITransformProps) *shimast.Node {
-	return nativeinternal.GenericTransformer.Scalar(nativeinternal.GenericTransformer_IProps{
-		ITransformProps: props,
-		Method:          "json.stringify",
-		Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
-			return nativejsonprogrammers.JsonStringifyProgrammer.Write(x)
-		},
-	})
+  return nativeinternal.GenericTransformer.Scalar(nativeinternal.GenericTransformer_IProps{
+    ITransformProps: props,
+    Method:          "json.stringify",
+    Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
+      return nativejsonprogrammers.JsonStringifyProgrammer.Write(x)
+    },
+  })
 }

package/native/transform/features/json/JsonValidateParseTransformer.go

@@ -1,10 +1,10 @@
 package json
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativejsonprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/json"
-	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"
+  nativejsonprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/json"
+  nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
 )
 
 type jsonValidateParseTransformerNamespace struct{}
@@ -12,11 +12,11 @@ type jsonValidateParseTransformerNamespace struct{}
 var JsonValidateParseTransformer = jsonValidateParseTransformerNamespace{}
 
 func (jsonValidateParseTransformerNamespace) Transform(props nativeinternal.ITransformProps) *shimast.Node {
-	return nativeinternal.GenericTransformer.Scalar(nativeinternal.GenericTransformer_IProps{
-		ITransformProps: props,
-		Method:          "json.validateParse",
-		Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
-			return nativejsonprogrammers.JsonValidateParseProgrammer.Write(x)
-		},
-	})
+  return nativeinternal.GenericTransformer.Scalar(nativeinternal.GenericTransformer_IProps{
+    ITransformProps: props,
+    Method:          "json.validateParse",
+    Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
+      return nativejsonprogrammers.JsonValidateParseProgrammer.Write(x)
+    },
+  })
 }

package/native/transform/features/json/JsonValidateStringifyTransformer.go

@@ -1,10 +1,10 @@
 package json
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativejsonprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/json"
-	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"
+  nativejsonprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/json"
+  nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
 )
 
 type jsonValidateStringifyTransformerNamespace struct{}
@@ -12,11 +12,11 @@ type jsonValidateStringifyTransformerNamespace struct{}
 var JsonValidateStringifyTransformer = jsonValidateStringifyTransformerNamespace{}
 
 func (jsonValidateStringifyTransformerNamespace) Transform(props nativeinternal.ITransformProps) *shimast.Node {
-	return nativeinternal.GenericTransformer.Scalar(nativeinternal.GenericTransformer_IProps{
-		ITransformProps: props,
-		Method:          "json.validateStringify",
-		Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
-			return nativejsonprogrammers.JsonValidateStringifyProgrammer.Write(x)
-		},
-	})
+  return nativeinternal.GenericTransformer.Scalar(nativeinternal.GenericTransformer_IProps{
+    ITransformProps: props,
+    Method:          "json.validateStringify",
+    Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
+      return nativejsonprogrammers.JsonValidateStringifyProgrammer.Write(x)
+    },
+  })
 }