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

package/native/core/programmers/iterate/stringify_dynamic_properties.go

@@ -1,212 +1,212 @@
 package iterate
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-	nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
-	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 func Stringify_dynamic_properties(dynamic []nativehelpers.IExpressionEntry, regular []string) *shimast.Node {
-	statements := []*shimast.Node{
-		stringify_dynamic_properties_factory.NewIfStatement(
-			stringify_dynamic_properties_factory.NewBinaryExpression(
-				nil,
-				stringify_dynamic_properties_factory.NewIdentifier("undefined"),
-				nil,
-				stringify_dynamic_properties_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
-				stringify_dynamic_properties_factory.NewIdentifier("value"),
-			),
-			stringify_dynamic_properties_factory.NewReturnStatement(
-				stringify_dynamic_properties_factory.NewStringLiteral("", shimast.TokenFlagsNone),
-			),
-			nil,
-		),
-	}
+  statements := []*shimast.Node{
+    stringify_dynamic_properties_factory.NewIfStatement(
+      stringify_dynamic_properties_factory.NewBinaryExpression(
+        nil,
+        stringify_dynamic_properties_factory.NewIdentifier("undefined"),
+        nil,
+        stringify_dynamic_properties_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+        stringify_dynamic_properties_factory.NewIdentifier("value"),
+      ),
+      stringify_dynamic_properties_factory.NewReturnStatement(
+        stringify_dynamic_properties_factory.NewStringLiteral("", shimast.TokenFlagsNone),
+      ),
+      nil,
+    ),
+  }
 
-	output := func() *shimast.Node {
-		mapped := stringify_dynamic_properties_factory.NewCallExpression(
-			nativefactories.IdentifierFactory.Access(
-				stringify_dynamic_properties_factory.NewCallExpression(
-					stringify_dynamic_properties_factory.NewIdentifier("Object.entries"),
-					nil,
-					nil,
-					stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
-						stringify_dynamic_properties_factory.NewIdentifier("input"),
-					}),
-					shimast.NodeFlagsNone,
-				),
-				"map",
-			),
-			nil,
-			nil,
-			stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
-				stringify_dynamic_properties_factory.NewArrowFunction(
-					nil,
-					nil,
-					stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
-						nativefactories.IdentifierFactory.Parameter(
-							stringify_dynamic_properties_binding_pattern(),
-							stringify_dynamic_properties_factory.NewTypeReferenceNode(
-								stringify_dynamic_properties_factory.NewIdentifier("[string, any]"),
-								nil,
-							),
-							nil,
-						),
-					}),
-					nil,
-					nil,
-					stringify_dynamic_properties_factory.NewToken(shimast.KindEqualsGreaterThanToken),
-					stringify_dynamic_properties_factory.NewBlock(
-						stringify_dynamic_properties_factory.NewNodeList(statements),
-						false,
-					),
-				),
-			}),
-			shimast.NodeFlagsNone,
-		)
-		filtered := stringify_dynamic_properties_factory.NewCallExpression(
-			nativefactories.IdentifierFactory.Access(mapped, "filter"),
-			nil,
-			nil,
-			stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
-				stringify_dynamic_properties_factory.NewArrowFunction(
-					nil,
-					nil,
-					stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
-						nativefactories.IdentifierFactory.Parameter("str", nil, nil),
-					}),
-					nil,
-					nil,
-					stringify_dynamic_properties_factory.NewToken(shimast.KindEqualsGreaterThanToken),
-					stringify_dynamic_properties_factory.NewBinaryExpression(
-						nil,
-						stringify_dynamic_properties_factory.NewStringLiteral("", shimast.TokenFlagsNone),
-						nil,
-						stringify_dynamic_properties_factory.NewToken(shimast.KindExclamationEqualsEqualsToken),
-						stringify_dynamic_properties_factory.NewIdentifier("str"),
-					),
-				),
-			}),
-			shimast.NodeFlagsNone,
-		)
-		return stringify_dynamic_properties_factory.NewCallExpression(
-			nativefactories.IdentifierFactory.Access(filtered, "join"),
-			nil,
-			nil,
-			stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
-				stringify_dynamic_properties_factory.NewStringLiteral(",", shimast.TokenFlagsNone),
-			}),
-			shimast.NodeFlagsNone,
-		)
-	}
+  output := func() *shimast.Node {
+    mapped := stringify_dynamic_properties_factory.NewCallExpression(
+      nativefactories.IdentifierFactory.Access(
+        stringify_dynamic_properties_factory.NewCallExpression(
+          stringify_dynamic_properties_factory.NewIdentifier("Object.entries"),
+          nil,
+          nil,
+          stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
+            stringify_dynamic_properties_factory.NewIdentifier("input"),
+          }),
+          shimast.NodeFlagsNone,
+        ),
+        "map",
+      ),
+      nil,
+      nil,
+      stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
+        stringify_dynamic_properties_factory.NewArrowFunction(
+          nil,
+          nil,
+          stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
+            nativefactories.IdentifierFactory.Parameter(
+              stringify_dynamic_properties_binding_pattern(),
+              stringify_dynamic_properties_factory.NewTypeReferenceNode(
+                stringify_dynamic_properties_factory.NewIdentifier("[string, any]"),
+                nil,
+              ),
+              nil,
+            ),
+          }),
+          nil,
+          nil,
+          stringify_dynamic_properties_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+          stringify_dynamic_properties_factory.NewBlock(
+            stringify_dynamic_properties_factory.NewNodeList(statements),
+            false,
+          ),
+        ),
+      }),
+      shimast.NodeFlagsNone,
+    )
+    filtered := stringify_dynamic_properties_factory.NewCallExpression(
+      nativefactories.IdentifierFactory.Access(mapped, "filter"),
+      nil,
+      nil,
+      stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
+        stringify_dynamic_properties_factory.NewArrowFunction(
+          nil,
+          nil,
+          stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
+            nativefactories.IdentifierFactory.Parameter("str", nil, nil),
+          }),
+          nil,
+          nil,
+          stringify_dynamic_properties_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+          stringify_dynamic_properties_factory.NewBinaryExpression(
+            nil,
+            stringify_dynamic_properties_factory.NewStringLiteral("", shimast.TokenFlagsNone),
+            nil,
+            stringify_dynamic_properties_factory.NewToken(shimast.KindExclamationEqualsEqualsToken),
+            stringify_dynamic_properties_factory.NewIdentifier("str"),
+          ),
+        ),
+      }),
+      shimast.NodeFlagsNone,
+    )
+    return stringify_dynamic_properties_factory.NewCallExpression(
+      nativefactories.IdentifierFactory.Access(filtered, "join"),
+      nil,
+      nil,
+      stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
+        stringify_dynamic_properties_factory.NewStringLiteral(",", shimast.TokenFlagsNone),
+      }),
+      shimast.NodeFlagsNone,
+    )
+  }
 
