typenative 0.1.3 → 0.2.0

package/bin/node/process.js

@@ -0,0 +1,316 @@
+// node:process + the global `process`: argv / env / exit / exitCode / cwd /
+// hrtime / memoryUsage / stdout.write / nextTick … (process.env reads and
+// writes are lowered in the transpiler: process.env.X → TnGetenv("X"))
+import { defineClass, defineHelper, defineModule, setResults } from './registry.js';
+const processHelper = `// node:process
+var tnProcessStart = time.Now()
+var tnExitCode float64
+
+// Node's argv shape: [execPath, script, ...args] (the binary is the script)
+func TnProcessArgv() []string {
+	return append([]string{TnProcessExecPath(), os.Args[0]}, os.Args[1:]...)
+}
+
+func TnProcessExecPath() string {
+	exe, err := os.Executable()
+	if err != nil {
+		return os.Args[0]
+	}
+	return exe
+}
+
+func TnSetExitCode(code float64) { tnExitCode = code }
+
+// process.on('exit') listeners (installed by node:events)
+var tnBeforeExit func(code float64)
+var tnExiting bool
+
+func tnRunBeforeExit(code float64) {
+	if tnBeforeExit != nil && !tnExiting {
+		tnExiting = true
+		tnBeforeExit(code)
+	}
+}
+
+// The end of main: exit with process.exitCode
+func TnProcessExit() {
+	tnRunBeforeExit(tnExitCode)
+	if tnExitCode != 0 {
+		os.Exit(int(tnExitCode))
+	}
+}
+
+// process.exit(code?)
+func TnProcessExitWith(code ...float64) {
+	if len(code) > 0 {
+		tnExitCode = code[0]
+	}
+	tnRunBeforeExit(tnExitCode)
+	os.Exit(int(tnExitCode))
+}
+
+func TnProcessChdir(dir string) {
+	if err := os.Chdir(dir); err != nil {
+		panic(TnNodeError("Error", "ENOENT", "ENOENT: no such file or directory, chdir "+tnQuote(dir)))
+	}
+}
+
+func tnQuote(s string) string { return "'" + s + "'" }
+
+// process.hrtime([prev]): [seconds, nanoseconds] of a monotonic clock
+func TnProcessHrtime(prev ...[]float64) []float64 {
+	ns := time.Since(tnProcessStart).Nanoseconds()
+	if len(prev) > 0 && len(prev[0]) == 2 {
+		ns -= int64(prev[0][0])*1e9 + int64(prev[0][1])
+	}
+	return []float64{float64(ns / 1e9), float64(ns % 1e9)}
+}
+
+func TnProcessHrtimeBigint() *tnbig.Int {
+	return tnbig.NewInt(time.Since(tnProcessStart).Nanoseconds())
+}
+
+func TnProcessUptime() float64 { return time.Since(tnProcessStart).Seconds() }
+
+type TnMemoryUsage struct {
+	rss          float64
+	heapTotal    float64
+	heapUsed     float64
+	external     float64
+	arrayBuffers float64
+}
+
+func TnProcessMemoryUsage() *TnMemoryUsage {
+	var m runtime.MemStats
+	runtime.ReadMemStats(&m)
+	return &TnMemoryUsage{rss: float64(m.Sys), heapTotal: float64(m.HeapSys), heapUsed: float64(m.HeapAlloc)}
+}
+
+// process.stdout.write / process.stderr.write (strings or Buffers)
+func TnProcessWrite(w *os.File, v interface{}) bool {
+	switch x := v.(type) {
+	case string:
+		w.WriteString(x)
+	case []byte:
+		w.Write(x)
+	default:
+		fmt.Fprint(w, x)
+	}
+	return true
+}
+
+func TnIsTTY(f *os.File) bool {
+	info, err := f.Stat()
+	return err == nil && info.Mode()&os.ModeCharDevice != 0
+}
+
+func TnProcessKill(pid float64, signal ...interface{}) bool {
+	p, err := os.FindProcess(int(pid))
+	if err != nil {
+		panic(TnNodeError("Error", "ESRCH", "kill ESRCH"))
+	}
+	sig := 15
+	if len(signal) > 0 {
+		switch s := signal[0].(type) {
+		case float64:
+			sig = int(s)
+		case string:
+			switch s {
+			case "SIGINT":
+				sig = 2
+			case "SIGKILL":
+				sig = 9
+			case "SIGHUP":
+				sig = 1
+			case "SIGQUIT":
+				sig = 3
+			}
+		}
+	}
+	if sig == 0 {
+		return true
+	}
+	if sig == 9 || sig == 15 || runtime.GOOS == "windows" {
+		err = p.Kill()
+	} else {
+		err = p.Signal(syscall.Signal(sig))
+	}
+	if err != nil {
+		panic(TnNodeError("Error", "ESRCH", "kill ESRCH"))
+	}
+	return true
+}
+
+func TnProcessEmitWarning(warning interface{}) {
+	msg := fmt.Sprint(warning)
+	if e, ok := warning.(*TnError); ok {
+		msg = e.message
+	}
+	fmt.Fprintf(os.Stderr, "(node:%d) Warning: %s\\n", os.Getpid(), msg)
+}
+
+func TnProcessVersions() *TnMap[string, string] {
+	m := TnNewMap[string, string]()
+	m.Set("node", "24.0.0")
+	m.Set("go", strings.TrimPrefix(runtime.Version(), "go"))
+	return m
+}
+
+// process.env as a whole (Object.keys(process.env), spreading it)
+func TnEnvMap() *TnMap[string, string] {
+	m := TnNewMap[string, string]()
+	for _, kv := range os.Environ() {
+		if i := strings.Index(kv, "="); i > 0 {
+			m.Set(kv[:i], kv[i+1:])
+		}
+	}
+	return m
+}
+
+func TnHasEnv(name string) bool {
+	_, ok := os.LookupEnv(name)
+	return ok
+}`;
+export function registerProcess(r) {
+    defineModule(r, 'process');
+    r.globals['process'] = 'process';
+    r.objects['process.stdout'] = true;
+    r.objects['process.stderr'] = true;
+    r.objects['process.stdin'] = true;
+    r.objects['process.hrtime'] = true;
+    r.objects['process.memoryUsage'] = true;
+    defineHelper(r, 'nodeProcess', ['fmt', 'math/big', 'os', 'runtime', 'strings', 'syscall', 'time'], ['error', 'orderedMap'], processHelper);
+    defineClass(r, 'process.MemoryUsage', '*TnMemoryUsage', 'class', '', 'rss=float64; heapTotal=float64; heapUsed=float64; external=float64; arrayBuffers=float64', '', '');
+    const use = () => r.helper('nodeProcess');
+    const value = (name, type, emit) => {
+        r.values[`process.${name}`] = (_c) => emit();
+        r.valueTypes[`process.${name}`] = type;
+    };
+    value('argv', '[]string', () => {
+        use();
+        return 'TnProcessArgv()';
+    });
+    value('execArgv', '[]string', () => '[]string{}');
+    value('argv0', 'string', () => {
+        r.pkg('os');
+        return 'os.Args[0]';
+    });
+    value('execPath', 'string', () => {
+        use();
+        return 'TnProcessExecPath()';
+    });
+    value('platform', 'string', () => {
+        r.helper('osPlatform');
+        return 'TnOsPlatform()';
+    });
+    value('arch', 'string', () => {
+        r.helper('nodeOs');
+        return 'TnOsArch()';
+    });
+    value('pid', 'float64', () => {
+        r.pkg('os');
+        return 'float64(os.Getpid())';
+    });
+    value('ppid', 'float64', () => {
+        r.pkg('os');
+        return 'float64(os.Getppid())';
+    });
+    value('version', 'string', () => '"v24.0.0"');
+    value('versions', '*TnMap[string, string]', () => {
+        use();
+        return 'TnProcessVersions()';
+    });
+    value('title', 'string', () => '"node"');
+    value('exitCode', 'float64', () => {
+        use();
+        return 'tnExitCode';
+    });
+    value('env', '*TnMap[string, string]', () => {
+        use();
+        return 'TnEnvMap()';
+    });
+    value('stdout.isTTY', 'bool', () => {
+        use();
+        return 'TnIsTTY(os.Stdout)';
+    });
+    value('stderr.isTTY', 'bool', () => {
+        use();
+        return 'TnIsTTY(os.Stderr)';
+    });
+    value('stdin.isTTY', 'bool', () => {
+        use();
+        return 'TnIsTTY(os.Stdin)';
+    });
+    value('stdout.fd', 'float64', () => 'float64(1)');
+    value('stderr.fd', 'float64', () => 'float64(2)');
+    value('stdin.fd', 'float64', () => 'float64(0)');
+    r.functions['process.exitCode='] = (call) => {
+        use();
+        return `TnSetExitCode(${call.args[0]})`;
+    };
+    const fn = (name, result, emit) => {
+        r.functions[`process.${name}`] = emit;
+        r.results[`process.${name}`] = result;
+    };
+    fn('exit', '', (call) => {
+        use();
+        return `TnProcessExitWith(${call.args.slice(0, 1).join(', ')})`;
+    });
+    fn('cwd', 'string', (_c) => {
+        r.pkg('os');
+        return 'func() string { __d, _ := os.Getwd(); return __d }()';
+    });
+    fn('chdir', '', (call) => {
+        use();
+        return `TnProcessChdir(${call.args[0]})`;
+    });
+    fn('hrtime', '[]float64', (call) => {
+        use();
+        return `TnProcessHrtime(${call.args.join(', ')})`;
+    });
+    fn('hrtime.bigint', '*tnbig.Int', (_c) => {
+        use();
+        return 'TnProcessHrtimeBigint()';
+    });
+    fn('uptime', 'float64', (_c) => {
+        use();
+        return 'TnProcessUptime()';
+    });
+    fn('memoryUsage', '*TnMemoryUsage', (_c) => {
+        use();
+        return 'TnProcessMemoryUsage()';
+    });
+    fn('memoryUsage.rss', 'float64', (_c) => {
+        use();
+        return 'TnProcessMemoryUsage().rss';
+    });
+    fn('stdout.write', 'bool', (call) => {
+        use();
+        return `TnProcessWrite(os.Stdout, ${call.args[0]})`;
+    });
+    fn('stderr.write', 'bool', (call) => {
+        use();
+        return `TnProcessWrite(os.Stderr, ${call.args[0]})`;
+    });
+    fn('nextTick', '', (call) => {
+        r.helper('timerWait');
+        const rest = call.args.slice(1).join(', ');
+        return `TnQueueMicrotask(func() { (${call.args[0]})(${rest}) })`;
+    });
+    fn('kill', 'bool', (call) => {
+        use();
+        return `TnProcessKill(${call.args.join(', ')})`;
+    });
+    fn('emitWarning', '', (call) => {
+        use();
+        return `TnProcessEmitWarning(${call.args[0]})`;
+    });
+    for (const id of ['getuid', 'getgid', 'geteuid', 'getegid']) {
+        const goName = id === 'getuid' ? 'Getuid' : id === 'getgid' ? 'Getgid' : id === 'geteuid' ? 'Geteuid' : 'Getegid';
+        fn(id, 'float64', (_c) => {
+            r.pkg('os');
+            return `float64(os.${goName}())`;
+        });
+    }
+    setResults(r, 'process', '');
+}

