typia 13.1.1 → 13.2.0

package/native/core/programmers/helpers/StringifyJoinder.go

@@ -2,7 +2,7 @@ package helpers
 
 import (
   "encoding/json"
-  "sort"
+  "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimprinter "github.com/microsoft/typescript-go/shim/printer"
@@ -21,9 +21,10 @@ type StringifyJoiner_ObjectProps struct {
 }
 
 type StringifyJoiner_ArrayProps struct {
-  Input *shimast.Expression
-  Arrow *shimast.Expression
-  Emit  *shimprinter.EmitContext
+  Context nativecontext.ITypiaContext
+  Input   *shimast.Expression
+  Arrow   *shimast.Expression
+  Emit    *shimprinter.EmitContext
 }
 
 type StringifyJoiner_TupleProps struct {
@@ -48,17 +49,22 @@ func (stringifyJoinerNamespace) Object(props StringifyJoiner_ObjectProps) *shima
       dynamic = append(dynamic, entry)
     }
   }
-  expressions := stringifyJoiner_regular_properties(regular, dynamic, props.Context.Emit)
+  expressions := stringifyJoiner_regular_properties(props.Context, regular, dynamic, props.Context.Emit)
   if len(dynamic) != 0 {
     keys := make([]string, 0, len(regular))
     for _, entry := range regular {
       keys = append(keys, *entry.Key.GetSoleLiteral())
     }
-    expressions = append(expressions, stringifyJoiner_dynamic_properties(dynamic, keys, props.Context.Emit))
+    expressions = append(expressions, stringifyJoiner_dynamic_properties(props.Context, dynamic, keys, props.Context.Emit))
   }
 
+  // The tail helper removes the separator left behind when the last written
+  // member drops out at runtime, so it may only be skipped when the last regular
+  // member cannot drop. Required is not the same as cannot-drop: a required
+  // `any` member is omitted whenever its value serializes to `undefined`, which
+  // without this produced a trailing comma before `}` (#2253).
   filtered := expressions