-	if len(regular) != 0 {
-		elements := make([]*shimast.Node, 0, len(regular))
-		for _, key := range regular {
-			elements = append(elements, stringify_dynamic_properties_factory.NewStringLiteral(key, shimast.TokenFlagsNone))
-		}
-		statements = append(statements, stringify_dynamic_properties_factory.NewIfStatement(
-			stringify_dynamic_properties_factory.NewCallExpression(
-				nativefactories.IdentifierFactory.Access(
-					stringify_dynamic_properties_factory.NewArrayLiteralExpression(
-						stringify_dynamic_properties_factory.NewNodeList(elements),
-						false,
-					),
-					"some",
-				),
-				nil,
-				nil,
-				stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
-					stringify_dynamic_properties_factory.NewArrowFunction(
-						nil,
-						nil,
-						stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
-							nativefactories.IdentifierFactory.Parameter("regular", nil, nil),
-						}),
-						nil,
-						nil,
-						stringify_dynamic_properties_factory.NewToken(shimast.KindEqualsGreaterThanToken),
-						stringify_dynamic_properties_factory.NewBinaryExpression(
-							nil,
-							stringify_dynamic_properties_factory.NewIdentifier("regular"),
-							nil,
-							stringify_dynamic_properties_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
-							stringify_dynamic_properties_factory.NewIdentifier("key"),
-						),
-					),
-				}),
-				shimast.NodeFlagsNone,
-			),
-			stringify_dynamic_properties_factory.NewReturnStatement(
-				stringify_dynamic_properties_factory.NewStringLiteral("", shimast.TokenFlagsNone),
-			),
-			nil,
-		))
-	}
+  if len(regular) != 0 {
+    elements := make([]*shimast.Node, 0, len(regular))
+    for _, key := range regular {
+      elements = append(elements, stringify_dynamic_properties_factory.NewStringLiteral(key, shimast.TokenFlagsNone))
+    }
+    statements = append(statements, stringify_dynamic_properties_factory.NewIfStatement(
+      stringify_dynamic_properties_factory.NewCallExpression(
+        nativefactories.IdentifierFactory.Access(
+          stringify_dynamic_properties_factory.NewArrayLiteralExpression(
+            stringify_dynamic_properties_factory.NewNodeList(elements),
+            false,
+          ),
+          "some",
+        ),
+        nil,
+        nil,
+        stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
+          stringify_dynamic_properties_factory.NewArrowFunction(
+            nil,
+            nil,
+            stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
+              nativefactories.IdentifierFactory.Parameter("regular", nil, nil),
+            }),
+            nil,
+            nil,
+            stringify_dynamic_properties_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+            stringify_dynamic_properties_factory.NewBinaryExpression(
+              nil,
+              stringify_dynamic_properties_factory.NewIdentifier("regular"),
+              nil,
+              stringify_dynamic_properties_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+              stringify_dynamic_properties_factory.NewIdentifier("key"),
+            ),
+          ),
+        }),
+        shimast.NodeFlagsNone,
+      ),
+      stringify_dynamic_properties_factory.NewReturnStatement(
+        stringify_dynamic_properties_factory.NewStringLiteral("", shimast.TokenFlagsNone),
+      ),
+      nil,
+    ))
+  }
 