package/bin/node/punycode.js

@@ -0,0 +1,195 @@
+// node:punycode (deprecated upstream, still shipped): RFC 3492 encode / decode,
+// toASCII / toUnicode for domains. Also backs url.domainToASCII and IDN hosts.
+import { defineHelper, defineModule, setResults } from './registry.js';
+const punycodeHelper = `// Punycode (RFC 3492)
+const (
+	tnPunyBase        = 36
+	tnPunyTMin        = 1
+	tnPunyTMax        = 26
+	tnPunySkew        = 38
+	tnPunyDamp        = 700
+	tnPunyInitialBias = 72
+	tnPunyInitialN    = 128
+)
+
+func tnPunyAdapt(delta int, numPoints int, first bool) int {
+	if first {
+		delta /= tnPunyDamp
+	} else {
+		delta /= 2
+	}
+	delta += delta / numPoints
+	k := 0
+	for delta > ((tnPunyBase-tnPunyTMin)*tnPunyTMax)/2 {
+		delta /= tnPunyBase - tnPunyTMin
+		k += tnPunyBase
+	}
+	return k + (tnPunyBase-tnPunyTMin+1)*delta/(delta+tnPunySkew)
+}
+
+func tnPunyDigit(d int) byte {
+	if d < 26 {
+		return byte('a' + d)
+	}
+	return byte('0' + d - 26)
+}
+
+func TnPunycodeEncode(input string) string {
+	runes := []rune(input)
+	out := []byte{}
+	for _, r := range runes {
+		if r < 0x80 {
+			out = append(out, byte(r))
+		}
+	}
+	basic := len(out)
+	handled := basic
+	if basic > 0 {
+		out = append(out, '-')
+	}
+	n, delta, bias := tnPunyInitialN, 0, tnPunyInitialBias
+	for handled < len(runes) {
+		m := int(^uint(0) >> 1)
+		for _, r := range runes {
+			if int(r) >= n && int(r) < m {
+				m = int(r)
+			}
+		}
+		delta += (m - n) * (handled + 1)
+		n = m
+		for _, r := range runes {
+			if int(r) < n {
+				delta++
+			}
+			if int(r) == n {
+				q := delta
+				for k := tnPunyBase; ; k += tnPunyBase {
+					t := k - bias
+					if t < tnPunyTMin {
+						t = tnPunyTMin
+					} else if t > tnPunyTMax {
+						t = tnPunyTMax
+					}
+					if q < t {
+						break
+					}
+					out = append(out, tnPunyDigit(t+(q-t)%(tnPunyBase-t)))
+					q = (q - t) / (tnPunyBase - t)
+				}
+				out = append(out, tnPunyDigit(q))
+				bias = tnPunyAdapt(delta, handled+1, handled == basic)
+				delta = 0
+				handled++
+			}
+		}
+		delta++
+		n++
+	}
+	return string(out)
+}
+
+func TnPunycodeDecode(input string) string {
+	out := []rune{}
+	b := strings.LastIndex(input, "-")
+	if b > 0 {
+		for _, c := range input[:b] {
+			out = append(out, c)
+		}
+		b++
+	} else {
+		b = 0
+	}
+	n, i, bias := tnPunyInitialN, 0, tnPunyInitialBias
+	for pos := b; pos < len(input); {
+		oldi, w := i, 1
+		for k := tnPunyBase; ; k += tnPunyBase {
+			if pos >= len(input) {
+				panic(TnNodeError("RangeError", "", "Invalid input"))
+			}
+			c := input[pos]
+			pos++
+			digit := 0
+			switch {
+			case c >= '0' && c <= '9':
+				digit = int(c-'0') + 26
+			case c >= 'A' && c <= 'Z':
+				digit = int(c - 'A')
+			case c >= 'a' && c <= 'z':
+				digit = int(c - 'a')
+			default:
+				panic(TnNodeError("RangeError", "", "Invalid input"))
+			}
+			i += digit * w
+			t := k - bias
+			if t < tnPunyTMin {
+				t = tnPunyTMin
+			} else if t > tnPunyTMax {
+				t = tnPunyTMax
+			}
+			if digit < t {
+				break
+			}
+			w *= tnPunyBase - t
+		}
+		bias = tnPunyAdapt(i-oldi, len(out)+1, oldi == 0)
+		n += i / (len(out) + 1)
+		i %= len(out) + 1
+		out = append(out[:i], append([]rune{rune(n)}, out[i:]...)...)
+		i++
+	}
+	return string(out)
+}
+
+func tnIsASCII(s string) bool {
+	for i := 0; i < len(s); i++ {
+		if s[i] >= 0x80 {
+			return false
+		}
+	}
+	return true
+}
+
+func tnMapDomainLabels(domain string, fn func(string) string) string {
+	// Node also splits on the ideographic full stops
+	domain = strings.NewReplacer("\\u3002", ".", "\\uFF0E", ".", "\\uFF61", ".").Replace(domain)
+	labels := strings.Split(domain, ".")
+	for i, label := range labels {
+		labels[i] = fn(label)
+	}
+	return strings.Join(labels, ".")
+}
+
+func TnPunycodeToASCII(domain string) string {
+	return tnMapDomainLabels(domain, func(label string) string {
+		if tnIsASCII(label) {
+			return label
+		}
+		return "xn--" + TnPunycodeEncode(label)
+	})
+}
+
+func TnPunycodeToUnicode(domain string) string {
+	return tnMapDomainLabels(domain, func(label string) string {
+		if strings.HasPrefix(strings.ToLower(label), "xn--") {
+			return TnPunycodeDecode(strings.ToLower(label[4:]))
+		}
+		return label
+	})
+}`;
+export function registerPunycode(r) {
+    defineModule(r, 'punycode');
+    defineHelper(r, 'punycode', ['strings'], ['error'], punycodeHelper);
+    const fn = (name, goName) => {
+        r.functions[`punycode.${name}`] = (call) => {
+            r.helper('punycode');
+            return `${goName}(${call.args[0]})`;
+        };
+    };
+    fn('encode', 'TnPunycodeEncode');
+    fn('decode', 'TnPunycodeDecode');
+    fn('toASCII', 'TnPunycodeToASCII');
+    fn('toUnicode', 'TnPunycodeToUnicode');
+    setResults(r, 'punycode', 'encode=string; decode=string; toASCII=string; toUnicode=string');
+    r.values['punycode.version'] = (_c) => '"2.1.0"';
+    r.valueTypes['punycode.version'] = 'string';
+}

