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

package/native/transform/TypiaGenerator.go

@@ -1,16 +1,16 @@
 package transform
 
 import (
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	"github.com/samchon/ttsc/packages/ttsc/driver"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  "errors"
+  "fmt"
+  "os"
+  "path/filepath"
+  "regexp"
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
 )
 
 type typiaGeneratorNamespace struct{}
@@ -18,151 +18,151 @@ type typiaGeneratorNamespace struct{}
 var TypiaGenerator = typiaGeneratorNamespace{}
 
 type TypiaGenerator_ILocation struct {
-	Input   string
-	Output  string
-	Project string
+  Input   string
+  Output  string
+  Project string
 }
 
 type typiaGenerator_gatherProps struct {
-	Location  TypiaGenerator_ILocation
-	Container *[]string
-	From      string
-	To        string
+  Location  TypiaGenerator_ILocation
+  Container *[]string
+  From      string
+  To        string
 }
 
 var typiaGenerator_TS_PATTERN = regexp.MustCompile(`\.[cm]?tsx?$`)
 var typiaGenerator_DTS_PATTERN = regexp.MustCompile(`\.d\.[cm]?tsx?$`)
 
 func (typiaGeneratorNamespace) Build(location TypiaGenerator_ILocation) error {
-	var err error
-	location.Input, err = filepath.Abs(location.Input)
-	if err != nil {
-		return err
-	}
-	location.Output, err = filepath.Abs(location.Output)
-	if err != nil {
-		return err
-	}
-	location.Project, err = filepath.Abs(location.Project)
-	if err != nil {
-		return err
-	}
-
-	if ok, err := typiaGenerator_is_directory(location.Input); err != nil || ok == false {
-		return errors.New("Error on TypiaGenerator.generate(): input path is not a directory.")
-	}
-	if _, err := os.Stat(location.Output); errors.Is(err, os.ErrNotExist) {
-		if err := os.MkdirAll(location.Output, 0o755); err != nil {
-			return err
-		}
-	} else if err != nil {
-		return err
-	} else if ok, err := typiaGenerator_is_directory(location.Output); err != nil || ok == false {
-		parent := filepath.Join(location.Output, "..")
-		if ok, err := typiaGenerator_is_directory(parent); err != nil || ok == false {
-			return errors.New("Error on TypiaGenerator.generate(): output path is not a directory.")
-		}
-		if err := os.Mkdir(location.Output, 0o755); err != nil && errors.Is(err, os.ErrExist) == false {
-			return err
-		}
-	}
-
-	container := []string{}
-	if err := typiaGenerator_gather(typiaGenerator_gatherProps{
-		Location:  location,
-		Container: &container,
-		From:      location.Input,
-		To:        location.Output,
-	}); err != nil {
-		return err
-	}
-
-	program, diagnostics, err := driver.LoadProgram(filepath.Dir(location.Project), filepath.Base(location.Project), driver.LoadProgramOptions{
-		ForceEmit: true,
-	})
-	if err != nil {
-		return err
-	}
-	if program != nil {
-		defer program.Close()
-	}
-	if len(diagnostics) != 0 {
-		return fmt.Errorf("TypiaGenerator.generate(): %s", diagnostics[0].String())
-	}
-
-	plugin := Transform(program, nil, nativecontext.ITypiaContext_Extras{
-		AddDiagnostic: func(diag *shimast.Diagnostic) int {
-			diagnostics = append(diagnostics, driver.Diagnostic{Message: "typia transform diagnostic"})
-			return len(diagnostics)
-		},
-	})
-	for _, file := range container {
-		if source := program.SourceFile(filepath.ToSlash(file)); source != nil {
-			plugin(source)
-		}
-		if len(diagnostics) != 0 {
-			return fmt.Errorf("TypiaGenerator.generate(): %s", diagnostics[0].String())
-		}
-		to := filepath.Join(location.Output, strings.TrimPrefix(file, location.Input))
-		if err := typiaGenerator_copy(file, to); err != nil {
-			return err
-		}
-	}
-	return nil
+  var err error
+  location.Input, err = filepath.Abs(location.Input)
+  if err != nil {
+    return err
+  }
+  location.Output, err = filepath.Abs(location.Output)
+  if err != nil {
+    return err
+  }
+  location.Project, err = filepath.Abs(location.Project)
+  if err != nil {
+    return err
+  }
+
+  if ok, err := typiaGenerator_is_directory(location.Input); err != nil || ok == false {
+    return errors.New("Error on TypiaGenerator.generate(): input path is not a directory.")
+  }
+  if _, err := os.Stat(location.Output); errors.Is(err, os.ErrNotExist) {
+    if err := os.MkdirAll(location.Output, 0o755); err != nil {
+      return err
+    }
+  } else if err != nil {
+    return err
+  } else if ok, err := typiaGenerator_is_directory(location.Output); err != nil || ok == false {
+    parent := filepath.Join(location.Output, "..")
+    if ok, err := typiaGenerator_is_directory(parent); err != nil || ok == false {
+      return errors.New("Error on TypiaGenerator.generate(): output path is not a directory.")
+    }
+    if err := os.Mkdir(location.Output, 0o755); err != nil && errors.Is(err, os.ErrExist) == false {
+      return err
+    }
+  }
+
+  container := []string{}
+  if err := typiaGenerator_gather(typiaGenerator_gatherProps{
+    Location:  location,
+    Container: &container,
+    From:      location.Input,
+    To:        location.Output,
+  }); err != nil {
+    return err
+  }
+
+  program, diagnostics, err := driver.LoadProgram(filepath.Dir(location.Project), filepath.Base(location.Project), driver.LoadProgramOptions{
+    ForceEmit: true,
+  })
+  if err != nil {
+    return err
+  }
+  if program != nil {
+    defer program.Close()
+  }
+  if len(diagnostics) != 0 {
+    return fmt.Errorf("TypiaGenerator.generate(): %s", diagnostics[0].String())
+  }
+
+  plugin := Transform(program, nil, nativecontext.ITypiaContext_Extras{
+    AddDiagnostic: func(diag *shimast.Diagnostic) int {
+      diagnostics = append(diagnostics, driver.Diagnostic{Message: "typia transform diagnostic"})
+      return len(diagnostics)
+    },
+  })
+  for _, file := range container {
+    if source := program.SourceFile(filepath.ToSlash(file)); source != nil {
+      plugin(source)
+    }
+    if len(diagnostics) != 0 {
+      return fmt.Errorf("TypiaGenerator.generate(): %s", diagnostics[0].String())
+    }
+    to := filepath.Join(location.Output, strings.TrimPrefix(file, location.Input))
+    if err := typiaGenerator_copy(file, to); err != nil {
+      return err
+    }
+  }
+  return nil
 }
 
 func typiaGenerator_is_directory(current string) (bool, error) {
-	stat, err := os.Stat(current)
-	if err != nil {
-		return false, err
-	}
-	return stat.IsDir(), nil
+  stat, err := os.Stat(current)
+  if err != nil {
+    return false, err
+  }
+  return stat.IsDir(), nil
 }
 
 func typiaGenerator_gather(props typiaGenerator_gatherProps) error {
-	if filepath.Clean(props.From) == filepath.Clean(props.Location.Output) {
-		return nil
-	}
-	if _, err := os.Stat(props.To); errors.Is(err, os.ErrNotExist) {
-		if err := os.MkdirAll(props.To, 0o755); err != nil {
-			return err
-		}
-	}
-	files, err := os.ReadDir(props.From)
-	if err != nil {
-		return err
-	}
-	for _, file := range files {
-		next := filepath.Join(props.From, file.Name())
-		if file.IsDir() {
-			if err := typiaGenerator_gather(typiaGenerator_gatherProps{
-				Location:  props.Location,
-				Container: props.Container,
-				From:      next,
-				To:        filepath.Join(props.To, file.Name()),
-			}); err != nil {
-				return err
-			}
-			continue
-		}
-		if typiaGenerator_is_supported_extension(file.Name()) {
-			*props.Container = append(*props.Container, next)
-		}
-	}
-	return nil
+  if filepath.Clean(props.From) == filepath.Clean(props.Location.Output) {
+    return nil
+  }
+  if _, err := os.Stat(props.To); errors.Is(err, os.ErrNotExist) {
+    if err := os.MkdirAll(props.To, 0o755); err != nil {
+      return err
+    }
+  }
+  files, err := os.ReadDir(props.From)
+  if err != nil {
+    return err
+  }
+  for _, file := range files {
+    next := filepath.Join(props.From, file.Name())
+    if file.IsDir() {
+      if err := typiaGenerator_gather(typiaGenerator_gatherProps{
+        Location:  props.Location,
+        Container: props.Container,
+        From:      next,
+        To:        filepath.Join(props.To, file.Name()),
+      }); err != nil {
+        return err
+      }
+      continue
+    }
+    if typiaGenerator_is_supported_extension(file.Name()) {
+      *props.Container = append(*props.Container, next)
+    }
+  }
+  return nil
 }
 
 func typiaGenerator_is_supported_extension(filename string) bool {
-	return typiaGenerator_TS_PATTERN.MatchString(filename) && typiaGenerator_DTS_PATTERN.MatchString(filename) == false
+  return typiaGenerator_TS_PATTERN.MatchString(filename) && typiaGenerator_DTS_PATTERN.MatchString(filename) == false
 }
 
 func typiaGenerator_copy(from string, to string) error {
-	data, err := os.ReadFile(from)
-	if err != nil {
-		return err
-	}
-	if err := os.MkdirAll(filepath.Dir(to), 0o755); err != nil {
-		return err
-	}
-	return os.WriteFile(to, data, 0o644)
+  data, err := os.ReadFile(from)
+  if err != nil {
+    return err
+  }
+  if err := os.MkdirAll(filepath.Dir(to), 0o755); err != nil {
+    return err
+  }
+  return os.WriteFile(to, data, 0o644)
 }

