vendor tsgo

2026-07-09 16:50:43 -04:00
parent c06ea2e5a4
commit 98978e4930
5804 changed files with 1556156 additions and 101 deletions
--- a/tools/tsgo/internal/core/core.go
+++ b/tools/tsgo/internal/core/core.go
@@ -0,0 +1,837 @@
+package core
+
+import (
+	"iter"
+	"maps"
+	"math"
+	"os"
+	rtdebug "runtime/debug"
+	"slices"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"unicode"
+	"unicode/utf16"
+	"unicode/utf8"
+
+	"github.com/microsoft/typescript-go/internal/debug"
+	"github.com/microsoft/typescript-go/internal/json"
+	"github.com/microsoft/typescript-go/internal/stringutil"
+	"github.com/microsoft/typescript-go/internal/tspath"
+)
+
+func ApplyDebugStackLimit() {
+	v := os.Getenv("TS_GO_DEBUG_STACK_LIMIT") //nolint:forbidigo
+	if v == "" {
+		return
+	}
+	n, err := strconv.Atoi(v)
+	if err != nil || n <= 0 {
+		return
+	}
+	rtdebug.SetMaxStack(n)
+}
+
+func Filter[T any](slice []T, f func(T) bool) []T {
+	for i, value := range slice {
+		if !f(value) {
+			result := slices.Clone(slice[:i])
+			for i++; i < len(slice); i++ {
+				value = slice[i]
+				if f(value) {
+					result = append(result, value)
+				}
+			}
+			return result
+		}
+	}
+	return slice
+}
+
+func FilterSeq[T any](slice []T, f func(T) bool) iter.Seq[T] {
+	return func(yield func(T) bool) {
+		for _, value := range slice {
+			if f(value) {
+				if !yield(value) {
+					return
+				}
+			}
+		}
+	}
+}
+
+func FilterIndex[T any](slice []T, f func(T, int, []T) bool) []T {
+	for i, value := range slice {
+		if !f(value, i, slice) {
+			result := slices.Clone(slice[:i])
+			for i++; i < len(slice); i++ {
+				value = slice[i]
+				if f(value, i, slice) {
+					result = append(result, value)
+				}
+			}
+			return result
+		}
+	}
+	return slice
+}
+
+func Map[T, U any](slice []T, f func(T) U) []U {
+	if slice == nil {
+		return nil
+	}
+	result := make([]U, len(slice))
+	for i, value := range slice {
+		result[i] = f(value)
+	}
+	return result
+}
+
+func TryMap[T, U any](slice []T, f func(T) (U, error)) ([]U, error) {
+	if len(slice) == 0 {
+		return nil, nil
+	}
+	result := make([]U, len(slice))
+	for i, value := range slice {
+		mapped, err := f(value)
+		if err != nil {
+			return nil, err
+		}
+		result[i] = mapped
+	}
+	return result, nil
+}
+
+func MapIndex[T, U any](slice []T, f func(T, int) U) []U {
+	if slice == nil {
+		return nil
+	}
+	result := make([]U, len(slice))
+	for i, value := range slice {
+		result[i] = f(value, i)
+	}
+	return result
+}
+
+func MapNonNil[T any, U comparable](slice []T, f func(T) U) []U {
+	var result []U
+	for _, value := range slice {
+		mapped := f(value)
+		if mapped != *new(U) {
+			result = append(result, mapped)
+		}
+	}
+	return result
+}
+
+func MapFiltered[T any, U any](slice []T, f func(T) (U, bool)) []U {
+	var result []U
+	for _, value := range slice {
+		mapped, ok := f(value)
+		if !ok {
+			continue
+		}
+		result = append(result, mapped)
+	}
+	return result
+}
+
+func FlatMap[T any, U any](slice []T, f func(T) []U) []U {
+	var result []U
+	for _, value := range slice {
+		mapped := f(value)
+		if len(mapped) != 0 {
+			result = append(result, mapped...)
+		}
+	}
+	return result
+}
+
+func SameMap[T comparable](slice []T, f func(T) T) []T {
+	for i, value := range slice {
+		mapped := f(value)
+		if mapped != value {
+			result := make([]T, len(slice))
+			copy(result, slice[:i])
+			result[i] = mapped
+			for j := i + 1; j < len(slice); j++ {
+				result[j] = f(slice[j])
+			}
+			return result
+		}
+	}
+	return slice
+}
+
+func SameMapIndex[T comparable](slice []T, f func(T, int) T) []T {
+	for i, value := range slice {
+		mapped := f(value, i)
+		if mapped != value {
+			result := make([]T, len(slice))
+			copy(result, slice[:i])
+			result[i] = mapped
+			for j := i + 1; j < len(slice); j++ {
+				result[j] = f(slice[j], j)
+			}
+			return result
+		}
+	}
+	return slice
+}
+
+func Same[T any](s1 []T, s2 []T) bool {
+	if len(s1) == len(s2) {
+		return len(s1) == 0 || &s1[0] == &s2[0]
+	}
+	return false
+}
+
+func Some[T any](slice []T, f func(T) bool) bool {
+	for _, value := range slice { //nolint:modernize
+		if f(value) {
+			return true
+		}
+	}
+	return false
+}
+
+func Every[T any](slice []T, f func(T) bool) bool {
+	for _, value := range slice {
+		if !f(value) {
+			return false
+		}
+	}
+	return true
+}
+
+func Or[T any](funcs ...func(T) bool) func(T) bool {
+	return func(input T) bool {
+		for _, f := range funcs {
+			if f(input) {
+				return true
+			}
+		}
+		return false
+	}
+}
+
+func Find[T any](slice []T, f func(T) bool) T {
+	for _, value := range slice {
+		if f(value) {
+			return value
+		}
+	}
+	return *new(T)
+}
+
+func FindLast[T any](slice []T, f func(T) bool) T {
+	for i := len(slice) - 1; i >= 0; i-- {
+		value := slice[i]
+		if f(value) {
+			return value
+		}
+	}
+	return *new(T)
+}
+
+func FindIndex[T any](slice []T, f func(T) bool) int {
+	for i, value := range slice {
+		if f(value) {
+			return i
+		}
+	}
+	return -1
+}
+
+func FindLastIndex[T any](slice []T, f func(T) bool) int {
+	for i := len(slice) - 1; i >= 0; i-- {
+		value := slice[i]
+		if f(value) {
+			return i
+		}
+	}
+	return -1
+}
+
+func FirstOrNil[T any](slice []T) T {
+	if len(slice) != 0 {
+		return slice[0]
+	}
+	return *new(T)
+}
+
+func LastOrNil[T any](slice []T) T {
+	if len(slice) != 0 {
+		return slice[len(slice)-1]
+	}
+	return *new(T)
+}
+
+func ElementOrNil[T any](slice []T, index int) T {
+	if index < len(slice) {
+		return slice[index]
+	}
+	return *new(T)
+}
+
+func FirstOrNilSeq[T any](seq iter.Seq[T]) T {
+	if seq != nil {
+		for value := range seq {
+			return value
+		}
+	}
+	return *new(T)
+}
+
+func FirstNonNil[T any, U comparable](slice []T, f func(T) U) U {
+	for _, value := range slice {
+		mapped := f(value)
+		if mapped != *new(U) {
+			return mapped
+		}
+	}
+	return *new(U)
+}
+
+func FirstNonZero[T comparable](values ...T) T {
+	var zero T
+	for _, value := range values {
+		if value != zero {
+			return value
+		}
+	}
+	return zero
+}
+
+func Concatenate[T any](s1 []T, s2 []T) []T {
+	if len(s2) == 0 {
+		return s1
+	}
+	if len(s1) == 0 {
+		return s2
+	}
+	return slices.Concat(s1, s2)
+}
+
+func Splice[T any](s1 []T, start int, deleteCount int, items ...T) []T {
+	if start < 0 {
+		start = len(s1) + start
+	}
+	if start < 0 {
+		start = 0
+	}
+	if start > len(s1) {
+		start = len(s1)
+	}
+	if deleteCount < 0 {
+		deleteCount = 0
+	}
+	end := min(start+max(deleteCount, 0), len(s1))
+	if start == end && len(items) == 0 {
+		return s1
+	}
+	return slices.Concat(s1[:start], items, s1[end:])
+}
+
+func CountWhere[T any](slice []T, f func(T) bool) int {
+	count := 0
+	for _, value := range slice {
+		if f(value) {
+			count++
+		}
+	}
+	return count
+}
+
+func ReplaceElement[T any](slice []T, i int, t T) []T {
+	result := slices.Clone(slice)
+	result[i] = t
+	return result
+}
+
+func InsertSorted[T any](slice []T, element T, cmp func(T, T) int) []T {
+	i, _ := slices.BinarySearchFunc(slice, element, cmp)
+	return slices.Insert(slice, i, element)
+}
+
+// MinAllFunc returns all minimum elements from xs according to the comparison function cmp.
+func MinAllFunc[T any](xs []T, cmp func(a, b T) int) []T {
+	if len(xs) == 0 {
+		return nil
+	}
+
+	m := xs[0]
+	mins := []T{m}
+
+	for _, x := range xs[1:] {
+		c := cmp(x, m)
+		switch {
+		case c < 0:
+			m = x
+			mins = mins[:0]
+			mins = append(mins, x)
+		case c == 0:
+			mins = append(mins, x)
+		}
+	}
+
+	return mins
+}
+
+func AppendIfUnique[T comparable](slice []T, element T) []T {
+	if slices.Contains(slice, element) {
+		return slice
+	}
+	return append(slice, element)
+}
+
+func Memoize[T any](create func() T) func() T {
+	var value T
+	return func() T {
+		if create != nil {
+			value = create()
+			create = nil
+		}
+		return value
+	}
+}
+
+// Returns whenTrue if b is true; otherwise, returns whenFalse. IfElse should only be used when branches are either
+// constant or precomputed as both branches will be evaluated regardless as to the value of b.
+func IfElse[T any](b bool, whenTrue T, whenFalse T) T {
+	if b {
+		return whenTrue
+	}
+	return whenFalse
+}
+
+// Returns value if value is not the zero value of T; Otherwise, returns defaultValue. OrElse should only be used when
+// defaultValue is constant or precomputed as its argument will be evaluated regardless as to the content of value.
+func OrElse[T comparable](value T, defaultValue T) T {
+	if value != *new(T) {
+		return value
+	}
+	return defaultValue
+}
+
+// Returns `a` if `a` is not `nil`; Otherwise, returns `b`. Coalesce is roughly analogous to `??` in JS, except that it
+// non-shortcutting, so it is advised to only use a constant or precomputed value for `b`
+func Coalesce[T *U, U any](a T, b T) T {
+	if a == nil {
+		return b
+	} else {
+		return a
+	}
+}
+
+type ECMALineStarts []TextPos
+
+func ComputeECMALineStarts(text string) ECMALineStarts {
+	result := make([]TextPos, 0, strings.Count(text, "\n")+1)
+	return slices.AppendSeq(result, ComputeECMALineStartsSeq(text))
+}
+
+func ComputeECMALineStartsSeq(text string) iter.Seq[TextPos] {
+	return func(yield func(TextPos) bool) {
+		textLen := TextPos(len(text))
+		var pos TextPos
+		var lineStart TextPos
+		for pos < textLen {
+			b := text[pos]
+			if b < utf8.RuneSelf {
+				pos++
+				switch b {
+				case '\r':
+					if pos < textLen && text[pos] == '\n' {
+						pos++
+					}
+					fallthrough
+				case '\n':
+					if !yield(lineStart) {
+						return
+					}
+					lineStart = pos
+				}
+			} else {
+				ch, size := utf8.DecodeRuneInString(text[pos:])
+				pos += TextPos(size)
+				if stringutil.IsLineBreak(ch) {
+					if !yield(lineStart) {
+						return
+					}
+					lineStart = pos
+				}
+			}
+		}
+		yield(lineStart)
+	}
+}
+
+// PositionToLineAndByteOffset returns the 0-based line and byte offset from the
+// start of that line for the given byte position, using the provided line starts.
+// The byte offset is a raw UTF-8 byte offset from the line start, not a UTF-16 code unit count.
+func PositionToLineAndByteOffset(position int, lineStarts []TextPos) (line int, byteOffset int) {
+	line = max(sort.Search(len(lineStarts), func(i int) bool {
+		return int(lineStarts[i]) > position
+	})-1, 0)
+	return line, position - int(lineStarts[line])
+}
+
+// UTF16Offset represents a character offset measured in UTF-16 code units.
+type UTF16Offset int
+
+// UTF16Len returns the number of UTF-16 code units needed to
+// represent the given UTF-8 encoded string.
+func UTF16Len(s string) UTF16Offset {
+	// Fast path: scan for non-ASCII bytes. For ASCII-only strings,
+	// each byte is one UTF-16 code unit, so we can return len(s) directly.
+	for i := range len(s) {
+		if s[i] >= utf8.RuneSelf {
+			// Found non-ASCII; count the ASCII prefix, then decode the rest.
+			n := UTF16Offset(i)
+			for _, r := range s[i:] {
+				n += UTF16Offset(utf16.RuneLen(r))
+			}
+			return n
+		}
+	}
+	return UTF16Offset(len(s))
+}
+
+func Flatten[T any](array [][]T) []T {
+	var result []T
+	for _, subArray := range array {
+		result = append(result, subArray...)
+	}
+	return result
+}
+
+func Must[T any](v T, err error) T {
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Extracts the first value of a multi-value return.
+func FirstResult[T1 any](t1 T1, _ ...any) T1 {
+	return t1
+}
+
+func StringifyJson(input any, prefix string, indent string) (string, error) {
+	output, err := json.MarshalIndent(input, prefix, indent)
+	return string(output), err
+}
+
+func GetScriptKindFromFileName(fileName string) ScriptKind {
+	dotPos := strings.LastIndex(fileName, ".")
+	if dotPos >= 0 {
+		switch strings.ToLower(fileName[dotPos:]) {
+		case tspath.ExtensionJs, tspath.ExtensionCjs, tspath.ExtensionMjs:
+			return ScriptKindJS
+		case tspath.ExtensionJsx:
+			return ScriptKindJSX
+		case tspath.ExtensionTs, tspath.ExtensionCts, tspath.ExtensionMts:
+			return ScriptKindTS
+		case tspath.ExtensionTsx:
+			return ScriptKindTSX
+		case tspath.ExtensionJson:
+			return ScriptKindJSON
+		}
+	}
+	return ScriptKindUnknown
+}
+
+// Given a name and a list of names that are *not* equal to the name, return a spelling suggestion if there is one that is close enough.
+// Names less than length 3 only check for case-insensitive equality.
+//
+// find the candidate with the smallest Levenshtein distance,
+//
+//	except for candidates:
+//	  * With no name
+//	  * Whose length differs from the target name by more than 0.34 of the length of the name.
+//	  * Whose levenshtein distance is more than 0.4 of the length of the name
+//	    (0.4 allows 1 substitution/transposition for every 5 characters,
+//	     and 1 insertion/deletion at 3 characters)
+//
+// @internal
+func GetSpellingSuggestion[T any](name string, candidates iter.Seq[T], getName func(T) string, compare func(T, T) int) T {
+	runeName := []rune(name)
+	maximumLengthDifference := max(2, int(float64(len(runeName))*0.34))
+	bestDistance := math.Floor(float64(len(runeName))*0.4) + 0.9 // If the best result is worse than this, don't bother.
+	buffers := levenshteinBuffersPool.Get().(*levenshteinBuffers)
+	defer levenshteinBuffersPool.Put(buffers)
+	var bestCandidate T
+	hasBest := false
+	for candidate := range candidates {
+		candidateName := getName(candidate)
+		maxLen := max(len(candidateName), len(runeName))
+		minLen := min(len(candidateName), len(runeName))
+		if candidateName != "" && maxLen-minLen <= maximumLengthDifference {
+			if candidateName == name {
+				continue
+			}
+			// Only consider candidates less than 3 characters long when they differ by case.
+			// Otherwise, don't bother, since a user would usually notice differences of a 2-character name.
+			if len(candidateName) < 3 && !strings.EqualFold(candidateName, name) {
+				continue
+			}
+			distance := levenshteinWithMax(buffers, runeName, []rune(candidateName), bestDistance)
+			if distance < 0 {
+				continue
+			}
+			debug.Assert(distance <= bestDistance) // Else `levenshteinWithMax` should return undefined
+			if distance < bestDistance {
+				bestDistance = distance
+				bestCandidate = candidate
+				hasBest = true
+			} else if !hasBest || compare(candidate, bestCandidate) < 0 {
+				bestCandidate = candidate
+				hasBest = true
+			}
+		}
+	}
+	return bestCandidate
+}
+
+func GetSpellingSuggestionForStrings(name string, candidates iter.Seq[string]) string {
+	return GetSpellingSuggestion(name, candidates, Identity, strings.Compare)
+}
+
+type levenshteinBuffers struct {
+	previous []float64
+	current  []float64
+}
+
+var levenshteinBuffersPool = sync.Pool{
+	New: func() any {
+		return &levenshteinBuffers{}
+	},
+}
+
+func levenshteinWithMax(buffers *levenshteinBuffers, s1 []rune, s2 []rune, maxValue float64) float64 {
+	bufferSize := len(s2) + 1
+	buffers.previous = slices.Grow(buffers.previous[:0], bufferSize)[:bufferSize]
+	buffers.current = slices.Grow(buffers.current[:0], bufferSize)[:bufferSize]
+
+	previous := buffers.previous
+	current := buffers.current
+
+	big := maxValue + 0.01
+	for i := range previous {
+		previous[i] = float64(i)
+	}
+	for i := 1; i <= len(s1); i++ {
+		c1 := s1[i-1]
+		minJ := max(int(math.Ceil(float64(i)-maxValue)), 1)
+		maxJ := min(int(math.Floor(maxValue+float64(i))), len(s2))
+		colMin := float64(i)
+		current[0] = colMin
+		for j := 1; j < minJ; j++ {
+			current[j] = big
+		}
+		for j := minJ; j <= maxJ; j++ {
+			var substitutionDistance, dist float64
+			if unicode.ToLower(s1[i-1]) == unicode.ToLower(s2[j-1]) {
+				substitutionDistance = previous[j-1] + 0.1
+			} else {
+				substitutionDistance = previous[j-1] + 2
+			}
+			if c1 == s2[j-1] {
+				dist = previous[j-1]
+			} else {
+				dist = math.Min(previous[j]+1, math.Min(current[j-1]+1, substitutionDistance))
+			}
+			current[j] = dist
+			colMin = math.Min(colMin, dist)
+		}
+		for j := maxJ + 1; j <= len(s2); j++ {
+			current[j] = big
+		}
+		if colMin > maxValue {
+			// Give up -- everything in this column is > max and it can't get better in future columns.
+			return -1
+		}
+		previous, current = current, previous
+	}
+	res := previous[len(s2)]
+	if res > maxValue {
+		return -1
+	}
+	return res
+}
+
+func Identity[T any](t T) T {
+	return t
+}
+
+func CheckEachDefined[S any](s []*S, msg string) []*S {
+	for _, value := range s {
+		if value == nil {
+			panic(msg)
+		}
+	}
+	return s
+}
+
+func IndexAfter(s string, pattern string, startIndex int) int {
+	matched := strings.Index(s[startIndex:], pattern)
+	if matched == -1 {
+		return -1
+	} else {
+		return matched + startIndex
+	}
+}
+
+func ShouldRewriteModuleSpecifier(specifier string, compilerOptions *CompilerOptions) bool {
+	return compilerOptions.RewriteRelativeImportExtensions.IsTrue() && tspath.PathIsRelative(specifier) && !tspath.IsDeclarationFileName(specifier) && tspath.HasTSFileExtension(specifier)
+}
+
+func SingleElementSlice[T any](element *T) []*T {
+	if element == nil {
+		return nil
+	}
+	return []*T{element}
+}
+
+func ConcatenateSeq[T any](seqs ...iter.Seq[T]) iter.Seq[T] {
+	return func(yield func(T) bool) {
+		for _, seq := range seqs {
+			if seq == nil {
+				continue
+			}
+			for e := range seq {
+				if !yield(e) {
+					return
+				}
+			}
+		}
+	}
+}
+
+// Enumerate returns a sequence of (index, value) pairs from the input sequence.
+func Enumerate[T any](seq iter.Seq[T]) iter.Seq2[int, T] {
+	return func(yield func(int, T) bool) {
+		i := 0
+		for v := range seq {
+			if !yield(i, v) {
+				return
+			}
+			i++
+		}
+	}
+}
+
+func comparableValuesEqual[T comparable](a, b T) bool {
+	return a == b
+}
+
+// DiffMaps compares two maps m1 and m2 and calls the provided callbacks for added, removed, and changed entries.
+// onAdded is called for each key-value pair that is in m2 but not in m1.
+// onRemoved is called for each key-value pair that is in m1 but not in m2.
+// onChanged is called for each key where the value in m1 differs from the value in m2.
+func DiffMaps[K comparable, V comparable](m1 map[K]V, m2 map[K]V, onAdded func(K, V), onRemoved func(K, V), onChanged func(K, V, V)) {
+	DiffMapsFunc(m1, m2, comparableValuesEqual, onAdded, onRemoved, onChanged)
+}
+
+// DiffMapsFunc compares two maps m1 and m2 and calls the provided callbacks for added, removed, and changed entries.
+// onAdded is called for each key-value pair that is in m2 but not in m1.
+// onRemoved is called for each key-value pair that is in m1 but not in m2.
+// onChanged is called for each key where the value in m1 differs from the value in m2.
+func DiffMapsFunc[K comparable, V1 any, V2 any](m1 map[K]V1, m2 map[K]V2, equalValues func(V1, V2) bool, onAdded func(K, V2), onRemoved func(K, V1), onChanged func(K, V1, V2)) {
+	if onAdded != nil {
+		for k, v2 := range m2 {
+			if _, ok := m1[k]; !ok {
+				onAdded(k, v2)
+			}
+		}
+	}
+	if onChanged == nil && onRemoved == nil {
+		return
+	}
+	for k, v1 := range m1 {
+		if v2, ok := m2[k]; ok {
+			if onChanged != nil && !equalValues(v1, v2) {
+				onChanged(k, v1, v2)
+			}
+		} else {
+			onRemoved(k, v1)
+		}
+	}
+}
+
+// CopyMapInto is maps.Copy, unless dst is nil, in which case it clones and returns src.
+// Use CopyMapInto anywhere you would use maps.Copy preceded by a nil check and map initialization.
+func CopyMapInto[M1 ~map[K]V, M2 ~map[K]V, K comparable, V any](dst M1, src M2) map[K]V {
+	if dst == nil {
+		return maps.Clone(src)
+	}
+	maps.Copy(dst, src)
+	return dst
+}
+
+// UnorderedEqual returns true if s1 and s2 contain the same elements, regardless of order.
+func UnorderedEqual[T comparable](s1 []T, s2 []T) bool {
+	if len(s1) != len(s2) {
+		return false
+	}
+	counts := make(map[T]int)
+	for _, v := range s1 {
+		counts[v]++
+	}
+	for _, v := range s2 {
+		counts[v]--
+		if counts[v] < 0 {
+			return false
+		}
+	}
+	return true
+}
+
+func Deduplicate[T comparable](slice []T) []T {
+	if len(slice) > 1 {
+		for i, value := range slice {
+			if slices.Contains(slice[:i], value) {
+				result := slices.Clone(slice[:i])
+				for i++; i < len(slice); i++ {
+					value = slice[i]
+					if !slices.Contains(result, value) {
+						result = append(result, value)
+					}
+				}
+				return result
+			}
+		}
+	}
+	return slice
+}
+
+func DeduplicateSorted[T any](slice []T, isEqual func(a, b T) bool) []T {
+	if len(slice) == 0 {
+		return slice
+	}
+	last := slice[0]
+	deduplicated := slice[:1]
+	for i := 1; i < len(slice); i++ {
+		next := slice[i]
+		if isEqual(last, next) {
+			continue
+		}
+
+		deduplicated = append(deduplicated, next)
+		last = next
+	}
+
+	return deduplicated
+}
+
+// CompareBooleans treats true as greater than false.
+func CompareBooleans(a, b bool) int {
+	if a && !b {
+		return 1
+	} else if !a && b {
+		return -1
+	}
+	return 0
+}