package/bin/node/querystring.js

@@ -0,0 +1,143 @@
+// node:querystring — parse / stringify / escape / unescape (decode / encode aliases)
+import { defineHelper, defineModule, setResults } from './registry.js';
+const querystringHelper = `// node:querystring
+func TnQueryUnescape(s string) string {
+	if decoded, err := tnurl.PathUnescape(s); err == nil {
+		return decoded
+	}
+	return tnFormDecode(strings.ReplaceAll(s, "+", "%2B"))
+}
+
+// parse(str, sep = "&", eq = "="): repeated keys collect into arrays
+func TnQueryParse(s string, seps ...string) *TnMap[string, interface{}] {
+	sep, eq := "&", "="
+	if len(seps) > 0 && seps[0] != "" {
+		sep = seps[0]
+	}
+	if len(seps) > 1 && seps[1] != "" {
+		eq = seps[1]
+	}
+	out := TnNewMap[string, interface{}]()
+	if s == "" {
+		return out
+	}
+	for _, part := range strings.Split(s, sep) {
+		if part == "" {
+			continue
+		}
+		key, value := part, ""
+		if i := strings.Index(part, eq); i >= 0 {
+			key, value = part[:i], part[i+len(eq):]
+		}
+		key = TnQueryUnescape(strings.ReplaceAll(key, "+", " "))
+		value = TnQueryUnescape(strings.ReplaceAll(value, "+", " "))
+		if existing, ok := out.Lookup(key); ok {
+			switch e := existing.(type) {
+			case []string:
+				out.Set(key, append(e, value))
+			case string:
+				out.Set(key, []string{e, value})
+			}
+			continue
+		}
+		out.Set(key, value)
+	}
+	return out
+}
+
+func tnQueryValue(v interface{}) string {
+	switch x := v.(type) {
+	case string:
+		return x
+	case float64:
+		if math.IsInf(x, 0) || math.IsNaN(x) {
+			return ""
+		}
+		return TnNumStr(x)
+	case bool:
+		if x {
+			return "true"
+		}
+		return "false"
+	case *tnbig.Int:
+		return x.String()
+	}
+	return ""
+}
+
+// stringify(obj, sep = "&", eq = "="): arrays repeat the key
+func TnQueryStringify(obj interface{}, seps ...string) string {
+	sep, eq := "&", "="
+	if len(seps) > 0 && seps[0] != "" {
+		sep = seps[0]
+	}
+	if len(seps) > 1 && seps[1] != "" {
+		eq = seps[1]
+	}
+	parts := []string{}
+	add := func(key string, value interface{}) {
+		k := TnEncodeURIComponent(key)
+		rv := reflect.ValueOf(value)
+		if value != nil && (rv.Kind() == reflect.Slice || (rv.Kind() == reflect.Pointer && !rv.IsNil() && rv.Elem().Kind() == reflect.Slice)) {
+			if rv.Kind() == reflect.Pointer {
+				rv = rv.Elem()
+			}
+			for i := 0; i < rv.Len(); i++ {
+				parts = append(parts, k+eq+TnEncodeURIComponent(tnQueryValue(rv.Index(i).Interface())))
+			}
+			return
+		}
+		parts = append(parts, k+eq+TnEncodeURIComponent(tnQueryValue(value)))
+	}
+	if withEntries, ok := obj.(interface{ Entries() [][]interface{} }); ok {
+		for _, e := range withEntries.Entries() {
+			add(fmt.Sprint(e[0]), e[1])
+		}
+	} else if m, ok := obj.(map[string]interface{}); ok {
+		keys := make([]string, 0, len(m))
+		for k := range m {
+			keys = append(keys, k)
+		}
+		sort.Strings(keys)
+		for _, k := range keys {
+			add(k, m[k])
+		}
+	} else {
+		rv := reflect.ValueOf(obj)
+		if rv.Kind() == reflect.Pointer && !rv.IsNil() && rv.Elem().Kind() == reflect.Struct {
+			sv := rv.Elem()
+			for i := 0; i < sv.NumField(); i++ {
+				f := sv.Field(i)
+				value := reflect.NewAt(f.Type(), unsafe.Pointer(f.UnsafeAddr())).Elem().Interface()
+				add(strings.TrimSuffix(sv.Type().Field(i).Name, "_"), value)
+			}
+		}
+	}
+	return strings.Join(parts, sep)
+}`;
+export function registerQuerystring(r) {
+    defineModule(r, 'querystring');
+    defineHelper(r, 'nodeQuerystring', ['fmt', 'math', 'math/big', 'net/url', 'reflect', 'sort', 'strings', 'unsafe'], ['nodeUrl', 'uri', 'orderedMap', 'dynamic'], querystringHelper);
+    const use = () => r.helper('nodeQuerystring');
+    for (const name of ['parse', 'decode']) {
+        r.functions[`querystring.${name}`] = (call) => {
+            use();
+            return `TnQueryParse(${call.args.slice(0, 3).join(', ')})`;
+        };
+    }
+    for (const name of ['stringify', 'encode']) {
+        r.functions[`querystring.${name}`] = (call) => {
+            use();
+            return `TnQueryStringify(${call.args.slice(0, 3).join(', ')})`;
+        };
+    }
+    r.functions['querystring.escape'] = (call) => {
+        r.helper('uri');
+        return `TnEncodeURIComponent(${call.args[0]})`;
+    };
+    r.functions['querystring.unescape'] = (call) => {
+        use();
+        return `TnQueryUnescape(${call.args[0]})`;
+    };
+    setResults(r, 'querystring', 'parse=*TnMap[string, interface{}]; decode=*TnMap[string, interface{}]; stringify=string; encode=string; escape=string; unescape=string');
+}