package/native/transform/features/AssertTransformer.go

@@ -1,10 +1,10 @@
 package features
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
-	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"
+  nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
+  nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
 )
 
 type assertTransformerNamespace struct{}
@@ -12,28 +12,28 @@ type assertTransformerNamespace struct{}
 var AssertTransformer = assertTransformerNamespace{}
 
 func (assertTransformerNamespace) Transform(config nativeprogrammers.AssertProgrammer_IConfig) func(props nativeinternal.ITransformProps) *shimast.Node {
-	return func(props nativeinternal.ITransformProps) *shimast.Node {
-		method := "assert"
-		if config.Equals && config.Guard {
-			method = "assertGuardEquals"
-		} else if config.Equals {
-			method = "assertEquals"
-		} else if config.Guard {
-			method = "assertGuard"
-		}
-		return nativeinternal.GenericTransformer.Scalar(nativeinternal.GenericTransformer_IProps{
-			ITransformProps: props,
-			Method:          method,
-			Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
-				return nativeprogrammers.AssertProgrammer.Write(nativeprogrammers.AssertProgrammer_IProps{
-					Context: x.Context,
-					Modulo:  x.Modulo,
-					Type:    x.Type,
-					Name:    x.Name,
-					Init:    x.Init,
-					Config:  config,
-				})
-			},
-		})
-	}
+  return func(props nativeinternal.ITransformProps) *shimast.Node {
+    method := "assert"
+    if config.Equals && config.Guard {
+      method = "assertGuardEquals"
+    } else if config.Equals {
+      method = "assertEquals"
+    } else if config.Guard {
+      method = "assertGuard"
+    }
+    return nativeinternal.GenericTransformer.Scalar(nativeinternal.GenericTransformer_IProps{
+      ITransformProps: props,
+      Method:          method,
+      Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
+        return nativeprogrammers.AssertProgrammer.Write(nativeprogrammers.AssertProgrammer_IProps{
+          Context: x.Context,
+          Modulo:  x.Modulo,
+          Type:    x.Type,
+          Name:    x.Name,
+          Init:    x.Init,
+          Config:  config,
+        })
+      },
+    })
+  }
 }

