typia 13.0.1-dev.20260703.1 → 13.0.2

package/native/core/programmers/AssertProgrammer.go

@@ -1,511 +1,511 @@
-package programmers
-
-import (
-  shimast "github.com/microsoft/typescript-go/shim/ast"
-  nativechecker "github.com/microsoft/typescript-go/shim/checker"
-  shimprinter "github.com/microsoft/typescript-go/shim/printer"
-  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
-  nativeinternal "github.com/samchon/typia/packages/typia/native/core/programmers/internal"
-  nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
-)
-
-type assertProgrammerNamespace struct{}
-
-var AssertProgrammer = assertProgrammerNamespace{}
-
-type AssertProgrammer_IConfig struct {
-  Equals bool
-  Guard  bool
-}
-
-type AssertProgrammer_IProps struct {
-  Context nativecontext.ITypiaContext
-  Modulo  *shimast.Node
-  Type    *nativechecker.Type
-  Name    *string
-  Init    *shimast.Node
-  Config  AssertProgrammer_IConfig
-}
-
-type AssertProgrammer_DecomposeProps struct {
-  Config  AssertProgrammer_IConfig
-  Context nativecontext.ITypiaContext
-  Functor *nativehelpers.FunctionProgrammer
-  Type    *nativechecker.Type
-  Name    *string
-  Init    *shimast.Node
-}
-
-type assertProgrammerImporter interface {
-  Internal(name string) *shimast.Node
-  Type(props nativecontext.ImportProgrammer_TypeProps) *shimast.Node
-}
-
-type assertProgrammerGuardianNamespace struct{}
-
-var Guardian = assertProgrammerGuardianNamespace{}
-
-var assertProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
-func (assertProgrammerNamespace) Decompose(props AssertProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
-  is := IsProgrammer.Decompose(IsProgrammer_DecomposeProps{
-    Config:  IsProgrammer_IConfig{Equals: props.Config.Equals},
-    Context: props.Context,
-    Functor: props.Functor,
-    Type:    props.Type,
-    Name:    props.Name,
-  })
-
-  composed := nativeinternal.CheckerProgrammer.Compose(nativeinternal.CheckerProgrammer_ComposeProps{
-    Context: props.Context,
-    Functor: props.Functor,
-    Type:    props.Type,
-    Name:    props.Name,
-    Config: nativeinternal.CheckerProgrammer_IConfig{
-      Prefix:  "_a",
-      Path:    true,
-      Trace:   true,
-      Numeric: nativehelpers.OptionPredicator.Numeric(props.Context.Options),
-      Equals:  props.Config.Equals,
-      ObjectParents: props.Config.Equals == false,
-      Atomist: assertProgrammer_atomist(props),
-      Combiner: assertProgrammer_combiner(struct {
-        Config  AssertProgrammer_IConfig
-        Context nativecontext.ITypiaContext
-        Functor *nativehelpers.FunctionProgrammer
-      }{Config: props.Config, Context: props.Context, Functor: props.Functor}),
-      Joiner:  assertProgrammer_joiner(props),
-      Success: f.NewKeywordExpression(shimast.KindTrueKeyword),
-    },
-  })
-
-  typeName := assertProgrammer_type_name(props.Context, props.Type, props.Name)
-  var returnType *shimast.Node
-  if props.Config.Guard {
-    returnType = f.NewTypePredicateNode(
-      f.NewToken(shimast.KindAssertsKeyword),
-      f.NewIdentifier("input"),
-      f.NewTypeReferenceNode(f.NewIdentifier(typeName), nil),
-    )
-  } else {
-    returnType = f.NewTypeReferenceNode(f.NewIdentifier(typeName), nil)
-  }
-
-  statements := []*shimast.Node{
-    f.NewIfStatement(
-      assertProgrammer_equal(
-        f.NewKeywordExpression(shimast.KindFalseKeyword),
-        f.NewCallExpression(
-          f.NewIdentifier("__is"),
-          nil,
-          nil,
-          f.NewNodeList([]*shimast.Node{f.NewIdentifier("input")}),
-          shimast.NodeFlagsNone,
-        ),
-        props.Context.Emit,
-      ),
-      f.NewBlock(
-        f.NewNodeList([]*shimast.Node{
-          f.NewExpressionStatement(
-            f.NewBinaryExpression(
-              nil,
-              f.NewIdentifier("_errorFactory"),
-              nil,
-              f.NewToken(shimast.KindEqualsToken),
-              f.NewIdentifier("errorFactory"),
-            ),
-          ),
-          f.NewExpressionStatement(
-            f.NewCallExpression(
-              f.NewArrowFunction(
-                nil,
-                nil,
-                f.NewNodeList(composed.Parameters),
-                nil,
-                nil,
-                f.NewToken(shimast.KindEqualsGreaterThanToken),
-                composed.Body,
-              ),
-              nil,
-              nil,
-              f.NewNodeList([]*shimast.Node{
-                f.NewIdentifier("input"),
-                f.NewStringLiteral("$input", shimast.TokenFlagsNone),
-                f.NewKeywordExpression(shimast.KindTrueKeyword),
-              }),
-              shimast.NodeFlagsNone,
-            ),
-          ),
-        }),
-        true,
-      ),
-      nil,
-    ),
-  }
-  if props.Config.Guard == false {
-    statements = append(statements, f.NewReturnStatement(f.NewIdentifier("input")))
-  }
-  arrow := f.NewArrowFunction(
-    nil,
-    nil,
-    f.NewNodeList([]*shimast.Node{
-      nativefactories.IdentifierFactory.Parameter("input", nativefactories.TypeFactory.Keyword("any", props.Context.Emit), nil, props.Context.Emit),
-      Guardian.Parameter(struct {
-        Context nativecontext.ITypiaContext
-        Init    *shimast.Node
-      }{Context: props.Context, Init: props.Init}),
-    }),
-    returnType,
-    nil,
-    f.NewToken(shimast.KindEqualsGreaterThanToken),
-    f.NewBlock(f.NewNodeList(statements), true),
-  )
-
-  functions := map[string]*shimast.Node{}
-  for key, value := range is.Functions {
-    functions[key] = value
-  }
-  for key, value := range composed.Functions {
-    functions[key] = value
-  }
-  outStatements := []*shimast.Node{}
-  outStatements = append(outStatements, is.Statements...)
-  outStatements = append(outStatements, composed.Statements...)
-  outStatements = append(outStatements,
-    nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__is", Value: is.Arrow}, props.Context.Emit),
-    nativefactories.StatementFactory.Mut(nativefactories.StatementFactory_MutProps{Name: "_errorFactory"}, props.Context.Emit),
-  )
-  return nativeinternal.FeatureProgrammer_IDecomposed{
-    Functions:  functions,
-    Statements: outStatements,
-    Arrow:      arrow,
-  }
-}
-
-func (assertProgrammerNamespace) Write(props AssertProgrammer_IProps) *shimast.Node {
-  method := nativehelpers.ModuloMethodText(props.Modulo)
-  functor := nativehelpers.NewFunctionProgrammer(method, props.Context.Emit)
-  result := AssertProgrammer.Decompose(AssertProgrammer_DecomposeProps{
-    Config:  props.Config,
-    Context: props.Context,
-    Functor: functor,
-    Type:    props.Type,
-    Name:    props.Name,
-    Init:    props.Init,
-  })
-  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
-    Modulo:  props.Modulo,
-    Functor: functor,
-    Result:  result,
-  })
-}
-
-func assertProgrammer_atomist(props AssertProgrammer_DecomposeProps) func(next nativeinternal.CheckerProgrammer_AtomistProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
-  return func(next nativeinternal.CheckerProgrammer_AtomistProps) *shimast.Node {
-    expressions := []*shimast.Node{}
-    if next.Entry.Expression != nil {
-      expressions = append(expressions, next.Entry.Expression)
-    }
-    if len(next.Entry.Conditions) != 0 {
-      exceptionable := assertProgrammer_exceptionable(next.Explore, props.Context.Emit)
-      path := assertProgrammer_path(next.Explore, props.Context.Emit)
-      if len(next.Entry.Conditions) == 1 {
-        for _, cond := range next.Entry.Conditions[0] {
-          expressions = append(expressions, assertProgrammer_or(
-            cond.Expression,
-            assertProgrammer_create_guard_call(assertProgrammer_createGuardCallProps{Context: props.Context, Functor: props.Functor, Exceptionable: exceptionable, Path: path, Expected: cond.Expected, Input: next.Input}),
-            props.Context.Emit,
-          ))
-        }
-      } else {
-        rows := []*shimast.Node{}
-        for _, set := range next.Entry.Conditions {
-          cols := []*shimast.Node{}
-          for _, s := range set {
-            cols = append(cols, s.Expression)
-          }
-          rows = append(rows, assertProgrammer_reduce(cols, shimast.KindAmpersandAmpersandToken, f.NewKeywordExpression(shimast.KindTrueKeyword), props.Context.Emit))
-        }
-        expressions = append(expressions, assertProgrammer_or(
-          assertProgrammer_reduce(rows, shimast.KindBarBarToken, f.NewKeywordExpression(shimast.KindFalseKeyword), props.Context.Emit),
-          assertProgrammer_create_guard_call(assertProgrammer_createGuardCallProps{Context: props.Context, Functor: props.Functor, Exceptionable: exceptionable, Path: path, Expected: next.Entry.Expected, Input: next.Input}),
-          props.Context.Emit,
-        ))
-      }
-    }
-    return assertProgrammer_reduce(expressions, shimast.KindAmpersandAmpersandToken, f.NewKeywordExpression(shimast.KindTrueKeyword), props.Context.Emit)
-  }
-}
-
-func assertProgrammer_combiner(props struct {
-  Config  AssertProgrammer_IConfig
-  Context nativecontext.ITypiaContext
-  Functor *nativehelpers.FunctionProgrammer
-}) nativeinternal.CheckerProgrammer_IConfig_Combiner {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
-  return func(next nativeinternal.CheckerProgrammer_CombinerProps) *shimast.Node {
-    if next.Explore.Tracable == false {
-      options := &IsProgrammer_CONFIG_IOptions{
-        Numeric: assertProgrammer_bool_ptr(true),
-        Object: func(v IsProgrammer_CONFIG_IOptions_ObjectProps) *shimast.Node {
-          return assertProgrammer_assert_object(assertProgrammer_assertObjectProps{Config: props.Config, Context: props.Context, Functor: props.Functor, Entries: v.Entries, Input: v.Input})
-        },
-      }
-      return IsProgrammer.Configure(struct {
-        Options *IsProgrammer_CONFIG_IOptions
-        Context nativecontext.ITypiaContext
-        Functor *nativehelpers.FunctionProgrammer
-      }{Options: options, Context: props.Context, Functor: props.Functor}).Combiner(next)
-    }
-    path := assertProgrammer_path(next.Explore, props.Context.Emit)
-    exceptionable := assertProgrammer_exceptionable(next.Explore, props.Context.Emit)
-    if next.Logic == "and" {
-      expressions := []*shimast.Node{}
-      for _, binary := range next.Binaries {
-        if binary.Combined {
-          expressions = append(expressions, binary.Expression)
-        } else {
-          expressions = append(expressions, assertProgrammer_or(
-            binary.Expression,
-            assertProgrammer_create_guard_call(assertProgrammer_createGuardCallProps{Context: props.Context, Functor: props.Functor, Exceptionable: exceptionable, Path: path, Expected: next.Expected, Input: next.Input}),
-            props.Context.Emit,
-          ))
-        }
-      }
-      return assertProgrammer_reduce(expressions, shimast.KindAmpersandAmpersandToken, f.NewKeywordExpression(shimast.KindTrueKeyword), props.Context.Emit)
-    }
-    expressions := []*shimast.Node{}
-    for _, binary := range next.Binaries {
-      expressions = append(expressions, binary.Expression)
-    }
-    return assertProgrammer_or(
-      assertProgrammer_reduce(expressions, shimast.KindBarBarToken, f.NewKeywordExpression(shimast.KindFalseKeyword), props.Context.Emit),
-      assertProgrammer_create_guard_call(assertProgrammer_createGuardCallProps{Context: props.Context, Functor: props.Functor, Exceptionable: exceptionable, Path: path, Expected: next.Expected, Input: next.Input}),
-      props.Context.Emit,
-    )
-  }
-}
-
-type assertProgrammer_assertObjectProps struct {
-  Config  AssertProgrammer_IConfig
-  Context nativecontext.ITypiaContext
-  Functor *nativehelpers.FunctionProgrammer
-  Entries []nativehelpers.IExpressionEntry
-  Input   *shimast.Expression
-}
-
-func assertProgrammer_assert_object(props assertProgrammer_assertObjectProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
-  return nativeiterate.Check_object(nativeiterate.Check_objectProps{
-    Config: nativeiterate.Check_object_IConfig{
-      Equals:    props.Config.Equals,
-      Assert:    true,
-      Undefined: nativehelpers.OptionPredicator.Undefined(props.Context.Options),
-      Reduce: func(a *shimast.Expression, b *shimast.Expression) *shimast.Node {
-        return assertProgrammer_binary(a, shimast.KindAmpersandAmpersandToken, b, props.Context.Emit)
-      },
-      Positive: f.NewKeywordExpression(shimast.KindTrueKeyword),
-      Superfluous: func(input *shimast.Expression, description *shimast.Expression) *shimast.Node {
-        return assertProgrammer_create_guard_call(assertProgrammer_createGuardCallProps{
-          Context: props.Context,
-          Functor: props.Functor,
-          Path: assertProgrammer_binary(
-            f.NewIdentifier("_path"),
-            shimast.KindPlusToken,
-            f.NewCallExpression(assertProgrammer_internal(props.Context, "accessExpressionAsString"), nil, nil, f.NewNodeList([]*shimast.Node{f.NewIdentifier("key")}), shimast.NodeFlagsNone),
-            props.Context.Emit,
-          ),
-          Expected: "undefined",
-          Input:    input,
-        })
-      },
-      Halt: func(expr *shimast.Expression) *shimast.Node {
-        return assertProgrammer_or(
-          assertProgrammer_equal(f.NewKeywordExpression(shimast.KindFalseKeyword), f.NewIdentifier("_exceptionable"), props.Context.Emit),
-          expr,
-          props.Context.Emit,
-        )
-      },
-    },
-    Context: props.Context,
-    Entries: props.Entries,
-    Input:   props.Input,
-  })
-}
-
-func assertProgrammer_joiner(props AssertProgrammer_DecomposeProps) nativeinternal.CheckerProgrammer_IConfig_IJoiner {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
-  joiner := nativeinternal.CheckerProgrammer_IConfig_IJoiner{
-    Object: func(next nativeinternal.CheckerProgrammer_JoinerObjectProps) *shimast.Node {
-      return assertProgrammer_assert_object(assertProgrammer_assertObjectProps{Config: props.Config, Context: props.Context, Functor: props.Functor, Entries: next.Entries, Input: next.Input})
-    },
-    Array: func(next nativeinternal.CheckerProgrammer_JoinerArrayProps) *shimast.Node {
-      return f.NewCallExpression(nativefactories.IdentifierFactory.Access(props.Context.Emit, next.Input, "every"), nil, nil, f.NewNodeList([]*shimast.Node{next.Arrow}), shimast.NodeFlagsNone)
-    },
-    Failure: func(next nativeinternal.CheckerProgrammer_JoinerFailureProps) *shimast.Node {
-      explore := nativeinternal.FeatureProgrammer_IExplore{}
-      if next.Explore != nil {
-        explore = *next.Explore
-      }
-      return assertProgrammer_create_guard_call(assertProgrammer_createGuardCallProps{Context: props.Context, Functor: props.Functor, Exceptionable: assertProgrammer_exceptionable(explore, props.Context.Emit), Path: assertProgrammer_path(explore, props.Context.Emit), Expected: next.Expected, Input: next.Input})
-    },
-  }
-  if props.Config.Equals == false {
-    joiner.Full = func(next nativeinternal.CheckerProgrammer_JoinerFullProps) *shimast.Node {
-      return assertProgrammer_or(
-        next.Condition,
-        assertProgrammer_create_guard_call(assertProgrammer_createGuardCallProps{Context: props.Context, Functor: props.Functor, Exceptionable: assertProgrammer_exceptionable(next.Explore, props.Context.Emit), Path: f.NewIdentifier("_path"), Expected: next.Expected, Input: next.Input}),
-        props.Context.Emit,
-      )
-    }
-  }
-  return joiner
-}
-
-type assertProgrammer_createGuardCallProps struct {
-  Context       nativecontext.ITypiaContext
-  Functor       *nativehelpers.FunctionProgrammer
-  Expected      string
-  Input         *shimast.Expression
-  Path          *shimast.Expression
-  Exceptionable *shimast.Expression
-}
-
-func assertProgrammer_create_guard_call(props assertProgrammer_createGuardCallProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
-  exceptionable := props.Exceptionable
-  if exceptionable == nil {
-    exceptionable = f.NewIdentifier("_exceptionable")
-  }
-  return f.NewCallExpression(
-    assertProgrammer_internal(props.Context, "assertGuard"),
-    nil,
-    nil,
-    f.NewNodeList([]*shimast.Node{
-      exceptionable,
-      f.NewObjectLiteralExpression(f.NewNodeList([]*shimast.Node{
-        f.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("method", props.Context.Emit), nil, nil, f.NewStringLiteral(props.Functor.Method, shimast.TokenFlagsNone)),
-        f.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("path", props.Context.Emit), nil, nil, props.Path),
-        f.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("expected", props.Context.Emit), nil, nil, assertProgrammer_expected_expression(props)),
-        f.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("value", props.Context.Emit), nil, nil, props.Input),
-      }), true),
-      f.NewIdentifier("_errorFactory"),
-    }),
-    shimast.NodeFlagsNone,
-  )
-}
-
-func assertProgrammer_expected_expression(props assertProgrammer_createGuardCallProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
-  if props.Functor == nil || len(props.Expected) < 128 {
-    return f.NewStringLiteral(props.Expected, shimast.TokenFlagsNone)
-  }
-  return props.Functor.EmplaceVariableByKey("_ae", props.Expected, func(string) *shimast.Expression {
-    return f.NewStringLiteral(props.Expected, shimast.TokenFlagsNone)
-  })
-}
-
-func (assertProgrammerGuardianNamespace) Identifier(emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, emit...)
-  return f.NewIdentifier("errorFactory")
-}
-
-func (assertProgrammerGuardianNamespace) Parameter(props struct {
-  Context nativecontext.ITypiaContext
-  Init    *shimast.Node
-}) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
-  init := props.Init
-  if init == nil {
-    init = f.NewToken(shimast.KindQuestionToken)
-  }
-  return nativefactories.IdentifierFactory.Parameter("errorFactory", Guardian.Type(props.Context), init, props.Context.Emit)
-}
-
-func (assertProgrammerGuardianNamespace) Type(context nativecontext.ITypiaContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, context.Emit)
-  return f.NewFunctionTypeNode(
-    nil,
-    f.NewNodeList([]*shimast.Node{
-      f.NewParameterDeclaration(
-        nil,
-        nil,
-        f.NewIdentifier("p"),
-        nil,
-        assertProgrammer_import_type(context, nativecontext.ImportProgrammer_TypeProps{File: "typia", Name: "TypeGuardError.IProps"}),
-        nil,
-      ),
-    }),
-    f.NewTypeReferenceNode(f.NewIdentifier("Error"), nil),
-  )
-}
-
-func assertProgrammer_reduce(expressions []*shimast.Node, operator shimast.Kind, initial *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Node {
-  if len(expressions) == 0 {
-    return initial
-  }
-  output := expressions[0]
-  for _, expr := range expressions[1:] {
-    output = assertProgrammer_binary(output, operator, expr, emit)
-  }
-  return output
-}
-
-func assertProgrammer_binary(left *shimast.Expression, operator shimast.Kind, right *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, emit)
-  return f.NewBinaryExpression(nil, left, nil, f.NewToken(operator), right)
-}
-
-func assertProgrammer_equal(left *shimast.Expression, right *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Node {
-  return assertProgrammer_binary(left, shimast.KindEqualsEqualsEqualsToken, right, emit)
-}
-
-func assertProgrammer_or(left *shimast.Expression, right *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Node {
-  return assertProgrammer_binary(left, shimast.KindBarBarToken, right, emit)
-}
-
-func assertProgrammer_exceptionable(explore nativeinternal.FeatureProgrammer_IExplore, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, emit)
-  if explore.From == "top" || explore.Source == "top" {
-    return f.NewKeywordExpression(shimast.KindTrueKeyword)
-  }
-  return f.NewIdentifier("_exceptionable")
-}
-
-func assertProgrammer_path(explore nativeinternal.FeatureProgrammer_IExplore, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, emit)
-  if explore.Postfix != "" {
-    return f.NewIdentifier("_path + " + explore.Postfix)
-  }
-  return f.NewIdentifier("_path")
-}
-
-func assertProgrammer_type_name(context nativecontext.ITypiaContext, typ *nativechecker.Type, name *string) string {
-  if name != nil {
-    return *name
-  }
-  return nativefactories.TypeFactory.GetFullName(nativefactories.TypeFactory_GetFullNameProps{Checker: context.Checker, Type: typ})
-}
-
-func assertProgrammer_internal(context nativecontext.ITypiaContext, name string) *shimast.Node {
-  if importer := context.Importer; importer != nil {
-    return importer.Internal(name)
-  }
-  return nativecontext.EmitFactoryOf(assertProgrammer_factory, context.Emit).NewIdentifier(name)
-}
-
-func assertProgrammer_import_type(context nativecontext.ITypiaContext, props nativecontext.ImportProgrammer_TypeProps) *shimast.Node {
-  if importer := context.Importer; importer != nil {
-    return importer.Type(props)
-  }
-  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, context.Emit)
-  return f.NewTypeReferenceNode(f.NewIdentifier(props.Name.(string)), nil)
-}
-
-func assertProgrammer_bool_ptr(value bool) *bool {
-  return &value
-}
+package programmers
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativechecker "github.com/microsoft/typescript-go/shim/checker"
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
+  nativeinternal "github.com/samchon/typia/packages/typia/native/core/programmers/internal"
+  nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
+)
+
+type assertProgrammerNamespace struct{}
+
+var AssertProgrammer = assertProgrammerNamespace{}
+
+type AssertProgrammer_IConfig struct {
+  Equals bool
+  Guard  bool
+}
+
+type AssertProgrammer_IProps struct {
+  Context nativecontext.ITypiaContext
+  Modulo  *shimast.Node
+  Type    *nativechecker.Type
+  Name    *string
+  Init    *shimast.Node
+  Config  AssertProgrammer_IConfig
+}
+
+type AssertProgrammer_DecomposeProps struct {
+  Config  AssertProgrammer_IConfig
+  Context nativecontext.ITypiaContext
+  Functor *nativehelpers.FunctionProgrammer
+  Type    *nativechecker.Type
+  Name    *string
+  Init    *shimast.Node
+}
+
+type assertProgrammerImporter interface {
+  Internal(name string) *shimast.Node
+  Type(props nativecontext.ImportProgrammer_TypeProps) *shimast.Node
+}
+
+type assertProgrammerGuardianNamespace struct{}
+
+var Guardian = assertProgrammerGuardianNamespace{}
+
+var assertProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (assertProgrammerNamespace) Decompose(props AssertProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
+  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
+  is := IsProgrammer.Decompose(IsProgrammer_DecomposeProps{
+    Config:  IsProgrammer_IConfig{Equals: props.Config.Equals},
+    Context: props.Context,
+    Functor: props.Functor,
+    Type:    props.Type,
+    Name:    props.Name,
+  })
+
+  composed := nativeinternal.CheckerProgrammer.Compose(nativeinternal.CheckerProgrammer_ComposeProps{
+    Context: props.Context,
+    Functor: props.Functor,
+    Type:    props.Type,
+    Name:    props.Name,
+    Config: nativeinternal.CheckerProgrammer_IConfig{
+      Prefix:  "_a",
+      Path:    true,
+      Trace:   true,
+      Numeric: nativehelpers.OptionPredicator.Numeric(props.Context.Options),
+      Equals:  props.Config.Equals,
+      ObjectParents: props.Config.Equals == false,
+      Atomist: assertProgrammer_atomist(props),
+      Combiner: assertProgrammer_combiner(struct {
+        Config  AssertProgrammer_IConfig
+        Context nativecontext.ITypiaContext
+        Functor *nativehelpers.FunctionProgrammer
+      }{Config: props.Config, Context: props.Context, Functor: props.Functor}),
+      Joiner:  assertProgrammer_joiner(props),
+      Success: f.NewKeywordExpression(shimast.KindTrueKeyword),
+    },
+  })
+
+  typeName := assertProgrammer_type_name(props.Context, props.Type, props.Name)
+  var returnType *shimast.Node
+  if props.Config.Guard {
+    returnType = f.NewTypePredicateNode(
+      f.NewToken(shimast.KindAssertsKeyword),
+      f.NewIdentifier("input"),
+      f.NewTypeReferenceNode(f.NewIdentifier(typeName), nil),
+    )
+  } else {
+    returnType = f.NewTypeReferenceNode(f.NewIdentifier(typeName), nil)
+  }
+
+  statements := []*shimast.Node{
+    f.NewIfStatement(
+      assertProgrammer_equal(
+        f.NewKeywordExpression(shimast.KindFalseKeyword),
+        f.NewCallExpression(
+          f.NewIdentifier("__is"),
+          nil,
+          nil,
+          f.NewNodeList([]*shimast.Node{f.NewIdentifier("input")}),
+          shimast.NodeFlagsNone,
+        ),
+        props.Context.Emit,
+      ),
+      f.NewBlock(
+        f.NewNodeList([]*shimast.Node{
+          f.NewExpressionStatement(
+            f.NewBinaryExpression(
+              nil,
+              f.NewIdentifier("_errorFactory"),
+              nil,
+              f.NewToken(shimast.KindEqualsToken),
+              f.NewIdentifier("errorFactory"),
+            ),
+          ),
+          f.NewExpressionStatement(
+            f.NewCallExpression(
+              f.NewArrowFunction(
+                nil,
+                nil,
+                f.NewNodeList(composed.Parameters),
+                nil,
+                nil,
+                f.NewToken(shimast.KindEqualsGreaterThanToken),
+                composed.Body,
+              ),
+              nil,
+              nil,
+              f.NewNodeList([]*shimast.Node{
+                f.NewIdentifier("input"),
+                f.NewStringLiteral("$input", shimast.TokenFlagsNone),
+                f.NewKeywordExpression(shimast.KindTrueKeyword),
+              }),
+              shimast.NodeFlagsNone,
+            ),
+          ),
+        }),
+        true,
+      ),
+      nil,
+    ),
+  }
+  if props.Config.Guard == false {
+    statements = append(statements, f.NewReturnStatement(f.NewIdentifier("input")))
+  }
+  arrow := f.NewArrowFunction(
+    nil,
+    nil,
+    f.NewNodeList([]*shimast.Node{
+      nativefactories.IdentifierFactory.Parameter("input", nativefactories.TypeFactory.Keyword("any", props.Context.Emit), nil, props.Context.Emit),
+      Guardian.Parameter(struct {
+        Context nativecontext.ITypiaContext
+        Init    *shimast.Node
+      }{Context: props.Context, Init: props.Init}),
+    }),
+    returnType,
+    nil,
+    f.NewToken(shimast.KindEqualsGreaterThanToken),
+    f.NewBlock(f.NewNodeList(statements), true),
+  )
+
+  functions := map[string]*shimast.Node{}
+  for key, value := range is.Functions {
+    functions[key] = value
+  }
+  for key, value := range composed.Functions {
+    functions[key] = value
+  }
+  outStatements := []*shimast.Node{}
+  outStatements = append(outStatements, is.Statements...)
+  outStatements = append(outStatements, composed.Statements...)
+  outStatements = append(outStatements,
+    nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__is", Value: is.Arrow}, props.Context.Emit),
+    nativefactories.StatementFactory.Mut(nativefactories.StatementFactory_MutProps{Name: "_errorFactory"}, props.Context.Emit),
+  )
+  return nativeinternal.FeatureProgrammer_IDecomposed{
+    Functions:  functions,
+    Statements: outStatements,
+    Arrow:      arrow,
+  }
+}
+
+func (assertProgrammerNamespace) Write(props AssertProgrammer_IProps) *shimast.Node {
+  method := nativehelpers.ModuloMethodText(props.Modulo)
+  functor := nativehelpers.NewFunctionProgrammer(method, props.Context.Emit)
+  result := AssertProgrammer.Decompose(AssertProgrammer_DecomposeProps{
+    Config:  props.Config,
+    Context: props.Context,
+    Functor: functor,
+    Type:    props.Type,
+    Name:    props.Name,
+    Init:    props.Init,
+  })
+  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
+    Modulo:  props.Modulo,
+    Functor: functor,
+    Result:  result,
+  })
+}
+
+func assertProgrammer_atomist(props AssertProgrammer_DecomposeProps) func(next nativeinternal.CheckerProgrammer_AtomistProps) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
+  return func(next nativeinternal.CheckerProgrammer_AtomistProps) *shimast.Node {
+    expressions := []*shimast.Node{}
+    if next.Entry.Expression != nil {
+      expressions = append(expressions, next.Entry.Expression)
+    }
+    if len(next.Entry.Conditions) != 0 {
+      exceptionable := assertProgrammer_exceptionable(next.Explore, props.Context.Emit)
+      path := assertProgrammer_path(next.Explore, props.Context.Emit)
+      if len(next.Entry.Conditions) == 1 {
+        for _, cond := range next.Entry.Conditions[0] {
+          expressions = append(expressions, assertProgrammer_or(
+            cond.Expression,
+            assertProgrammer_create_guard_call(assertProgrammer_createGuardCallProps{Context: props.Context, Functor: props.Functor, Exceptionable: exceptionable, Path: path, Expected: cond.Expected, Input: next.Input}),
+            props.Context.Emit,
+          ))
+        }
+      } else {
+        rows := []*shimast.Node{}
+        for _, set := range next.Entry.Conditions {
+          cols := []*shimast.Node{}
+          for _, s := range set {
+            cols = append(cols, s.Expression)
+          }
+          rows = append(rows, assertProgrammer_reduce(cols, shimast.KindAmpersandAmpersandToken, f.NewKeywordExpression(shimast.KindTrueKeyword), props.Context.Emit))
+        }
+        expressions = append(expressions, assertProgrammer_or(
+          assertProgrammer_reduce(rows, shimast.KindBarBarToken, f.NewKeywordExpression(shimast.KindFalseKeyword), props.Context.Emit),
+          assertProgrammer_create_guard_call(assertProgrammer_createGuardCallProps{Context: props.Context, Functor: props.Functor, Exceptionable: exceptionable, Path: path, Expected: next.Entry.Expected, Input: next.Input}),
+          props.Context.Emit,
+        ))
+      }
+    }
+    return assertProgrammer_reduce(expressions, shimast.KindAmpersandAmpersandToken, f.NewKeywordExpression(shimast.KindTrueKeyword), props.Context.Emit)
+  }
+}
+
+func assertProgrammer_combiner(props struct {
+  Config  AssertProgrammer_IConfig
+  Context nativecontext.ITypiaContext
+  Functor *nativehelpers.FunctionProgrammer
+}) nativeinternal.CheckerProgrammer_IConfig_Combiner {
+  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
+  return func(next nativeinternal.CheckerProgrammer_CombinerProps) *shimast.Node {
+    if next.Explore.Tracable == false {
+      options := &IsProgrammer_CONFIG_IOptions{
+        Numeric: assertProgrammer_bool_ptr(true),
+        Object: func(v IsProgrammer_CONFIG_IOptions_ObjectProps) *shimast.Node {
+          return assertProgrammer_assert_object(assertProgrammer_assertObjectProps{Config: props.Config, Context: props.Context, Functor: props.Functor, Entries: v.Entries, Input: v.Input})
+        },
+      }
+      return IsProgrammer.Configure(struct {
+        Options *IsProgrammer_CONFIG_IOptions
+        Context nativecontext.ITypiaContext
+        Functor *nativehelpers.FunctionProgrammer
+      }{Options: options, Context: props.Context, Functor: props.Functor}).Combiner(next)
+    }
+    path := assertProgrammer_path(next.Explore, props.Context.Emit)
+    exceptionable := assertProgrammer_exceptionable(next.Explore, props.Context.Emit)
+    if next.Logic == "and" {
+      expressions := []*shimast.Node{}
+      for _, binary := range next.Binaries {
+        if binary.Combined {
+          expressions = append(expressions, binary.Expression)
+        } else {
+          expressions = append(expressions, assertProgrammer_or(
+            binary.Expression,
+            assertProgrammer_create_guard_call(assertProgrammer_createGuardCallProps{Context: props.Context, Functor: props.Functor, Exceptionable: exceptionable, Path: path, Expected: next.Expected, Input: next.Input}),
+            props.Context.Emit,
+          ))
+        }
+      }
+      return assertProgrammer_reduce(expressions, shimast.KindAmpersandAmpersandToken, f.NewKeywordExpression(shimast.KindTrueKeyword), props.Context.Emit)
+    }
+    expressions := []*shimast.Node{}
+    for _, binary := range next.Binaries {
+      expressions = append(expressions, binary.Expression)
+    }
+    return assertProgrammer_or(
+      assertProgrammer_reduce(expressions, shimast.KindBarBarToken, f.NewKeywordExpression(shimast.KindFalseKeyword), props.Context.Emit),
+      assertProgrammer_create_guard_call(assertProgrammer_createGuardCallProps{Context: props.Context, Functor: props.Functor, Exceptionable: exceptionable, Path: path, Expected: next.Expected, Input: next.Input}),
+      props.Context.Emit,
+    )
+  }
+}
+
+type assertProgrammer_assertObjectProps struct {
+  Config  AssertProgrammer_IConfig
+  Context nativecontext.ITypiaContext
+  Functor *nativehelpers.FunctionProgrammer
+  Entries []nativehelpers.IExpressionEntry
+  Input   *shimast.Expression
+}
+
+func assertProgrammer_assert_object(props assertProgrammer_assertObjectProps) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
+  return nativeiterate.Check_object(nativeiterate.Check_objectProps{
+    Config: nativeiterate.Check_object_IConfig{
+      Equals:    props.Config.Equals,
+      Assert:    true,
+      Undefined: nativehelpers.OptionPredicator.Undefined(props.Context.Options),
+      Reduce: func(a *shimast.Expression, b *shimast.Expression) *shimast.Node {
+        return assertProgrammer_binary(a, shimast.KindAmpersandAmpersandToken, b, props.Context.Emit)
+      },
+      Positive: f.NewKeywordExpression(shimast.KindTrueKeyword),
+      Superfluous: func(input *shimast.Expression, description *shimast.Expression) *shimast.Node {
+        return assertProgrammer_create_guard_call(assertProgrammer_createGuardCallProps{
+          Context: props.Context,
+          Functor: props.Functor,
+          Path: assertProgrammer_binary(
+            f.NewIdentifier("_path"),
+            shimast.KindPlusToken,
+            f.NewCallExpression(assertProgrammer_internal(props.Context, "accessExpressionAsString"), nil, nil, f.NewNodeList([]*shimast.Node{f.NewIdentifier("key")}), shimast.NodeFlagsNone),
+            props.Context.Emit,
+          ),
+          Expected: "undefined",
+          Input:    input,
+        })
+      },
+      Halt: func(expr *shimast.Expression) *shimast.Node {
+        return assertProgrammer_or(
+          assertProgrammer_equal(f.NewKeywordExpression(shimast.KindFalseKeyword), f.NewIdentifier("_exceptionable"), props.Context.Emit),
+          expr,
+          props.Context.Emit,
+        )
+      },
+    },
+    Context: props.Context,
+    Entries: props.Entries,
+    Input:   props.Input,
+  })
+}
+
+func assertProgrammer_joiner(props AssertProgrammer_DecomposeProps) nativeinternal.CheckerProgrammer_IConfig_IJoiner {
+  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
+  joiner := nativeinternal.CheckerProgrammer_IConfig_IJoiner{
+    Object: func(next nativeinternal.CheckerProgrammer_JoinerObjectProps) *shimast.Node {
+      return assertProgrammer_assert_object(assertProgrammer_assertObjectProps{Config: props.Config, Context: props.Context, Functor: props.Functor, Entries: next.Entries, Input: next.Input})
+    },
+    Array: func(next nativeinternal.CheckerProgrammer_JoinerArrayProps) *shimast.Node {
+      return f.NewCallExpression(nativefactories.IdentifierFactory.Access(props.Context.Emit, next.Input, "every"), nil, nil, f.NewNodeList([]*shimast.Node{next.Arrow}), shimast.NodeFlagsNone)
+    },
+    Failure: func(next nativeinternal.CheckerProgrammer_JoinerFailureProps) *shimast.Node {
+      explore := nativeinternal.FeatureProgrammer_IExplore{}
+      if next.Explore != nil {
+        explore = *next.Explore
+      }
+      return assertProgrammer_create_guard_call(assertProgrammer_createGuardCallProps{Context: props.Context, Functor: props.Functor, Exceptionable: assertProgrammer_exceptionable(explore, props.Context.Emit), Path: assertProgrammer_path(explore, props.Context.Emit), Expected: next.Expected, Input: next.Input})
+    },
+  }
+  if props.Config.Equals == false {
+    joiner.Full = func(next nativeinternal.CheckerProgrammer_JoinerFullProps) *shimast.Node {
+      return assertProgrammer_or(
+        next.Condition,
+        assertProgrammer_create_guard_call(assertProgrammer_createGuardCallProps{Context: props.Context, Functor: props.Functor, Exceptionable: assertProgrammer_exceptionable(next.Explore, props.Context.Emit), Path: f.NewIdentifier("_path"), Expected: next.Expected, Input: next.Input}),
+        props.Context.Emit,
+      )
+    }
+  }
+  return joiner
+}
+
+type assertProgrammer_createGuardCallProps struct {
+  Context       nativecontext.ITypiaContext
+  Functor       *nativehelpers.FunctionProgrammer
+  Expected      string
+  Input         *shimast.Expression
+  Path          *shimast.Expression
+  Exceptionable *shimast.Expression
+}
+
+func assertProgrammer_create_guard_call(props assertProgrammer_createGuardCallProps) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
+  exceptionable := props.Exceptionable
+  if exceptionable == nil {
+    exceptionable = f.NewIdentifier("_exceptionable")
+  }
+  return f.NewCallExpression(
+    assertProgrammer_internal(props.Context, "assertGuard"),
+    nil,
+    nil,
+    f.NewNodeList([]*shimast.Node{
+      exceptionable,
+      f.NewObjectLiteralExpression(f.NewNodeList([]*shimast.Node{
+        f.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("method", props.Context.Emit), nil, nil, f.NewStringLiteral(props.Functor.Method, shimast.TokenFlagsNone)),
+        f.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("path", props.Context.Emit), nil, nil, props.Path),
+        f.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("expected", props.Context.Emit), nil, nil, assertProgrammer_expected_expression(props)),
+        f.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("value", props.Context.Emit), nil, nil, props.Input),
+      }), true),
+      f.NewIdentifier("_errorFactory"),
+    }),
+    shimast.NodeFlagsNone,
+  )
+}
+
+func assertProgrammer_expected_expression(props assertProgrammer_createGuardCallProps) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
+  if props.Functor == nil || len(props.Expected) < 128 {
+    return f.NewStringLiteral(props.Expected, shimast.TokenFlagsNone)
+  }
+  return props.Functor.EmplaceVariableByKey("_ae", props.Expected, func(string) *shimast.Expression {
+    return f.NewStringLiteral(props.Expected, shimast.TokenFlagsNone)
+  })
+}
+
+func (assertProgrammerGuardianNamespace) Identifier(emit ...*shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, emit...)
+  return f.NewIdentifier("errorFactory")
+}
+
+func (assertProgrammerGuardianNamespace) Parameter(props struct {
+  Context nativecontext.ITypiaContext
+  Init    *shimast.Node
+}) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, props.Context.Emit)
+  init := props.Init
+  if init == nil {
+    init = f.NewToken(shimast.KindQuestionToken)
+  }
+  return nativefactories.IdentifierFactory.Parameter("errorFactory", Guardian.Type(props.Context), init, props.Context.Emit)
+}
+
+func (assertProgrammerGuardianNamespace) Type(context nativecontext.ITypiaContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, context.Emit)
+  return f.NewFunctionTypeNode(
+    nil,
+    f.NewNodeList([]*shimast.Node{
+      f.NewParameterDeclaration(
+        nil,
+        nil,
+        f.NewIdentifier("p"),
+        nil,
+        assertProgrammer_import_type(context, nativecontext.ImportProgrammer_TypeProps{File: "typia", Name: "TypeGuardError.IProps"}),
+        nil,
+      ),
+    }),
+    f.NewTypeReferenceNode(f.NewIdentifier("Error"), nil),
+  )
+}
+
+func assertProgrammer_reduce(expressions []*shimast.Node, operator shimast.Kind, initial *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Node {
+  if len(expressions) == 0 {
+    return initial
+  }
+  output := expressions[0]
+  for _, expr := range expressions[1:] {
+    output = assertProgrammer_binary(output, operator, expr, emit)
+  }
+  return output
+}
+
+func assertProgrammer_binary(left *shimast.Expression, operator shimast.Kind, right *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, emit)
+  return f.NewBinaryExpression(nil, left, nil, f.NewToken(operator), right)
+}
+
+func assertProgrammer_equal(left *shimast.Expression, right *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Node {
+  return assertProgrammer_binary(left, shimast.KindEqualsEqualsEqualsToken, right, emit)
+}
+
+func assertProgrammer_or(left *shimast.Expression, right *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Node {
+  return assertProgrammer_binary(left, shimast.KindBarBarToken, right, emit)
+}
+
+func assertProgrammer_exceptionable(explore nativeinternal.FeatureProgrammer_IExplore, emit *shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, emit)
+  if explore.From == "top" || explore.Source == "top" {
+    return f.NewKeywordExpression(shimast.KindTrueKeyword)
+  }
+  return f.NewIdentifier("_exceptionable")
+}
+
+func assertProgrammer_path(explore nativeinternal.FeatureProgrammer_IExplore, emit *shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, emit)
+  if explore.Postfix != "" {
+    return f.NewIdentifier("_path + " + explore.Postfix)
+  }
+  return f.NewIdentifier("_path")
+}
+
+func assertProgrammer_type_name(context nativecontext.ITypiaContext, typ *nativechecker.Type, name *string) string {
+  if name != nil {
+    return *name
+  }
+  return nativefactories.TypeFactory.GetFullName(nativefactories.TypeFactory_GetFullNameProps{Checker: context.Checker, Type: typ})
+}
+
+func assertProgrammer_internal(context nativecontext.ITypiaContext, name string) *shimast.Node {
+  if importer := context.Importer; importer != nil {
+    return importer.Internal(name)
+  }
+  return nativecontext.EmitFactoryOf(assertProgrammer_factory, context.Emit).NewIdentifier(name)
+}
+
+func assertProgrammer_import_type(context nativecontext.ITypiaContext, props nativecontext.ImportProgrammer_TypeProps) *shimast.Node {
+  if importer := context.Importer; importer != nil {
+    return importer.Type(props)
+  }
+  f := nativecontext.EmitFactoryOf(assertProgrammer_factory, context.Emit)
+  return f.NewTypeReferenceNode(f.NewIdentifier(props.Name.(string)), nil)
+}
+
+func assertProgrammer_bool_ptr(value bool) *bool {
+  return &value
+}