-  if !((len(regular) != 0 && regular[len(regular)-1].Meta.IsRequired() && len(dynamic) == 0) ||
+  if !((len(regular) != 0 && !stringifyJoiner_entry_omittable(regular[len(regular)-1]) && len(dynamic) == 0) ||
     (len(regular) == 0 && len(dynamic) != 0)) {
     filtered = []*shimast.Node{
       f.NewCallExpression(
@@ -78,27 +84,26 @@ func (stringifyJoinerNamespace) Object(props StringifyJoiner_ObjectProps) *shima
   return nativefactories.TemplateFactory.Generate(output, props.Context.Emit)
 }
 
+// Array serializes elements through the `_jsonStringifyArray` helper rather than
+// `input.map(...).join(",")`.
+//
+// `map` never visits a hole and leaves one behind, and `join` renders both a
+// hole and a mapped `undefined` as empty text, so the two cases ECMAScript's
+// SerializeJSONArray answers with `null` were emitted as nothing at all: a
+// sparse array produced the malformed text `[,1]`, and an element serializing to
+// `undefined` — a function, a symbol, or a `toJSON` returning nothing in an
+// `any` or `unknown` slot — silently collapsed its position. A hole exists at
+// runtime whatever the element type declares, so this is not confined to `any`
+// (#2253).
 func (stringifyJoinerNamespace) Array(props StringifyJoiner_ArrayProps) *shimast.Node {
   f := nativecontext.EmitFactoryOf(stringifyJoiner_factory, props.Emit)
   return nativefactories.TemplateFactory.Generate([]*shimast.Node{
     f.NewStringLiteral("[", shimast.TokenFlagsNone),
     f.NewCallExpression(
-      nativefactories.IdentifierFactory.Access(
-        nil,
-        f.NewCallExpression(
-          nativefactories.IdentifierFactory.Access(nil, props.Input, "map"),
-          nil,
-          nil,
-          f.NewNodeList([]*shimast.Node{props.Arrow}),
-          shimast.NodeFlagsNone,
-        ),
-        "join",
-      ),
+      stringifyJoiner_internal(props.Context, "jsonStringifyArray"),
       nil,
       nil,
-      f.NewNodeList([]*shimast.Node{
-        f.NewStringLiteral(",", shimast.TokenFlagsNone),
-      }),
+      f.NewNodeList([]*shimast.Node{props.Input, props.Arrow}),
       shimast.NodeFlagsNone,
     ),
     f.NewStringLiteral("]", shimast.TokenFlagsNone),
@@ -131,31 +136,66 @@ func (stringifyJoinerNamespace) Tuple(props StringifyJoiner_TupleProps) *shimast
   return nativefactories.TemplateFactory.Generate(expressions, props.Emit)
 }
 
-func stringifyJoiner_regular_properties(regular []IExpressionEntry, dynamic []IExpressionEntry, emit ...*shimprinter.EmitContext) []*shimast.Node {
+func stringifyJoiner_regular_properties(context nativecontext.ITypiaContext, regular []IExpressionEntry, dynamic []IExpressionEntry, emit ...*shimprinter.EmitContext) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(stringifyJoiner_factory, emit...)
   output := []*shimast.Node{}
-  sort.Slice(regular, func(i int, j int) bool {
-    return stringifyJoiner_sequence(regular[i].Meta) < stringifyJoiner_sequence(regular[j].Meta)
-  })
+  // Members keep their declaration order, which is what the guide promises and
+  // what `JSON.stringify` produces for a value assigned in that order. They used
+  // to be sorted so every omissible member sat ahead of the required ones,
+  // because the separator is appended to every entry but the last and a last
+  // member that drops at runtime would leave a trailing comma. The caller
+  // already repairs exactly that with `_jsonStringifyTail`, whose condition
+  // reads the last member and now sees the declared one, so the ordering
+  // constraint the sort existed for no longer applies (#2295).
   for index, entry := range regular {
     key := entry.Key.GetSoleLiteral()
     encoded, err := json.Marshal(*key)
     if err != nil {
       encoded = []byte("\"" + *key + "\"")
     }
+    // encoded is escaped for a JSON string, but the literal becomes a part of a
+    // template literal (TemplateFactory.Generate). The two contexts disagree, so
+    // re-escape the JSON bytes for the template-literal context: otherwise `\"`
+    // decays to `"`, `\\` to `\`, a control-char escape's backslash is dropped, a
+    // raw backtick closes the template, and `${` starts a live interpolation.
+    separator := ""
+    if index != len(regular)-1 || len(dynamic) != 0 {
+      separator = ","
+    }
     base := []*shimast.Node{
-      f.NewStringLiteral(string(encoded)+":", shimast.TokenFlagsNone),
+      f.NewStringLiteral(stringifyJoiner_escape_template(string(encoded))+":", shimast.TokenFlagsNone),
       entry.Expression,
     }
-    if index != len(regular)-1 || len(dynamic) != 0 {
-      base = append(base, f.NewStringLiteral(",", shimast.TokenFlagsNone))
+    if separator != "" {
+      base = append(base, f.NewStringLiteral(separator, 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 {
+    if stringifyJoiner_result_undefinable(entry.Meta) {
+      // An `any` or `unknown` member is serialized by JSON.stringify, which
+      // answers `undefined` for a function, a symbol, and a `toJSON` returning
+      // nothing while the value itself is present. Only the serialized result
+      // distinguishes those from a value that has text, so the member is written
+      // through the helper that reads that result — once, because a `toJSON` may
+      // answer differently on a second call (#2253). The input tests below stay
+      // for members whose serializer must not run on a missing value at all.
+      output = append(output, f.NewCallExpression(
+        stringifyJoiner_internal(context, "jsonStringifyProperty"),
+        nil,
+        nil,
+        f.NewNodeList([]*shimast.Node{
+          f.NewStringLiteral(string(encoded)+":", shimast.TokenFlagsNone),
+          entry.Expression,
+          f.NewStringLiteral(separator, shimast.TokenFlagsNone),
+        }),
+        shimast.NodeFlagsNone,
+      ))
+      continue
+    }
+    if !entry.Meta.IsRequired() || len(entry.Meta.Functions) != 0 {
       output = append(output, nativefactories.ExpressionFactory.Conditional(
         stringifyJoiner_regular_condition(entry, emit...),
         f.NewStringLiteral("", shimast.TokenFlagsNone),
@@ -169,6 +209,39 @@ func stringifyJoiner_regular_properties(regular []IExpressionEntry, dynamic []IE
   return output
 }
 
+// stringifyJoiner_entry_omittable reports whether a member can be absent from
+// the emitted object at runtime, which is exactly the set of members that are
+// written through a conditional or through the property helper.
+func stringifyJoiner_entry_omittable(entry IExpressionEntry) bool {
+  return !entry.Meta.IsRequired() || len(entry.Meta.Functions) != 0 ||
+    stringifyJoiner_result_undefinable(entry.Meta)
+}
+
+// stringifyJoiner_result_undefinable reports whether a value that is present can
+// still serialize to nothing, which is the case an input test cannot see.
+//
+// `any` and `unknown` are serialized by JSON.stringify, which answers
+// `undefined` for a function, a symbol, and a `toJSON` returning nothing. A
+// declared `toJSON` is the same case without `any`: the member's text is its
+// return value, so a return type that admits `undefined` admits a member with no
+// text (#2253).
+// StringifyJoiner_ResultUndefinable exposes the same question to the element
+// positions the joiner does not build itself, so a tuple slot and an object
+// member classify a value identically.
+func StringifyJoiner_ResultUndefinable(meta *nativemetadata.MetadataSchema) bool {
+  return stringifyJoiner_result_undefinable(meta)
+}
+
+func stringifyJoiner_result_undefinable(meta *nativemetadata.MetadataSchema) bool {
+  if meta == nil {
+    return false
+  }
+  if meta.Any {
+    return true
+  }
+  return meta.Escaped != nil && meta.Escaped.Returns != nil && !meta.Escaped.Returns.IsRequired()
+}
+
 func stringifyJoiner_regular_condition(entry IExpressionEntry, emit ...*shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(stringifyJoiner_factory, emit...)
   conditions := []*shimast.Node{}
@@ -193,7 +266,7 @@ func stringifyJoiner_regular_condition(entry IExpressionEntry, emit ...*shimprin
   return stringifyJoiner_reduce(conditions, shimast.KindBarBarToken, emit...)
 }
 
-func stringifyJoiner_dynamic_properties(dynamic []IExpressionEntry, regular []string, emit ...*shimprinter.EmitContext) *shimast.Node {
+func stringifyJoiner_dynamic_properties(context nativecontext.ITypiaContext, dynamic []IExpressionEntry, regular []string, emit ...*shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(stringifyJoiner_factory, emit...)
   statements := []*shimast.Node{
     f.NewIfStatement(
@@ -292,7 +365,7 @@ func stringifyJoiner_dynamic_properties(dynamic []IExpressionEntry, regular []st
   }
   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, stringifyJoiner_stringify(dynamic[0], emit...))
+    statements = append(statements, stringifyJoiner_stringify(context, dynamic[0], emit...))
     return output()
   }
   for _, entry := range dynamic {
@@ -307,7 +380,7 @@ func stringifyJoiner_dynamic_properties(dynamic []IExpressionEntry, regular []st
         f.NewNodeList([]*shimast.Node{f.NewIdentifier("key")}),
         shimast.NodeFlagsNone,
       ),
-      stringifyJoiner_stringify(entry, emit...),
+      stringifyJoiner_stringify(context, entry, emit...),
       nil,
     ))
   }
@@ -315,20 +388,39 @@ func stringifyJoiner_dynamic_properties(dynamic []IExpressionEntry, regular []st
   return output()
 }
 
-func stringifyJoiner_stringify(entry IExpressionEntry, emit ...*shimprinter.EmitContext) *shimast.Node {
+func stringifyJoiner_stringify(context nativecontext.ITypiaContext, entry IExpressionEntry, emit ...*shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(stringifyJoiner_factory, emit...)
+  head := nativefactories.TemplateFactory.Generate([]*shimast.Node{
+    f.NewCallExpression(
+      f.NewIdentifier("JSON.stringify"),
+      nil,
+      f.NewNodeList(nil),
+      f.NewNodeList([]*shimast.Node{f.NewIdentifier("key")}),
+      shimast.NodeFlagsNone,
+    ),
+    f.NewStringLiteral(":", shimast.TokenFlagsNone),
+  }, emit...)
+  if entry.Meta.Any {
+    // An index-signature member takes the same contextual decision a static one
+    // takes: `any` and `unknown` values are serialized by JSON.stringify, which
+    // answers `undefined` for a present function, symbol, or empty `toJSON`.
+    // Returning the empty string hands the surrounding filter the same sentinel
+    // it already uses for a missing value, so the member and its separator drop
+    // together instead of rendering the literal `undefined` (#2253).
+    return f.NewReturnStatement(f.NewCallExpression(
+      stringifyJoiner_internal(context, "jsonStringifyProperty"),
+      nil,
+      nil,
+      f.NewNodeList([]*shimast.Node{
+        head,
+        entry.Expression,
+        f.NewStringLiteral("", shimast.TokenFlagsNone),
+      }),
+      shimast.NodeFlagsNone,
+    ))
+  }
   return f.NewReturnStatement(
-    nativefactories.TemplateFactory.Generate([]*shimast.Node{
-      f.NewCallExpression(
-        f.NewIdentifier("JSON.stringify"),
-        nil,
-        f.NewNodeList(nil),
-        f.NewNodeList([]*shimast.Node{f.NewIdentifier("key")}),
-        shimast.NodeFlagsNone,
-      ),
-      f.NewStringLiteral(":", shimast.TokenFlagsNone),
-      entry.Expression,
-    }, emit...),
+    nativefactories.TemplateFactory.Generate([]*shimast.Node{head, entry.Expression}, emit...),
   )
 }
 
@@ -374,13 +466,6 @@ func stringifyJoiner_reduce(expressions []*shimast.Node, operator shimast.Kind,
   return output
 }
 
-func stringifyJoiner_sequence(meta *nativemetadata.MetadataSchema) int {
-  if meta.Any || !meta.IsRequired() || len(meta.Functions) != 0 {
-    return 0
-  }
-  return 1
-}
-
 func stringifyJoiner_internal(context nativecontext.ITypiaContext, name string) *shimast.Node {
   if importer := context.Importer; importer != nil {
     return importer.Internal(name)
@@ -397,6 +482,31 @@ func stringifyJoiner_all_string_literals(elements []*shimast.Expression) bool {
   return true
 }
 
+// stringifyJoiner_escape_template escapes an already-JSON-encoded key so that,
+// spliced verbatim into a backtick template literal, it reproduces the exact
+// JSON bytes at runtime. It doubles every backslash (so JSON escapes such as
+// `\"`, `\\`, `\t`, `<` survive), escapes a backtick (which would close the
+// template), and escapes the `$` of a `${` pair (which would start a live
+// interpolation). A `$` not followed by `{` and every ordinary character stay
+// byte-identical, so keys that need none of these are unchanged.
+func stringifyJoiner_escape_template(text string) string {
+  var builder strings.Builder
+  builder.Grow(len(text))
+  for i := 0; i < len(text); i++ {
+    switch c := text[i]; {
+    case c == '\\':
+      builder.WriteString("\\\\")
+    case c == '`':
+      builder.WriteString("\\`")
+    case c == '$' && i+1 < len(text) && text[i+1] == '{':
+      builder.WriteString("\\$")
+    default:
+      builder.WriteByte(c)
+    }
+  }
+  return builder.String()
+}
+
 func joinStrings(values []string, sep string) string {
   if len(values) == 0 {
     return ""

package/native/core/programmers/helpers/UnionExplorer.go

@@ -79,11 +79,12 @@ type UnionExplorer_ObjectProps struct {
 }
 
 type UnionExplorer_ArrayLikeConfig struct {
-  Checker func(props UnionExplorer_ArrayLikeCheckerProps) *shimast.Node
-  Decoder func(props UnionExplorer_ArrayLikeDecoderProps) *shimast.Node
-  Empty   *shimast.Node
-  Success *shimast.Expression
-  Failure func(props UnionExplorer_ArrayLikeFailureProps) *shimast.Node
+  Checker   func(props UnionExplorer_ArrayLikeCheckerProps) *shimast.Node
+  Candidate func(props UnionExplorer_ArrayLikeCandidateProps) *shimast.Node
+  Decoder   func(props UnionExplorer_ArrayLikeDecoderProps) *shimast.Node
+  Empty     *shimast.Node
+  Success   *shimast.Expression
+  Failure   func(props UnionExplorer_ArrayLikeFailureProps) *shimast.Node
 }
 
 type UnionExplorer_ArrayLikeCheckerProps struct {
@@ -99,6 +100,12 @@ type UnionExplorer_ArrayLikeDecoderProps struct {
   Explore    any
 }
 
+type UnionExplorer_ArrayLikeCandidateProps struct {
+  Input      *shimast.Expression
+  Definition any
+  Explore    any
+}
+
 type UnionExplorer_ArrayLikeFailureProps struct {
   Input    *shimast.Expression
   Expected string
@@ -622,46 +629,69 @@ func unionExplorer_check_union_array_like(props unionExplorer_check_union_array_
       inputType = nativefactories.TypeFactory.Keyword("any", props.Emit)
       postfix = "\"[0]\""
     }
-    return f.NewAsExpression(
-      f.NewArrayLiteralExpression(
+    entries := []*shimast.Node{
+      f.NewArrowFunction(
+        nil,
+        nil,
         f.NewNodeList([]*shimast.Node{
-          f.NewArrowFunction(
-            nil,
-            nil,
-            f.NewNodeList([]*shimast.Node{
-              nativefactories.IdentifierFactory.Parameter("top", inputType, nil, props.Emit),
-            }),
-            nativefactories.TypeFactory.Keyword("any", props.Emit),
+          nativefactories.IdentifierFactory.Parameter("top", inputType, nil, props.Emit),
+        }),
+        nativefactories.TypeFactory.Keyword("any", props.Emit),
+        nil,
+        f.NewToken(shimast.KindEqualsGreaterThanToken),
+        props.Config.Checker(UnionExplorer_ArrayLikeCheckerProps{
+          Input:      f.NewIdentifier("top"),
+          Definition: props.Accessor.Element(meta),
+          Explore:    unionExplorer_with_postfix(props.Explore, false, postfix),
+          Container:  array,
+        }),
+      ),
+      f.NewArrowFunction(
+        nil,
+        nil,
+        f.NewNodeList([]*shimast.Node{
+          nativefactories.IdentifierFactory.Parameter(
+            "entire",
+            f.NewTypeReferenceNode(f.NewIdentifier("any[]"), nil),
             nil,
-            f.NewToken(shimast.KindEqualsGreaterThanToken),
-            props.Config.Checker(UnionExplorer_ArrayLikeCheckerProps{
-              Input:      f.NewIdentifier("top"),
-              Definition: props.Accessor.Element(meta),
-              Explore:    unionExplorer_with_postfix(props.Explore, false, postfix),
-              Container:  array,
-            }),
+            props.Emit,
           ),
-          f.NewArrowFunction(
-            nil,
-            nil,
-            f.NewNodeList([]*shimast.Node{
-              nativefactories.IdentifierFactory.Parameter(
-                "entire",
-                f.NewTypeReferenceNode(f.NewIdentifier("any[]"), nil),
-                nil,
-                props.Emit,
-              ),
-            }),
-            nativefactories.TypeFactory.Keyword("any", props.Emit),
+        }),
+        nativefactories.TypeFactory.Keyword("any", props.Emit),
+        nil,
+        f.NewToken(shimast.KindEqualsGreaterThanToken),
+        props.Config.Decoder(UnionExplorer_ArrayLikeDecoderProps{
+          Input:      f.NewIdentifier("entire"),
+          Definition: meta,
+          Explore:    unionExplorer_with_tracable(props.Explore, true),
+        }),
+      ),
+    }
+    if props.Config.Candidate != nil {
+      entries = append(entries, f.NewArrowFunction(
+        nil,
+        nil,
+        f.NewNodeList([]*shimast.Node{
+          nativefactories.IdentifierFactory.Parameter(
+            "entire",
+            f.NewTypeReferenceNode(f.NewIdentifier("any[]"), nil),
             nil,
-            f.NewToken(shimast.KindEqualsGreaterThanToken),
-            props.Config.Decoder(UnionExplorer_ArrayLikeDecoderProps{
-              Input:      f.NewIdentifier("entire"),
-              Definition: meta,
-              Explore:    unionExplorer_with_tracable(props.Explore, true),
-            }),
+            props.Emit,
           ),
         }),
+        nativefactories.TypeFactory.Keyword("boolean", props.Emit),
+        nil,
+        f.NewToken(shimast.KindEqualsGreaterThanToken),
+        props.Config.Candidate(UnionExplorer_ArrayLikeCandidateProps{
+          Input:      f.NewIdentifier("entire"),
+          Definition: meta,
+          Explore:    unionExplorer_with_tracable(props.Explore, false),
+        }),
+      ))
+    }
+    return f.NewAsExpression(
+      f.NewArrayLiteralExpression(
+        f.NewNodeList(entries),
         true,
       ),
       f.NewTypeReferenceNode(f.NewIdentifier("const"), nil),
@@ -709,12 +739,17 @@ func unionExplorer_check_union_array_like(props unionExplorer_check_union_array_
         "pred",
         f.NewIdentifier("tuplePredicators"),
         f.NewIfStatement(
-          f.NewCallExpression(
-            f.NewIdentifier("pred[0]"),
-            nil,
-            nil,
-            f.NewNodeList([]*shimast.Node{array}),
-            shimast.NodeFlagsNone,
+          unionExplorer_array_candidate_condition(
+            f.NewCallExpression(
+              f.NewIdentifier("pred[0]"),
+              nil,
+              nil,
+              f.NewNodeList([]*shimast.Node{array}),
+              shimast.NodeFlagsNone,
+            ),
+            props.Config.Candidate != nil,
+            array,
+            props.Emit,
           ),
           f.NewReturnStatement(
             f.NewCallExpression(
@@ -741,12 +776,12 @@ func unionExplorer_check_union_array_like(props unionExplorer_check_union_array_
     for _, x := range arrayList {
       arrayPredicates = append(arrayPredicates, predicate(x))
     }
-    statements = append(statements,
-      nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-        Name:  "top",
-        Value: props.Accessor.Front(props.Input),
-      }, props.Emit),
-      f.NewIfStatement(
+    statements = append(statements, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+      Name:  "top",
+      Value: props.Accessor.Front(props.Input),
+    }, props.Emit))
+    if props.Config.Candidate == nil {
+      statements = append(statements, f.NewIfStatement(
         f.NewBinaryExpression(
           nil,
           nativefactories.ExpressionFactory.Number(0, props.Emit),
@@ -756,7 +791,9 @@ func unionExplorer_check_union_array_like(props unionExplorer_check_union_array_
         ),
         unionExplorer_return_or_statement(props.Config.Empty, props.Emit),
         nil,
-      ),
+      ))
+    }
+    statements = append(statements,
       nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
         Name: "arrayPredicators",
         Value: f.NewArrayLiteralExpression(
@@ -780,19 +817,37 @@ func unionExplorer_check_union_array_like(props unionExplorer_check_union_array_
               nil,
               nil,
               f.NewToken(shimast.KindEqualsGreaterThanToken),
-              f.NewCallExpression(
-                f.NewIdentifier("pred[0]"),
-                nil,
-                nil,
-                f.NewNodeList([]*shimast.Node{top}),
-                shimast.NodeFlagsNone,
-              ),
+              func() *shimast.Node {
+                element := f.NewCallExpression(
+                  f.NewIdentifier("pred[0]"),
+                  nil,
+                  nil,
+                  f.NewNodeList([]*shimast.Node{top}),
+                  shimast.NodeFlagsNone,
+                )
+                if props.Config.Candidate == nil {
+                  return element
+                }
+                return f.NewBinaryExpression(
+                  nil,
+                  f.NewBinaryExpression(
+                    nil,
+                    nativefactories.ExpressionFactory.Number(0, props.Emit),
+                    nil,
+                    f.NewToken(shimast.KindEqualsEqualsEqualsToken),
+                    props.Accessor.Size(props.Input),
+                  ),
+                  nil,
+                  f.NewToken(shimast.KindBarBarToken),
+                  element,
+                )
+              }(),
             ),
           }),
           shimast.NodeFlagsNone,
         ),
       }, props.Emit),
-      unionExplorer_array_if(iterate, array, top, props.Config.Success, props.Emit),
+      unionExplorer_array_if(iterate, array, top, props.Config.Success, props.Config.Candidate != nil, props.Emit),
     )
   }
   names := make([]string, 0, len(targets))
@@ -819,8 +874,75 @@ func unionExplorer_check_union_array_like(props unionExplorer_check_union_array_
   )
 }
 
-func unionExplorer_array_if(iterate func(init string, from *shimast.Expression, ifStatement *shimast.Node) *shimast.Node, array *shimast.Node, top *shimast.Node, success *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
+func unionExplorer_array_if(iterate func(init string, from *shimast.Expression, ifStatement *shimast.Node) *shimast.Node, array *shimast.Node, top *shimast.Node, success *shimast.Expression, candidate bool, emit ...*shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(unionExplorer_factory, emit...)
+  if candidate {
+    elementCondition := f.NewCallExpression(
+      nativefactories.IdentifierFactory.Access(nil, array, "every"),
+      nil,
+      nil,
+      f.NewNodeList([]*shimast.Node{
+        f.NewArrowFunction(
+          nil,
+          nil,
+          f.NewNodeList([]*shimast.Node{
+            nativefactories.IdentifierFactory.Parameter("value", nativefactories.TypeFactory.Keyword("any", emit...), nil, emit...),
+          }),
+          nil,
+          nil,
+          f.NewToken(shimast.KindEqualsGreaterThanToken),
+          f.NewBinaryExpression(
+            nil,
+            success,
+            nil,
+            f.NewToken(shimast.KindEqualsEqualsEqualsToken),
+            f.NewCallExpression(
+              f.NewIdentifier("pred[0]"),
+              nil,
+              nil,
+              f.NewNodeList([]*shimast.Node{f.NewIdentifier("value")}),
+              shimast.NodeFlagsNone,
+            ),
+          ),
+        ),
+      }),
+      shimast.NodeFlagsNone,
+    )
+    return f.NewBlock(f.NewNodeList([]*shimast.Node{
+      iterate(
+        "pred",
+        f.NewIdentifier("passed"),
+        f.NewIfStatement(
+          unionExplorer_array_candidate_condition(elementCondition, true, array, emit...),
+          f.NewReturnStatement(f.NewCallExpression(
+            f.NewIdentifier("pred[1]"),
+            nil,
+            nil,
+            f.NewNodeList([]*shimast.Node{array}),
+            shimast.NodeFlagsNone,
+          )),
+          nil,
+        ),
+      ),
+      f.NewIfStatement(
+        f.NewBinaryExpression(
+          nil,
+          nativefactories.ExpressionFactory.Number(0, emit...),
+          nil,
+          f.NewToken(shimast.KindLessThanToken),
+          f.NewIdentifier("passed.length"),
+        ),
+        f.NewReturnStatement(f.NewCallExpression(
+          f.NewIdentifier("passed[0][1]"),
+          nil,
+          nil,
+          f.NewNodeList([]*shimast.Node{array}),
+          shimast.NodeFlagsNone,
+        )),
+        nil,
+      ),
+    }), true)
+  }
   return f.NewIfStatement(
     f.NewBinaryExpression(
       nil,
@@ -910,6 +1032,26 @@ func unionExplorer_array_if(iterate func(init string, from *shimast.Expression,
   )
 }
 
+func unionExplorer_array_candidate_condition(element *shimast.Node, candidate bool, array *shimast.Node, emit ...*shimprinter.EmitContext) *shimast.Node {
+  if candidate == false {
+    return element
+  }
+  f := nativecontext.EmitFactoryOf(unionExplorer_factory, emit...)
+  return f.NewBinaryExpression(
+    nil,
+    f.NewCallExpression(
+      f.NewIdentifier("pred[2]"),
+      nil,
+      nil,
+      f.NewNodeList([]*shimast.Node{array}),
+      shimast.NodeFlagsNone,
+    ),
+    nil,
+    f.NewToken(shimast.KindAmpersandAmpersandToken),
+    element,
+  )
+}
+
 func unionExplorer_return_or_statement(node *shimast.Node, emit ...*shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(unionExplorer_factory, emit...)
   if node == nil || node.Kind == shimast.KindReturnStatement {