package/native/transform/features/CreateAssertTransformer.go

@@ -1,10 +1,10 @@
 package features
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
-	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"
+  nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
+  nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
 )
 
 type createAssertTransformerNamespace struct{}
@@ -12,28 +12,28 @@ type createAssertTransformerNamespace struct{}
 var CreateAssertTransformer = createAssertTransformerNamespace{}
 
 func (createAssertTransformerNamespace) Transform(config nativeprogrammers.AssertProgrammer_IConfig) func(props nativeinternal.ITransformProps) *shimast.Node {
-	return func(props nativeinternal.ITransformProps) *shimast.Node {
-		method := "assert"
-		if config.Equals && config.Guard {
-			method = "assertGuardEquals"
-		} else if config.Equals {
-			method = "assertEquals"
-		} else if config.Guard {
-			method = "assertGuard"
-		}
-		return nativeinternal.GenericTransformer.Factory(nativeinternal.GenericTransformer_IProps{
-			ITransformProps: props,
-			Method:          method,
-			Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
-				return nativeprogrammers.AssertProgrammer.Write(nativeprogrammers.AssertProgrammer_IProps{
-					Context: x.Context,
-					Modulo:  x.Modulo,
-					Type:    x.Type,
-					Name:    x.Name,
-					Init:    x.Init,
-					Config:  config,
-				})
-			},
-		})
-	}
+  return func(props nativeinternal.ITransformProps) *shimast.Node {
+    method := "assert"
+    if config.Equals && config.Guard {
+      method = "assertGuardEquals"
+    } else if config.Equals {
+      method = "assertEquals"
+    } else if config.Guard {
+      method = "assertGuard"
+    }
+    return nativeinternal.GenericTransformer.Factory(nativeinternal.GenericTransformer_IProps{
+      ITransformProps: props,
+      Method:          method,
+      Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
+        return nativeprogrammers.AssertProgrammer.Write(nativeprogrammers.AssertProgrammer_IProps{
+          Context: x.Context,
+          Modulo:  x.Modulo,
+          Type:    x.Type,
+          Name:    x.Name,
+          Init:    x.Init,
+          Config:  config,
+        })
+      },
+    })
+  }
 }