-	simple := len(dynamic) == 1 &&
-		dynamic[0].Key.Size() == 1 &&
-		len(dynamic[0].Key.Atomics) != 0 &&
-		dynamic[0].Key.Atomics[0].Type == "string"
-	if simple {
-		statements = append(statements, stringify_dynamic_properties_stringify(dynamic[0]))
-		return output()
-	}
+  simple := len(dynamic) == 1 &&
+    dynamic[0].Key.Size() == 1 &&
+    len(dynamic[0].Key.Atomics) != 0 &&
+    dynamic[0].Key.Atomics[0].Type == "string"
+  if simple {
+    statements = append(statements, stringify_dynamic_properties_stringify(dynamic[0]))
+    return output()
+  }
 
-	for _, entry := range dynamic {
-		statements = append(statements, stringify_dynamic_properties_factory.NewIfStatement(
-			stringify_dynamic_properties_factory.NewCallExpression(
-				stringify_dynamic_properties_factory.NewIdentifier("RegExp(/"+metadata_to_pattern(struct {
-					top      bool
-					metadata *nativemetadata.MetadataSchema
-				}{
-					top:      true,
-					metadata: entry.Key,
-				})+"/).test"),
-				nil,
-				nil,
-				stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
-					stringify_dynamic_properties_factory.NewIdentifier("key"),
-				}),
-				shimast.NodeFlagsNone,
-			),
-			stringify_dynamic_properties_stringify(entry),
-			nil,
-		))
-	}
-	statements = append(statements, stringify_dynamic_properties_factory.NewReturnStatement(
-		stringify_dynamic_properties_factory.NewStringLiteral("", shimast.TokenFlagsNone),
-	))
-	return output()
+  for _, entry := range dynamic {
+    statements = append(statements, stringify_dynamic_properties_factory.NewIfStatement(
+      stringify_dynamic_properties_factory.NewCallExpression(
+        stringify_dynamic_properties_factory.NewIdentifier("RegExp(/"+metadata_to_pattern(struct {
+          top      bool
+          metadata *nativemetadata.MetadataSchema
+        }{
+          top:      true,
+          metadata: entry.Key,
+        })+"/).test"),
+        nil,
+        nil,
+        stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
+          stringify_dynamic_properties_factory.NewIdentifier("key"),
+        }),
+        shimast.NodeFlagsNone,
+      ),
+      stringify_dynamic_properties_stringify(entry),
+      nil,
+    ))
+  }
+  statements = append(statements, stringify_dynamic_properties_factory.NewReturnStatement(
+    stringify_dynamic_properties_factory.NewStringLiteral("", shimast.TokenFlagsNone),
+  ))
+  return output()
 }
 
 func stringify_dynamic_properties_stringify(entry nativehelpers.IExpressionEntry) *shimast.Node {
-	return stringify_dynamic_properties_factory.NewReturnStatement(
-		nativefactories.TemplateFactory.Generate([]*shimast.Node{
-			stringify_dynamic_properties_factory.NewCallExpression(
-				stringify_dynamic_properties_factory.NewIdentifier("JSON.stringify"),
-				nil,
-				stringify_dynamic_properties_factory.NewNodeList(nil),
-				stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
-					stringify_dynamic_properties_factory.NewIdentifier("key"),
-				}),
-				shimast.NodeFlagsNone,
-			),
-			stringify_dynamic_properties_factory.NewStringLiteral(":", shimast.TokenFlagsNone),
-			entry.Expression,
-		}),
-	)
+  return stringify_dynamic_properties_factory.NewReturnStatement(
+    nativefactories.TemplateFactory.Generate([]*shimast.Node{
+      stringify_dynamic_properties_factory.NewCallExpression(
+        stringify_dynamic_properties_factory.NewIdentifier("JSON.stringify"),
+        nil,
+        stringify_dynamic_properties_factory.NewNodeList(nil),
+        stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
+          stringify_dynamic_properties_factory.NewIdentifier("key"),
+        }),
+        shimast.NodeFlagsNone,
+      ),
+      stringify_dynamic_properties_factory.NewStringLiteral(":", shimast.TokenFlagsNone),
+      entry.Expression,
+    }),
+  )
 }
 
 func stringify_dynamic_properties_binding_pattern() *shimast.Node {
-	return stringify_dynamic_properties_factory.NewBindingPattern(
-		shimast.KindArrayBindingPattern,
-		stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
-			stringify_dynamic_properties_factory.NewBindingElement(nil, nil, stringify_dynamic_properties_factory.NewIdentifier("key"), nil),
-			stringify_dynamic_properties_factory.NewBindingElement(nil, nil, stringify_dynamic_properties_factory.NewIdentifier("value"), nil),
-		}),
-	)
+  return stringify_dynamic_properties_factory.NewBindingPattern(
+    shimast.KindArrayBindingPattern,
+    stringify_dynamic_properties_factory.NewNodeList([]*shimast.Node{
+      stringify_dynamic_properties_factory.NewBindingElement(nil, nil, stringify_dynamic_properties_factory.NewIdentifier("key"), nil),
+      stringify_dynamic_properties_factory.NewBindingElement(nil, nil, stringify_dynamic_properties_factory.NewIdentifier("value"), nil),
+    }),
+  )
 }
 
 var stringify_dynamic_properties_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

