typia 15.0.0 → 15.1.0

package/native/core/factories/expression_factory_number_spells_non_finite_values_test.go

@@ -0,0 +1,74 @@
+package factories
+
+import (
+  "math"
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestExpressionFactoryNumberSpellsNonFiniteValues verifies number literals for
+// NaN and the infinities.
+//
+// ExpressionFactory.Number built the literal text with `fmt.Sprint`, which
+// spells positive infinity `+Inf` and prints the magnitude of negative infinity
+// as `Inf`. Both reached the emit as identifiers JavaScript does not declare, so
+// every emitted schema, validator, or random bound carrying one threw
+// `ReferenceError: Inf is not defined` on its first run (samchon/typia#2452).
+// The expected shapes are the JavaScript globals TypeScript's own factory
+// prints. Finite values are the negative twin and must keep their literal.
+//
+//  1. Build numbers for NaN, positive and negative infinity.
+//  2. Assert they are the `NaN` / `Infinity` identifiers, negated for -Infinity.
+//  3. Assert finite values, negative ones, and zero keep numeric literals, with
+//     negative zero negated like any negative value rather than spelled `-0`
+//     inside one literal.
+//
+// @evidence contracts/testing.md#behavioral-verification ExpressionFactory.Number is called with NaN, both infinities, finite values, negatives and negative zero, and the produced AST node kinds and texts are compared; the pre-fix +Inf and Inf spellings would fail the identifier checks.
+// @evidence contracts/testing.md#independent-expectations The expected shapes are the JavaScript globals NaN and Infinity (negated for minus infinity) as TypeScript's own factory prints them, authored in the test rather than read from the factory.
+// @evidence contracts/testing.md#distinguishing-cases Finite values and zero are the negative twins that must keep numeric literals, negative values must be negated and negative zero is checked separately from positive zero.
+// @evidence contracts/testing.md#execution-ownership The canonical native Go command (pnpm test:go:native) runs this same-package Test function in process. It builds AST nodes in memory and reads their kinds, with no checker, filesystem fixture or process.
+func TestExpressionFactoryNumberSpellsNonFiniteValues(t *testing.T) {
+  identifier := func(node *shimast.Node, name string) bool {
+    return node != nil && node.Kind == shimast.KindIdentifier && node.Text() == name
+  }
+
+  if node := ExpressionFactory.Number(math.NaN()); identifier(node, "NaN") == false {
+    t.Fatalf("NaN should be the NaN identifier, got kind %v", node.Kind)
+  }
+  if node := ExpressionFactory.Number(math.Inf(1)); identifier(node, "Infinity") == false {
+    t.Fatalf("+Inf should be the Infinity identifier, got kind %v", node.Kind)
+  }
+  negative := ExpressionFactory.Number(math.Inf(-1))
+  if negative.Kind != shimast.KindPrefixUnaryExpression {
+    t.Fatalf("-Inf should be a negation, got kind %v", negative.Kind)
+  }
+  unary := negative.AsPrefixUnaryExpression()
+  if unary.Operator != shimast.KindMinusToken || identifier(unary.Operand, "Infinity") == false {
+    t.Fatal("-Inf should negate the Infinity identifier")
+  }
+
+  for _, item := range []struct {
+    value    any
+    negative bool
+    text     string
+  }{
+    {3, false, "3"},
+    {1.5, false, "1.5"},
+    {int64(0), false, "0"},
+    {-12, true, "12"},
+    {-2.5, true, "2.5"},
+    {math.Copysign(0, -1), true, "0"},
+  } {
+    node := ExpressionFactory.Number(item.value)
+    if item.negative {
+      if node.Kind != shimast.KindPrefixUnaryExpression {
+        t.Fatalf("%v should be a negation, got kind %v", item.value, node.Kind)
+      }
+      node = node.AsPrefixUnaryExpression().Operand
+    }
+    if node.Kind != shimast.KindNumericLiteral || node.Text() != item.text {
+      t.Fatalf("%v should be the numeric literal %q, got kind %v", item.value, item.text, node.Kind)
+    }
+  }
+}

package/native/core/factories/factory_utility_coverage_test.go

@@ -21,15 +21,20 @@ import (
 // TestFactoryUtilityCoverage covers small factory helpers.
 //
 // Most factory paths are exercised through TypeScript transforms, but simple
-// AST helper branches and text-formatting helpers do not need a compiler
-// program. This test keeps those deterministic helper checks local to the
-// factories package.
+// AST helper branches and text-formatting helpers are called directly. The
+// checker-backed type-name cases also load a temporary TypeScript fixture in
+// process. Both remain local to the factories package.
 //
 // 1. Generate numeric range predicates for all supported numeric tags.
 // 2. Exercise bigint, object, currying, self-call, and escaped-text helpers.
 // 3. Cover comment merging and statement helper branches.
 // 4. Verify fallback AST, literal, protobuf, sequence validation, and type-tag factory paths.
 // 5. Resolve TypeScript checker-backed type names and synthetic function declarations.
+//
+// @evidence contracts/testing.md#behavioral-verification Small factory helpers are called directly: numeric and bigint range predicates, currying, self-call, escaped-text and comment-merging helpers. Roughly half of the assertions only require a non-nil AST node, so they detect a missing result and not a wrong one; the others compare exact text or structure.
+// @evidence contracts/testing.md#independent-expectations Where text is compared the expectations are authored literals; the non-nil checks have no independent expectation and certify only that a node was produced. This is a limitation of the test, not a verification of emitted code.
+// @evidence contracts/testing.md#distinguishing-cases Every supported numeric tag, bigint, object, currying and escaping branch is visited once; most branches have no negative twin, so an over-matching helper could still pass.
+// @evidence contracts/testing.md#execution-ownership The typia_native_internal Go command (go -C packages/typia/test test -tags typia_native_internal ../native/...) runs this same-package unit Test in process. AST helpers use the node factory; checker-backed cases write a temporary TypeScript fixture, load it through driver.LoadProgram, and close the program. No compiler or JavaScript subprocess is launched.
 func TestFactoryUtilityCoverage(t *testing.T) {
   emit := shimprinter.NewEmitContext()
   input := expressionFactory_factory.NewIdentifier("input")

package/native/core/factories/format_alias_resolves_to_cheat_sheet_test.go

@@ -18,6 +18,11 @@ import (
 // 1. Parse each alias spelling of the `date-time` format as a JSDoc comment tag.
 // 2. Require the emitted format name, schema, and tag name to be the canonical one.
 // 3. Require the generated validator to be the cheat sheet entry verbatim.
+//
+// @evidence contracts/testing.md#behavioral-verification Every @format alias is expanded by the comment tag factory and the produced tag is compared with the cheat sheet entry it must equal: tag count, canonical value, name, emitted schema format and validator text.
+// @evidence contracts/testing.md#independent-expectations The cheat sheet entry for the canonical format is the reference; the alias must produce exactly that entry, so a second implementation under the alias name is detected without hard-coding either validator string.
+// @evidence contracts/testing.md#distinguishing-cases Each alias is checked individually, and a lookup of a missing canonical name is a guard that the sweep covers real entries. Aliases that do not exist cannot be detected by this test.
+// @evidence contracts/testing.md#execution-ownership The canonical native Go command (pnpm test:go:native) runs this same-package Test function in process. It calls the factory in memory with no checker, filesystem fixture or process.
 func TestFormatAliasResolvesToCheatSheet(t *testing.T) {
   canonical := "date-time"
   expected, ok := FormatCheatSheet[canonical]

package/native/core/factories/format_alias_table_targets_the_cheat_sheet_test.go

@@ -2,40 +2,30 @@ package factories
 
 import "testing"
 
-// TestFormatAliasTableTargetsTheCheatSheet verifies every declared `@format` alias names a real cheat sheet format.
+// TestFormatAliasTableTargetsTheCheatSheet verifies supported format spellings resolve to canonical validators.
 //
-// The original defect was structural, not arithmetic: the aliases were appended
-// after a loop that copied the cheat sheet, so they were invisible to any sweep
-// that enumerated the cheat sheet's entries and could drift from the format they
-// emit without contradicting anything. The alias table now holds only cheat
-// sheet keys, and this pins that shape — an alias pointing nowhere, or shadowing
-// a real format with a different meaning, fails here rather than at a user's
-// call site.
+// Alternative date-time spellings must share the canonical validator rather
+// than resolve to a second implementation. Authored requests exercise the
+// resolver independently of how its alias table is represented.
 //
-// 1. Require every alias to resolve to an existing cheat sheet entry.
-// 2. Require no alias to shadow a cheat sheet key of its own name.
+// 1. Resolve both supported aliases and the canonical date-time spelling.
+// 2. Compare canonical names and validator references, including password.
 // 3. Require resolution to reject a format the cheat sheet does not own.
+//
+// @evidence contracts/testing.md#behavioral-verification The resolver is called with authored alternative spellings, their canonical date-time name, another canonical name and an unsupported name; canonical name and validator identity are compared. No assertion depends on the alias table's arrangement.
+// @evidence contracts/testing.md#independent-expectations The supported dateTime and datetime spellings mean date-time independently of the table. The cheat sheet supplies the shared validator reference, so this detects wrong resolution but not a defect shared by the canonical validator itself.
+// @evidence contracts/testing.md#distinguishing-cases Both supported aliases, the canonical date-time spelling, a non-alias canonical password and an unsupported name distinguish lookup branches; the sibling expansion test owns the emitted tag shape.
+// @evidence contracts/testing.md#execution-ownership The canonical native Go command (pnpm test:go:native) runs this same-package Test function in process. It reads the package tables and calls the resolver in memory with no filesystem fixture or process.
 func TestFormatAliasTableTargetsTheCheatSheet(t *testing.T) {
-  if len(formatCheatSheet_ALIASES) == 0 {
-    t.Fatal("the alias table should stay the enumerable owner of every alternative spelling")
-  }
-  for alias, canonical := range formatCheatSheet_ALIASES {
-    expected, ok := FormatCheatSheet[canonical]
-    if ok == false {
-      t.Fatalf("the alias %s targets %s, which the cheat sheet does not own", alias, canonical)
-    }
-    if _, ok := FormatCheatSheet[alias]; ok {
-      t.Fatalf("the alias %s shadows a cheat sheet format of the same name", alias)
-    }
-    name, validate, ok := formatCheatSheet_resolve(alias)
-    if ok == false || name != canonical || validate != expected {
-      t.Fatalf("the alias %s must resolve to the cheat sheet %s entry, resolved to %s", alias, canonical, name)
-    }
-  }
-  for name, validate := range FormatCheatSheet {
-    resolvedName, resolvedValidate, ok := formatCheatSheet_resolve(name)
-    if ok == false || resolvedName != name || resolvedValidate != validate {
-      t.Fatalf("the canonical format %s must resolve to itself", name)
+  for _, item := range []struct {
+    input     string
+    canonical string
+  }{
+    {"datetime", "date-time"}, {"dateTime", "date-time"}, {"date-time", "date-time"}, {"password", "password"},
+  } {
+    name, validate, ok := formatCheatSheet_resolve(item.input)
+    if !ok || name != item.canonical || validate != FormatCheatSheet[item.canonical] {
+      t.Fatalf("%s must resolve to the canonical %s validator, got %s (%t)", item.input, item.canonical, name, ok)
     }
   }
   if _, _, ok := formatCheatSheet_resolve("not-a-format"); ok {

package/native/core/factories/identifier_factory_postfix_escapes_every_key_test.go

@@ -23,6 +23,11 @@ import (
 //  2. Decode every result as JSON twice and assert the original key survives.
 //  3. Assert the identifier fast path stays a dotted accessor, so ordinary keys
 //     and prototype-shadowing keys keep their existing output.
+//
+// @evidence contracts/testing.md#behavioral-verification IdentifierFactory.Postfix is called on keys with quotes, backslashes, separators and unicode; the output must equal the authored string, parse as a JavaScript string literal, and the accessor must decode back to the key.
+// @evidence contracts/testing.md#independent-expectations Authored expected strings plus a decoding oracle (JSON parsing of the emitted accessor) establish correctness independently of the escaper.
+// @evidence contracts/testing.md#distinguishing-cases A table of regressed characters plus round-trip checks for dotted and bracketed accessors; a complete sweep is owned by the code-point test.
+// @evidence contracts/testing.md#execution-ownership The canonical native Go command (pnpm test:go:native) runs this same-package Test function in process. It calls the factory on strings and decodes the result with encoding/json, with no checker, filesystem fixture or process.
 func TestIdentifierFactoryPostfixEscapesEveryKey(t *testing.T) {
   for _, item := range []struct {
     name     string

package/native/core/factories/identifier_factory_postfix_survives_every_code_point_test.go

@@ -25,6 +25,11 @@ import (
 //     escape rather than corrupting the literal.
 //  3. Sweep every single byte, including the ones that are not UTF-8, and assert
 //     the emitted literal still decodes.
+//
+// @evidence contracts/testing.md#behavioral-verification Postfix is called on every Unicode scalar, lone surrogate code unit and single byte. Scalars and valid UTF-8 bytes must round-trip exactly; surrogates must retain their exact escaped code unit and decode without error, while invalid UTF-8 bytes are checked only for decodability.
+// @evidence contracts/testing.md#independent-expectations The independent JSON decoder must recover the authored scalar and valid-byte inputs. It replaces lone surrogates, so their separate authored escape checks establish code-unit preservation; no exact decoded value is asserted for invalid UTF-8 bytes.
+// @evidence contracts/testing.md#distinguishing-cases An exhaustive sweep closes the class of unescaped characters that the table-driven case samples.
+// @evidence contracts/testing.md#execution-ownership The canonical native Go command (pnpm test:go:native) runs this same-package Test function in process. It calls the factory on strings and decodes the result with encoding/json, with no checker, filesystem fixture or process.
 func TestIdentifierFactoryPostfixSurvivesEveryCodePoint(t *testing.T) {
   for code := rune(0); code <= utf8.MaxRune; code++ {
     if code >= 0xd800 && code <= 0xdfff {

package/native/core/factories/internal/metadata/IMetadataIteratorProps.go

@@ -5,58 +5,151 @@ import (
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
+// MetadataFactory_IOptions is the option record of the metadata analysis.
+// Escape reads `toJSON`, Absorb folds intersections, Constant keeps literals,
+// Functional analyzes functions, Methods keeps compare methods and
+// StrictObjectMembers rejects members without a JSON form. Validate and OnError
+// are retained caller hooks; Validate is invoked by the analyzer, whereas the
+// current native analyzer does not invoke OnError.
+//
+// @evidence contracts/common.md#principled-implementation Each switch controls one analysis decision: reading `toJSON`, folding intersections, keeping literals, analyzing functions, keeping compare methods and rejecting members without a JSON form. Validate supplies consumer rejection reasons; OnError preserves the caller's hook shape but is not invoked by the current native analyzer.
+// @evidence contracts/common.md#clear-and-simple-design One flat record; the field comments explain the two options whose purpose is not obvious.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Options are parameters of the analysis and no consumer name appears.
+// @evidence contracts/common.md#meaningful-documentation The doc lists every switch and the field comments cover Methods and StrictObjectMembers.
 type MetadataFactory_IOptions struct {
-  Escape     bool
-  Absorb     bool
-  Constant   bool
+  // Escape analyzes supported toJSON return types as the escaped JSON shape.
+  Escape bool
+
+  // Absorb expands aliases and allows structural intersection analysis.
+  Absorb bool
+
+  // Constant retains primitive literal values instead of their atomic category.
+  Constant bool
+
+  // Functional collects function parameter and return metadata.
   Functional bool
+
   // Methods opts object/class method members (e.g. an `equals` / `less`
   // method) into the collected properties as function-typed values, without
   // switching on full Functional analysis. Used by the compare programmers to
   // detect user-defined comparison methods.
   Methods bool
+
   // StrictObjectMembers is for consumers whose emitted value promises to
   // satisfy the entire input type. Include accessors and methods in the
   // structural shape and diagnose members that have no JSON representation.
   StrictObjectMembers bool
-  Validate            func(props struct {
+
+  // Validate supplies consumer rejection reasons while traversing the completed
+  // metadata graph. Nil skips this additional validation.
+  Validate func(props struct {
     Metadata *schemametadata.MetadataSchema
     Explore  MetadataFactory_IExplore
     Top      *schemametadata.MetadataSchema
   }) []string
+
+  // OnError retains the caller hook; the current native analyzer does not invoke it.
   OnError func(node any, message string)
 }
 
+// MetadataFactory_IError is one failure: the type name, where it was found and
+// the reasons.
+//
+// @evidence contracts/common.md#principled-implementation A failure names the type, where it was found and why, which is what the diagnostic text needs.
+// @evidence contracts/common.md#clear-and-simple-design A three-field record.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc states the parts.
 type MetadataFactory_IError struct {
-  Name     string
-  Explore  MetadataFactory_IExplore
+  // Name identifies the metadata/type being rejected for diagnostic text.
+  Name string
+
+  // Explore locates the failure within the root analysis.
+  Explore MetadataFactory_IExplore
+
+  // Messages contains the collected rejection reasons at that location.
   Messages []string
 }
 
+// MetadataFactory_IExplore records where the analysis is: whether it is at the
+// top, the object, property or parameter being explored, and the aliased,
+// escaped, nested and output states.
+//
+// @evidence contracts/common.md#principled-implementation The location carries whether the analysis is at the top, the object and property or parameter being explored, and the aliased, escaped, nested and output states, because the same type is analyzed differently in those positions; property and parameter are typed any since they come from different producers.
+// @evidence contracts/common.md#clear-and-simple-design One flat record that iterators copy and modify to descend.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc lists the states.
 type MetadataFactory_IExplore struct {
-  Top       bool
-  Object    *schemametadata.MetadataObjectType
-  Property  any
+  // Top marks the root position rather than a nested member.
+  Top bool
+
+  // Object identifies the containing named object when exploring its members.
+  Object *schemametadata.MetadataObjectType
+
+  // Property carries a literal name or a dynamic-key marker; nil means no member.
+  Property any
+
+  // Parameter carries the current function parameter name when applicable.
   Parameter any
-  Nested    any
-  Aliased   bool
-  Escaped   bool
-  Output    bool
+
+  // Nested identifies the containing alias, array or tuple during descent.
+  Nested any
+
+  // Aliased prevents rewrapping the target in the alias currently being expanded.
+  Aliased bool
+
+  // Escaped marks analysis reached through a toJSON return value.
+  Escaped bool
+
+  // Output marks a function return position rather than its parameters.
+  Output bool
 }
 
+// MetadataFactory_IExplore_Function derives a new exploration state from one.
+//
+// @evidence contracts/common.md#principled-implementation A function from a location to a location lets a caller derive the next state without exposing the record's construction.
+// @evidence contracts/common.md#clear-and-simple-design A function type.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A declaration only.
+// @evidence contracts/common.md#meaningful-documentation The doc states that it derives a state.
 type MetadataFactory_IExplore_Function func(MetadataFactory_IExplore) MetadataFactory_IExplore
 
+// IMetadataIteratorProps is the state passed to every iterator: options, checker,
+// the collection, the error sink, the metadata being filled, the type, the
+// exploration location and the Intersected, Unioned and Prunable flags.
+//
+// @evidence contracts/common.md#principled-implementation Every iterator receives the same record, so adding a decision means adding a field and not changing each signature; the Intersected, Unioned and Prunable flags tell an iterator whether it is inside an intersection or union, which changes how it treats never and brands.
+// @evidence contracts/common.md#clear-and-simple-design One flat record copied with small changes when an iterator recurses.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc lists the fields and what the three flags mean.
 type IMetadataIteratorProps struct {
-  Options     MetadataFactory_IOptions
-  Checker     *nativechecker.Checker
-  Components  *schemametadata.MetadataCollection
-  Errors      *[]MetadataFactory_IError
-  Metadata    *schemametadata.MetadataSchema
-  Type        *nativechecker.Type
-  Explore     MetadataFactory_IExplore
+  // Options selects this analysis's shape and rejection hooks.
+  Options MetadataFactory_IOptions
+
+  // Checker resolves Type and reachable compiler identities.
+  Checker *nativechecker.Checker
+
+  // Components is the per-analysis shared named-type registry.
+  Components *schemametadata.MetadataCollection
+
+  // Errors is the optional append-only analysis failure sink.
+  Errors *[]MetadataFactory_IError
+
+  // Metadata is the mutable union schema filled by the chosen iterator.
+  Metadata *schemametadata.MetadataSchema
+
+  // Type is the compiler type currently being dispatched.
+  Type *nativechecker.Type
+
+  // Explore locates this type's use within the analysis.
+  Explore MetadataFactory_IExplore
+
+  // Intersected suppresses recursive intersection handling for a selected base.
   Intersected bool
-  Unioned     bool
-  Prunable    bool
+
+  // Unioned permits impossible intersection alternatives to be pruned.
+  Unioned bool
+
+  // Prunable permits impossible intersection branches to contribute no values.
+  Prunable bool
 }
 
 var MetadataTypeTagAnalyzer func(props struct {

package/native/core/factories/internal/metadata/MetadataHelper.go

@@ -2,6 +2,7 @@ package metadata
 
 import (
   "strings"
+  "unicode"
 
   nativeast "github.com/microsoft/typescript-go/shim/ast"
   nativechecker "github.com/microsoft/typescript-go/shim/checker"
@@ -587,6 +588,11 @@ func metadata_js_doc_type_expression_text(tag *nativeast.Node) string {
   return metadata_clean_js_doc_text(nativescanner.GetTextOfNode(typ))
 }
 
+// metadata_js_doc_comment_text renders visible text from native JSDoc nodes.
+//
+// Links retain their target or display label. Source-only blank starred lines
+// delimit comment groups and supply no text, even when an unbraced type tag
+// causes the native parser to expose their marker as a JSDocText value.
 func metadata_js_doc_comment_text(list *nativeast.NodeList) string {
   if list == nil {
     return ""
@@ -598,7 +604,9 @@ func metadata_js_doc_comment_text(list *nativeast.NodeList) string {
     }
     switch node.Kind {
     case nativeast.KindJSDocText:
-      parts = append(parts, node.Text())
+      if !metadata_js_doc_text_is_separator_artifact(node) {
+        parts = append(parts, node.Text())
+      }
     case nativeast.KindJSDocLink,
       nativeast.KindJSDocLinkCode,
       nativeast.KindJSDocLinkPlain:
@@ -608,6 +616,61 @@ func metadata_js_doc_comment_text(list *nativeast.NodeList) string {
   return metadata_clean_js_doc_text(strings.Join(parts, ""))
 }
 
+// metadata_js_doc_text_is_separator_artifact recognizes a marker without content.
+//
+// A span starts inside its first line, so its first asterisk is actual text.
+// Subsequent lines may start with one JSDoc marker after a whitespace token
+// beginning with ASCII horizontal whitespace, as the native JSDoc scanner does.
+// Removing that marker must leave only whitespace to establish empty content.
+// Unicode line and paragraph separators are not part of the whitespace token.
+// Actual whitespace between visible nodes remains text. Missing source
+// provenance leaves the parser result untouched.
+func metadata_js_doc_text_is_separator_artifact(node *nativeast.Node) bool {
+  if node == nil {
+    return false
+  }
+  isWhitespace := func(char rune) bool {
+    // Match the native scanner's whitespace, including its BOM and zero-width space.
+    return unicode.IsSpace(char) || char == '\ufeff' || char == '\u200b'
+  }
+  text := strings.TrimFunc(node.Text(), isWhitespace)
+  if text == "" {
+    return false
+  }
+  for _, char := range text {
+    if char != '*' && !isWhitespace(char) {
+      return false
+    }
+  }
+  file := nativeast.GetSourceFileOfNode(node)
+  if file == nil {
+    return false
+  }
+  source := file.Text()
+  start, end := node.Pos(), node.End()
+  if start < 0 || end > len(source) || start >= end {
+    return false
+  }
+  text = strings.ReplaceAll(source[start:end], "\r\n", "\n")
+  text = strings.ReplaceAll(text, "\r", "\n")
+  for index, line := range strings.Split(text, "\n") {
+    if index != 0 {
+      // JSDoc starts whitespace tokens with ASCII horizontal whitespace;
+      // the same token may then include native Unicode whitespace.
+      if len(line) != 0 && strings.ContainsRune(" \t\v\f", rune(line[0])) {
+        line = strings.TrimLeftFunc(line, func(char rune) bool {
+          return char != '\u2028' && char != '\u2029' && isWhitespace(char)
+        })
+      }
+      line = strings.TrimPrefix(line, "*")
+    }
+    if strings.TrimFunc(line, isWhitespace) != "" {
+      return false
+    }
+  }
+  return true
+}
+
 func metadata_js_doc_link_text(node *nativeast.Node) string {
   if node == nil {
     return ""