package/native/transform/features/CreateIsTransformer.go

@@ -1,10 +1,10 @@
 package features
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
-	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"
+  nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
+  nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
 )
 
 type createIsTransformerNamespace struct{}
@@ -12,24 +12,24 @@ type createIsTransformerNamespace struct{}
 var CreateIsTransformer = createIsTransformerNamespace{}
 
 func (createIsTransformerNamespace) Transform(config nativeprogrammers.IsProgrammer_IConfig) func(props nativeinternal.ITransformProps) *shimast.Node {
-	return func(props nativeinternal.ITransformProps) *shimast.Node {
-		method := "is"
-		if config.Equals {
-			method = "equals"
-		}
-		return nativeinternal.GenericTransformer.Factory(nativeinternal.GenericTransformer_IProps{
-			ITransformProps: props,
-			Method:          method,
-			Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
-				return nativeprogrammers.IsProgrammer.Write(nativeprogrammers.IsProgrammer_IProps{
-					Context: x.Context,
-					Modulo:  x.Modulo,
-					Type:    x.Type,
-					Name:    x.Name,
-					Init:    x.Init,
-					Config:  config,
-				})
-			},
-		})
-	}
+  return func(props nativeinternal.ITransformProps) *shimast.Node {
+    method := "is"
+    if config.Equals {
+      method = "equals"
+    }
+    return nativeinternal.GenericTransformer.Factory(nativeinternal.GenericTransformer_IProps{
+      ITransformProps: props,
+      Method:          method,
+      Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
+        return nativeprogrammers.IsProgrammer.Write(nativeprogrammers.IsProgrammer_IProps{
+          Context: x.Context,
+          Modulo:  x.Modulo,
+          Type:    x.Type,
+          Name:    x.Name,
+          Init:    x.Init,
+          Config:  config,
+        })
+      },
+    })
+  }
 }

package/native/transform/features/CreateRandomTransformer.go

@@ -1,12 +1,12 @@
 package features
 
 import (
-	"strings"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimscanner "github.com/microsoft/typescript-go/shim/scanner"
-	nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
-	nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+  nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
+  nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
 )
 
 type createRandomTransformerNamespace struct{}
@@ -14,34 +14,34 @@ type createRandomTransformerNamespace struct{}
 var CreateRandomTransformer = createRandomTransformerNamespace{}
 
 func (createRandomTransformerNamespace) 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.createRandom",