package/native/core/programmers/iterate/stringify_native.go

@@ -5,5 +5,5 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 var stringify_native_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
 func Stringify_native() *shimast.Node {
-	return stringify_native_factory.NewStringLiteral("{}", shimast.TokenFlagsNone)
+  return stringify_native_factory.NewStringLiteral("{}", shimast.TokenFlagsNone)
 }

package/native/core/programmers/iterate/stringify_regular_properties.go

@@ -1,108 +1,108 @@
 package iterate
 
 import (
-	"encoding/json"
-	"sort"
+  "encoding/json"
+  "sort"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-	nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
-	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 type Stringify_regular_propertiesProps struct {
-	Regular []nativehelpers.IExpressionEntry
-	Dynamic []nativehelpers.IExpressionEntry
+  Regular []nativehelpers.IExpressionEntry
+  Dynamic []nativehelpers.IExpressionEntry
 }
 
 func Stringify_regular_properties(props Stringify_regular_propertiesProps) []*shimast.Node {
-	output := []*shimast.Node{}
+  output := []*shimast.Node{}
 
-	sort.Slice(props.Regular, func(i int, j int) bool {
-		return stringify_regular_properties_sequence(props.Regular[i].Meta) < stringify_regular_properties_sequence(props.Regular[j].Meta)
-	})
-	for index, entry := range props.Regular {
-		key := entry.Key.GetSoleLiteral()
-		if key == nil {
-			continue
-		}
-		encoded, err := json.Marshal(*key)
-		if err != nil {
-			encoded = []byte("\"" + *key + "\"")
-		}
-		base := []*shimast.Node{
-			stringify_regular_properties_factory.NewStringLiteral(string(encoded)+":", shimast.TokenFlagsNone),
-			entry.Expression,
-		}
-		if index != len(props.Regular)-1 || len(props.Dynamic) != 0 {
-			base = append(base, stringify_regular_properties_factory.NewStringLiteral(",", shimast.TokenFlagsNone))
-		}
+  sort.Slice(props.Regular, func(i int, j int) bool {
+    return stringify_regular_properties_sequence(props.Regular[i].Meta) < stringify_regular_properties_sequence(props.Regular[j].Meta)
+  })
+  for index, entry := range props.Regular {
+    key := entry.Key.GetSoleLiteral()
+    if key == nil {
+      continue
+    }
+    encoded, err := json.Marshal(*key)
+    if err != nil {
+      encoded = []byte("\"" + *key + "\"")
+    }
+    base := []*shimast.Node{
+      stringify_regular_properties_factory.NewStringLiteral(string(encoded)+":", shimast.TokenFlagsNone),
+      entry.Expression,
+    }
+    if index != len(props.Regular)-1 || len(props.Dynamic) != 0 {
+      base = append(base, stringify_regular_properties_factory.NewStringLiteral(",", shimast.TokenFlagsNone))
+    }
 
-		empty := (!entry.Meta.IsRequired() && !entry.Meta.Nullable && entry.Meta.Size() == 0) ||
-			(len(entry.Meta.Functions) != 0 && !entry.Meta.Nullable && entry.Meta.Size() == 1)
-		if empty {
-			continue
-		}
-		if !entry.Meta.IsRequired() || len(entry.Meta.Functions) != 0 || entry.Meta.Any {
-			output = append(output, stringify_regular_properties_factory.NewConditionalExpression(
-				stringify_regular_properties_condition(entry),
-				nil,
-				stringify_regular_properties_factory.NewStringLiteral("", shimast.TokenFlagsNone),
-				nil,
-				nativefactories.TemplateFactory.Generate(base),
-			))
-		} else {
-			output = append(output, base...)
-		}
-	}
-	return output
+    empty := (!entry.Meta.IsRequired() && !entry.Meta.Nullable && entry.Meta.Size() == 0) ||
+      (len(entry.Meta.Functions) != 0 && !entry.Meta.Nullable && entry.Meta.Size() == 1)
+    if empty {
+      continue
+    }
+    if !entry.Meta.IsRequired() || len(entry.Meta.Functions) != 0 || entry.Meta.Any {
+      output = append(output, stringify_regular_properties_factory.NewConditionalExpression(
+        stringify_regular_properties_condition(entry),
+        nil,
+        stringify_regular_properties_factory.NewStringLiteral("", shimast.TokenFlagsNone),
+        nil,
+        nativefactories.TemplateFactory.Generate(base),
+      ))
+    } else {
+      output = append(output, base...)
+    }
+  }
+  return output
 }
 
 func stringify_regular_properties_condition(entry nativehelpers.IExpressionEntry) *shimast.Node {
-	conditions := []*shimast.Node{}
-	if !entry.Meta.IsRequired() || entry.Meta.Any {
-		conditions = append(conditions, stringify_regular_properties_factory.NewBinaryExpression(
-			nil,
-			stringify_regular_properties_factory.NewIdentifier("undefined"),
-			nil,
-			stringify_regular_properties_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
-			entry.Input,
-		))
-	}
-	if len(entry.Meta.Functions) != 0 || entry.Meta.Any {
-		conditions = append(conditions, stringify_regular_properties_factory.NewBinaryExpression(
-			nil,
-			stringify_regular_properties_factory.NewStringLiteral("function", shimast.TokenFlagsNone),
-			nil,
-			stringify_regular_properties_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
-			nativefactories.ValueFactory.TYPEOF(entry.Input),
-		))
-	}
-	return stringify_regular_properties_reduce(conditions, shimast.KindBarBarToken)
+  conditions := []*shimast.Node{}
+  if !entry.Meta.IsRequired() || entry.Meta.Any {
+    conditions = append(conditions, stringify_regular_properties_factory.NewBinaryExpression(
+      nil,
+      stringify_regular_properties_factory.NewIdentifier("undefined"),
+      nil,
+      stringify_regular_properties_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+      entry.Input,
+    ))
+  }
+  if len(entry.Meta.Functions) != 0 || entry.Meta.Any {
+    conditions = append(conditions, stringify_regular_properties_factory.NewBinaryExpression(
+      nil,
+      stringify_regular_properties_factory.NewStringLiteral("function", shimast.TokenFlagsNone),
+      nil,
+      stringify_regular_properties_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+      nativefactories.ValueFactory.TYPEOF(entry.Input),
+    ))
+  }
+  return stringify_regular_properties_reduce(conditions, shimast.KindBarBarToken)
 }
 
 func stringify_regular_properties_reduce(expressions []*shimast.Node, operator shimast.Kind) *shimast.Node {
-	if len(expressions) == 0 {
-		return stringify_regular_properties_factory.NewKeywordExpression(shimast.KindFalseKeyword)
-	}
-	output := expressions[0]
-	for _, next := range expressions[1:] {
-		output = stringify_regular_properties_factory.NewBinaryExpression(
-			nil,
-			output,
-			nil,
-			stringify_regular_properties_factory.NewToken(operator),
-			next,
-		)
-	}
-	return output
+  if len(expressions) == 0 {
+    return stringify_regular_properties_factory.NewKeywordExpression(shimast.KindFalseKeyword)
+  }
+  output := expressions[0]
+  for _, next := range expressions[1:] {
+    output = stringify_regular_properties_factory.NewBinaryExpression(
+      nil,
+      output,
+      nil,
+      stringify_regular_properties_factory.NewToken(operator),
+      next,
+    )
+  }
+  return output
 }
 
 func stringify_regular_properties_sequence(meta *nativemetadata.MetadataSchema) int {
-	if meta.Any || !meta.IsRequired() || len(meta.Functions) != 0 {
-		return 0
-	}
-	return 1
+  if meta.Any || !meta.IsRequired() || len(meta.Functions) != 0 {
+    return 0
+  }
+  return 1
 }
 
 var stringify_regular_properties_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})