-			Message: "generic argument is not specified.",
-		}))
-	}
-	node := props.Expression.TypeArguments.Nodes[0]
-	typ := props.Context.Checker.GetTypeFromTypeNode(node)
-	if typ != nil && typ.IsTypeParameter() {
-		panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
-			Code:    "typia.createRandom",
-			Message: "non-specified generic argument.",
-		}))
-	}
-	name := strings.TrimSpace(shimscanner.GetTextOfNode(node))
-	context := props.Context
-	disabled := false
-	context.Options.Functional = &disabled
-	context.Options.Numeric = &disabled
-	var init *shimast.Node
-	if props.Expression.Arguments != nil && len(props.Expression.Arguments.Nodes) != 0 {
-		init = props.Expression.Arguments.Nodes[0]
-	}
-	return nativeprogrammers.RandomProgrammer.Write(nativeprogrammers.RandomProgrammer_IProps{
-		Context: context,
-		Modulo:  props.Modulo,
-		Type:    typ,
-		Name:    &name,
-		Init:    init,
-	})
+  if props.Expression == nil || props.Expression.TypeArguments == nil || len(props.Expression.TypeArguments.Nodes) == 0 {
+    panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
+      Code:    "typia.createRandom",
+      Message: "generic argument is not specified.",
+    }))
+  }
+  node := props.Expression.TypeArguments.Nodes[0]
+  typ := props.Context.Checker.GetTypeFromTypeNode(node)
+  if typ != nil && typ.IsTypeParameter() {
+    panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
+      Code:    "typia.createRandom",
+      Message: "non-specified generic argument.",
+    }))
+  }
+  name := strings.TrimSpace(shimscanner.GetTextOfNode(node))
+  context := props.Context
+  disabled := false
+  context.Options.Functional = &disabled
+  context.Options.Numeric = &disabled
+  var init *shimast.Node
+  if props.Expression.Arguments != nil && len(props.Expression.Arguments.Nodes) != 0 {
+    init = props.Expression.Arguments.Nodes[0]
+  }
+  return nativeprogrammers.RandomProgrammer.Write(nativeprogrammers.RandomProgrammer_IProps{
+    Context: context,
+    Modulo:  props.Modulo,
+    Type:    typ,
+    Name:    &name,
+    Init:    init,
+  })
 }

package/native/transform/features/CreateValidateTransformer.go

@@ -1,10 +1,10 @@
 package features
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
-	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"
+  nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
+  nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
 )
 
 type createValidateTransformerNamespace struct{}
@@ -12,24 +12,24 @@ type createValidateTransformerNamespace struct{}
 var CreateValidateTransformer = createValidateTransformerNamespace{}
 
 func (createValidateTransformerNamespace) Transform(config nativeprogrammers.ValidateProgrammer_IConfig) func(props nativeinternal.ITransformProps) *shimast.Node {
-	return func(props nativeinternal.ITransformProps) *shimast.Node {
-		method := "validate"
-		if config.Equals {
-			method = "validateEquals"
-		}
-		return nativeinternal.GenericTransformer.Factory(nativeinternal.GenericTransformer_IProps{
-			ITransformProps: props,
-			Method:          method,
-			Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
-				return nativeprogrammers.ValidateProgrammer.Write(nativeprogrammers.ValidateProgrammer_IProps{
-					Context: x.Context,
-					Modulo:  x.Modulo,
-					Type:    x.Type,
-					Name:    x.Name,
-					Init:    x.Init,
-					Config:  config,
-				})
-			},
-		})
-	}
+  return func(props nativeinternal.ITransformProps) *shimast.Node {
+    method := "validate"
+    if config.Equals {
+      method = "validateEquals"
+    }
+    return nativeinternal.GenericTransformer.Factory(nativeinternal.GenericTransformer_IProps{
+      ITransformProps: props,
+      Method:          method,
+      Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
+        return nativeprogrammers.ValidateProgrammer.Write(nativeprogrammers.ValidateProgrammer_IProps{
+          Context: x.Context,
+          Modulo:  x.Modulo,
+          Type:    x.Type,
+          Name:    x.Name,
+          Init:    x.Init,
+          Config:  config,
+        })
+      },
+    })
+  }
 }