typenative 0.4.0 → 0.4.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (44) hide show
  1. package/.github/workflows/ci.yml +2 -0
  2. package/CHANGELOG.md +201 -0
  3. package/CONTRIBUTION.md +1 -1
  4. package/bin/cli.js +1 -0
  5. package/bin/go/bridge.js +74 -14
  6. package/bin/go/convert.js +48 -0
  7. package/bin/go/metadata.js +13 -4
  8. package/bin/go/overrides.js +4 -6
  9. package/bin/go/stdlib.generated.js +2 -0
  10. package/bin/index.js +117 -0
  11. package/bin/main.js +1 -0
  12. package/bin/node/child_process.js +51 -3
  13. package/bin/node/cluster.js +41 -3
  14. package/bin/node/core.js +1 -1
  15. package/bin/node/crypto.js +205 -4
  16. package/bin/node/dgram.js +230 -6
  17. package/bin/node/dns.js +470 -7
  18. package/bin/node/errno_tables.js +445 -0
  19. package/bin/node/fs.js +21 -14
  20. package/bin/node/http.js +128 -30
  21. package/bin/node/http2.js +4 -1
  22. package/bin/node/module_v8.js +142 -0
  23. package/bin/node/net.js +9 -6
  24. package/bin/node/process.js +242 -0
  25. package/bin/node/readline.js +271 -0
  26. package/bin/node/registry.js +2 -1
  27. package/bin/node/sqlite.js +60 -12
  28. package/bin/node/stream.js +139 -7
  29. package/bin/node/test.js +311 -19
  30. package/bin/node/url.js +23 -5
  31. package/bin/node/util.js +18 -1
  32. package/bin/node/util_extra.js +6 -30
  33. package/bin/node/worker_threads.js +79 -19
  34. package/bin/transpiler.js +4019 -497
  35. package/bin/typecheck-node.js +1 -0
  36. package/bin/version.js +1 -1
  37. package/conformance.md +1025 -884
  38. package/examples/README.md +5 -5
  39. package/examples/json-server/README.md +31 -29
  40. package/examples/json-server/bench.mjs +130 -38
  41. package/package.json +1 -1
  42. package/types/typenative-go.d.ts +23 -0
  43. package/types/typenative-npm.d.ts +169 -5
  44. package/types/typenative.d.ts +185 -11
package/bin/node/url.js CHANGED
@@ -18,7 +18,23 @@ type TnURL struct {
18
18
 
19
19
  var tnSpecialSchemes = map[string]string{"http:": "80", "https:": "443", "ws:": "80", "wss:": "443", "ftp:": "21", "file:": ""}
20
20
 
21
- var tnSchemePattern = regexp.MustCompile("^[A-Za-z][A-Za-z0-9+.-]*:")
21
+ // The leading "scheme:" of s (/^[A-Za-z][A-Za-z0-9+.-]*:/), "" when there is none
22
+ func tnURLScheme(s string) string {
23
+ for i := 0; i < len(s); i++ {
24
+ c := s[i]
25
+ switch {
26
+ case c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z':
27
+ case i > 0 && (c >= '0' && c <= '9' || c == '+' || c == '.' || c == '-'):
28
+ case i > 0 && c == ':':
29
+ return s[:i+1]
30
+ default:
31
+ return ""
32
+ }
33
+ }
34
+ return ""
35
+ }
36
+
37
+ var tnURLStrip = strings.NewReplacer("\\t", "", "\\n", "", "\\r", "")
22
38
 
23
39
  func tnInvalidURL(input string) *TnError {
24
40
  e := TnNodeError("TypeError", "ERR_INVALID_URL", "Invalid URL")
@@ -213,7 +229,9 @@ func tnCopyURL(b *TnURL) *TnURL {
213
229
 
214
230
  func tnParseURLString(input string, base *TnURL) (*TnURL, bool) {
215
231
  input = strings.TrimFunc(input, func(r rune) bool { return r <= 0x20 })
216
- input = strings.NewReplacer("\\t", "", "\\n", "", "\\r", "").Replace(input)
232
+ if strings.ContainsAny(input, "\\t\\n\\r") {
233
+ input = tnURLStrip.Replace(input)
234
+ }
217
235
  fragment, hasFragment := "", false
218
236
  if i := strings.Index(input, "#"); i >= 0 {
219
237
  fragment, hasFragment = input[i+1:], true
@@ -225,7 +243,7 @@ func tnParseURLString(input string, base *TnURL) (*TnURL, bool) {
225
243
  input = input[:i]
226
244
  }
227
245
  u := &TnURL{}
228
- if scheme := tnSchemePattern.FindString(input); scheme != "" {
246
+ if scheme := tnURLScheme(input); scheme != "" {
229
247
  u.protocol = strings.ToLower(scheme)
230
248
  rest := input[len(scheme):]
231
249
  if u.special() {
@@ -451,7 +469,7 @@ func (u *TnURL) Set_href(v string) {
451
469
 
452
470
  func (u *TnURL) Set_protocol(v string) {
453
471
  v = strings.ToLower(strings.TrimSuffix(v, ":")) + ":"
454
- if !tnSchemePattern.MatchString(v) {
472
+ if tnURLScheme(v) == "" {
455
473
  return
456
474
  }
457
475
  _, toSpecial := tnSpecialSchemes[v]
@@ -809,7 +827,7 @@ func TnDomainToUnicode(domain string) string {
809
827
  }`;
810
828
  export function registerUrl(r) {
811
829
  defineModule(r, 'url');
812
- defineHelper(r, 'nodeUrl', ['encoding/hex', 'fmt', 'net/url', 'path/filepath', 'reflect', 'regexp', 'runtime', 'sort', 'strconv', 'strings', 'unicode/utf16', 'unsafe'], ['error', 'dynamic', 'punycode', 'pathToFileURL', 'nodeInvoke'], urlHelper);
830
+ defineHelper(r, 'nodeUrl', ['encoding/hex', 'fmt', 'net/url', 'path/filepath', 'reflect', 'runtime', 'sort', 'strconv', 'strings', 'unicode/utf16', 'unsafe'], ['error', 'dynamic', 'punycode', 'pathToFileURL', 'nodeInvoke'], urlHelper);
813
831
  defineClass(r, 'url.URL', '*TnURL', 'class', 'toString=string; toJSON=string', '', 'href=string; protocol=string; username=string; password=string; host=string; hostname=string; port=string; pathname=string; search=string; hash=string; origin=string; searchParams=*TnURLSearchParams', 'href; protocol; username; password; host; hostname; port; pathname; search; hash');
814
832
  defineClass(r, 'url.URLSearchParams', '*TnURLSearchParams', 'class', 'append=; set=; delete=; get=*string; getAll=[]string; has=bool; sort=; toString=string; keys=[]string; values=[]string; entries=[][]string; forEach=', '', 'size=float64', '');
815
833
  r.iterators['*TnURLSearchParams'] = 'entries';
package/bin/node/util.js CHANGED
@@ -196,6 +196,9 @@ func (ins *tnInspector) format(v interface{}, depth int) string {
196
196
  name, values := x.TnTypedInspect()
197
197
  return name + " " + ins.format(values, depth)
198
198
  case time.Time:
199
+ if x.IsZero() {
200
+ return "Invalid Date"
201
+ }
199
202
  return x.UTC().Format("2006-01-02T15:04:05.000Z07:00")
200
203
  case *regexp.Regexp:
201
204
  if x == nil {
@@ -327,8 +330,16 @@ func (ins *tnInspector) formatCompound(v interface{}, rv reflect.Value, depth in
327
330
  isTop := depth == 0
328
331
  if withEntries, ok := v.(interface{ Entries() [][]interface{} }); ok {
329
332
  entries = withEntries.Entries()
330
- if tnInspectSetLike(rv) {
333
+ // new Map() / new Set() are tagged; untagged maps are records unless a
334
+ // key is not a string
335
+ jsKind := uint8(0)
336
+ if tagged, ok := v.(interface{ TnJSKind() uint8 }); ok {
337
+ jsKind = tagged.TnJSKind()
338
+ }
339
+ if jsKind == 2 || (jsKind == 0 && tnInspectSetLike(rv)) {
331
340
  kind = "set"
341
+ } else if jsKind == 1 {
342
+ kind = "map"
332
343
  } else {
333
344
  kind = "map"
334
345
  stringKeys := true
@@ -762,6 +773,12 @@ func TnUtilFormat(args ...interface{}) string {
762
773
  } else {
763
774
  args[i] = *p
764
775
  }
776
+ case string:
777
+ default:
778
+ // String enum members (type E string) print as strings
779
+ if rv := reflect.ValueOf(a); rv.Kind() == reflect.String {
780
+ args[i] = rv.String()
781
+ }
765
782
  }
766
783
  }
767
784
  first, isString := args[0].(string)
@@ -253,31 +253,13 @@ func tnArgEntries(v interface{}) [][2]interface{} {
253
253
 
254
254
  // --- system errors ---
255
255
 
256
- var tnSystemErrors = map[string]syscall.Errno{
257
- "E2BIG": syscall.E2BIG, "EACCES": syscall.EACCES, "EADDRINUSE": syscall.EADDRINUSE, "EADDRNOTAVAIL": syscall.EADDRNOTAVAIL,
258
- "EAFNOSUPPORT": syscall.EAFNOSUPPORT, "EAGAIN": syscall.EAGAIN, "EALREADY": syscall.EALREADY, "EBADF": syscall.EBADF,
259
- "EBUSY": syscall.EBUSY, "ECANCELED": syscall.ECANCELED, "ECONNABORTED": syscall.ECONNABORTED, "ECONNREFUSED": syscall.ECONNREFUSED,
260
- "ECONNRESET": syscall.ECONNRESET, "EDESTADDRREQ": syscall.EDESTADDRREQ, "EEXIST": syscall.EEXIST, "EFAULT": syscall.EFAULT,
261
- "EFBIG": syscall.EFBIG, "EHOSTUNREACH": syscall.EHOSTUNREACH, "EINTR": syscall.EINTR, "EINVAL": syscall.EINVAL,
262
- "EIO": syscall.EIO, "EISCONN": syscall.EISCONN, "EISDIR": syscall.EISDIR, "ELOOP": syscall.ELOOP, "EMFILE": syscall.EMFILE,
263
- "EMLINK": syscall.EMLINK, "EMSGSIZE": syscall.EMSGSIZE, "ENAMETOOLONG": syscall.ENAMETOOLONG, "ENETDOWN": syscall.ENETDOWN,
264
- "ENETUNREACH": syscall.ENETUNREACH, "ENFILE": syscall.ENFILE, "ENOBUFS": syscall.ENOBUFS, "ENODEV": syscall.ENODEV,
265
- "ENOENT": syscall.ENOENT, "ENOMEM": syscall.ENOMEM, "ENOSPC": syscall.ENOSPC, "ENOSYS": syscall.ENOSYS,
266
- "ENOTCONN": syscall.ENOTCONN, "ENOTDIR": syscall.ENOTDIR, "ENOTEMPTY": syscall.ENOTEMPTY, "ENOTSOCK": syscall.ENOTSOCK,
267
- "ENOTSUP": syscall.ENOTSUP, "ENXIO": syscall.ENXIO, "EPERM": syscall.EPERM, "EPIPE": syscall.EPIPE,
268
- "EPROTO": syscall.EPROTO, "EPROTONOSUPPORT": syscall.EPROTONOSUPPORT, "EPROTOTYPE": syscall.EPROTOTYPE,
269
- "ERANGE": syscall.ERANGE, "EROFS": syscall.EROFS, "ESPIPE": syscall.ESPIPE, "ESRCH": syscall.ESRCH,
270
- "ETIMEDOUT": syscall.ETIMEDOUT, "ETXTBSY": syscall.ETXTBSY, "EXDEV": syscall.EXDEV,
271
- }
272
-
273
256
  func tnSystemErrorEntry(errno float64) (string, string, bool) {
274
257
  if errno >= 0 || errno != float64(int64(errno)) {
275
258
  panic(TnNodeError("RangeError", "ERR_OUT_OF_RANGE", "The value of \\"err\\" is out of range. It must be a negative integer. Received "+TnNumStr(errno)))
276
259
  }
277
- target := syscall.Errno(int64(-errno))
278
- for name, e := range tnSystemErrors {
279
- if e == target {
280
- return name, e.Error(), true
260
+ for _, e := range tnUvErrorList {
261
+ if tnUvErrnos[e[0]] == errno {
262
+ return e[0], e[1], true
281
263
  }
282
264
  }
283
265
  return "", "", false
@@ -301,14 +283,8 @@ func TnGetSystemErrorMessage(errno float64) string {
301
283
 
302
284
  func TnGetSystemErrorMap() *TnMap[float64, []string] {
303
285
  m := TnNewMap[float64, []string]()
304
- names := make([]string, 0, len(tnSystemErrors))
305
- for name := range tnSystemErrors {
306
- names = append(names, name)
307
- }
308
- sort.Slice(names, func(i, j int) bool { return tnSystemErrors[names[i]] < tnSystemErrors[names[j]] })
309
- for _, name := range names {
310
- e := tnSystemErrors[name]
311
- m.Set(-float64(e), []string{name, e.Error()})
286
+ for _, e := range tnUvErrorList {
287
+ m.Set(tnUvErrnos[e[0]], []string{e[0], e[1]})
312
288
  }
313
289
  return m
314
290
  }
@@ -560,7 +536,7 @@ func TnDebuglogEnabled(section string) bool { return tnDebugEnabled(section) }
560
536
  // toUSVString: invalid sequences become U+FFFD
561
537
  func TnToUSVString(s string) string { return strings.ToValidUTF8(s, "\uFFFD") }`;
562
538
  export function registerUtilExtra(r) {
563
- defineHelper(r, 'nodeUtilExtra', ['fmt', 'os', 'reflect', 'regexp', 'sort', 'strconv', 'strings', 'syscall', 'unsafe'], ['nodeUtil', 'dynamic', 'orderedMap', 'error', 'eventLoop', 'nodeEvents', 'fsErrors'], utilExtraHelper);
539
+ defineHelper(r, 'nodeUtilExtra', ['fmt', 'os', 'reflect', 'regexp', 'sort', 'strconv', 'strings', 'unsafe'], ['nodeUtil', 'dynamic', 'orderedMap', 'error', 'eventLoop', 'nodeEvents', 'fsErrors', 'uvErrno'], utilExtraHelper);
564
540
  const use = () => r.helper('nodeUtilExtra');
565
541
  const fn = (key, result, emit) => {
566
542
  r.functions[key] = (c) => {
@@ -6,8 +6,17 @@
6
6
  // workerData are set. MessageChannel / MessagePort / BroadcastChannel work
7
7
  // within one process. The worker's stdout / stderr are the parent's; an
8
8
  // uncaught exception in a worker becomes an 'error' event and exit code 1.
9
- import { defineClass, defineHelper, defineModule, setResults, isStringNode } from './registry.js';
9
+ import { defineClass, defineHelper, defineModule, setResults } from './registry.js';
10
10
  const cloneHelper = `// Structured clone (subset): values to and from JSON with type tags
11
+ // Objects keep their key order: {"$tn": "Object", "k": keys, "v": values}
12
+ func tnCloneObject(keys []string, values []interface{}) map[string]interface{} {
13
+ k := make([]interface{}, len(keys))
14
+ for i, key := range keys {
15
+ k[i] = key
16
+ }
17
+ return map[string]interface{}{"$tn": "Object", "k": k, "v": values}
18
+ }
19
+
11
20
  func tnCloneEncode(v interface{}) interface{} {
12
21
  switch x := v.(type) {
13
22
  case nil:
@@ -44,11 +53,16 @@ func tnCloneEncode(v interface{}) interface{} {
44
53
  }
45
54
  return map[string]interface{}{"$tn": "Error", "message": x.message, "code": x.code, "props": props}
46
55
  case map[string]interface{}:
47
- out := map[string]interface{}{}
48
- for k, val := range x {
49
- out[k] = tnCloneEncode(val)
56
+ keys := make([]string, 0, len(x))
57
+ for k := range x {
58
+ keys = append(keys, k)
50
59
  }
51
- return out
60
+ sort.Strings(keys)
61
+ values := make([]interface{}, len(keys))
62
+ for i, k := range keys {
63
+ values[i] = tnCloneEncode(x[k])
64
+ }
65
+ return tnCloneObject(keys, values)
52
66
  case []interface{}:
53
67
  out := make([]interface{}, len(x))
54
68
  for i, val := range x {
@@ -57,7 +71,30 @@ func tnCloneEncode(v interface{}) interface{} {
57
71
  return out
58
72
  }
59
73
  if withEntries, ok := v.(interface{ Entries() [][]interface{} }); ok {
60
- if _, isSet := v.(interface{ IsSet() bool }); isSet {
74
+ kind := uint8(0)
75
+ if tagged, ok := v.(interface{ TnJSKind() uint8 }); ok {
76
+ kind = tagged.TnJSKind()
77
+ }
78
+ // a record (string keys, not made by new Map()) is a plain object
79
+ if kind == 0 {
80
+ entries := withEntries.Entries()
81
+ keys := make([]string, 0, len(entries))
82
+ values := make([]interface{}, 0, len(entries))
83
+ plain := true
84
+ for _, e := range entries {
85
+ k, isString := e[0].(string)
86
+ if !isString {
87
+ plain = false
88
+ break
89
+ }
90
+ keys = append(keys, k)
91
+ values = append(values, tnCloneEncode(e[1]))
92
+ }
93
+ if plain {
94
+ return tnCloneObject(keys, values)
95
+ }
96
+ }
97
+ if kind == 2 {
61
98
  values := []interface{}{}
62
99
  for _, e := range withEntries.Entries() {
63
100
  values = append(values, tnCloneEncode(e[0]))
@@ -92,16 +129,18 @@ func tnCloneEncode(v interface{}) interface{} {
92
129
  }
93
130
  if rv.Elem().Kind() == reflect.Struct {
94
131
  sv := rv.Elem()
95
- out := map[string]interface{}{}
132
+ keys := []string{}
133
+ values := []interface{}{}
96
134
  for i := 0; i < sv.NumField(); i++ {
97
135
  f := sv.Field(i)
98
136
  if f.Kind() == reflect.Func {
99
137
  continue
100
138
  }
101
139
  value := reflect.NewAt(f.Type(), unsafe.Pointer(f.UnsafeAddr())).Elem().Interface()
102
- out[strings.TrimSuffix(sv.Type().Field(i).Name, "_")] = tnCloneEncode(value)
140
+ keys = append(keys, strings.TrimSuffix(sv.Type().Field(i).Name, "_"))
141
+ values = append(values, tnCloneEncode(value))
103
142
  }
104
- return out
143
+ return tnCloneObject(keys, values)
105
144
  }
106
145
  return tnCloneEncode(rv.Elem().Interface())
107
146
  case reflect.Float32, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
@@ -141,7 +180,7 @@ func tnCloneDecode(v interface{}) interface{} {
141
180
  }
142
181
  return e
143
182
  case "Map":
144
- m := TnNewMap[interface{}, interface{}]()
183
+ m := TnJSCollection(TnNewMap[interface{}, interface{}](), 1)
145
184
  if pairs, ok := x["v"].([]interface{}); ok {
146
185
  for _, p := range pairs {
147
186
  if pair, ok := p.([]interface{}); ok && len(pair) == 2 {
@@ -150,8 +189,19 @@ func tnCloneDecode(v interface{}) interface{} {
150
189
  }
151
190
  }
152
191
  return m
192
+ case "Object":
193
+ // an ordered record, as plain objects print and stringify in order
194
+ m := TnNewMap[string, interface{}]()
195
+ keys, _ := x["k"].([]interface{})
196
+ values, _ := x["v"].([]interface{})
197
+ for i, k := range keys {
198
+ if i < len(values) {
199
+ m.Set(TnJSString(k), tnCloneDecode(values[i]))
200
+ }
201
+ }
202
+ return m
153
203
  case "Set":
154
- m := TnNewMap[interface{}, interface{}]()
204
+ m := TnJSCollection(TnNewMap[interface{}, interface{}](), 2)
155
205
  if values, ok := x["v"].([]interface{}); ok {
156
206
  for _, val := range values {
157
207
  d := tnCloneDecode(val)
@@ -410,8 +460,10 @@ func init() {
410
460
  var setup map[string]interface{}
411
461
  json.Unmarshal(payload, &setup)
412
462
  TnWorkerData = tnCloneDecode(setup["workerData"])
413
- if env, ok := tnCloneDecode(setup["environmentData"]).(map[string]interface{}); ok {
414
- tnEnvironmentData = env
463
+ if env, ok := tnCloneDecode(setup["environmentData"]).(*TnMap[string, interface{}]); ok {
464
+ for _, k := range env.Keys() {
465
+ tnEnvironmentData[k] = env.Get(k)
466
+ }
415
467
  }
416
468
  TnThreadID, _ = setup["threadId"].(float64)
417
469
  port := tnNewPort()
@@ -463,6 +515,13 @@ type TnWorker struct {
463
515
 
464
516
  func (w *TnWorker) Get_threadId() float64 { return w.threadId }
465
517
 
518
+ // new Worker('./w.ts'): runs the entry point compiled from that file
519
+ func TnNewWorkerAt(entry string, filename interface{}, options ...interface{}) *TnWorker {
520
+ tnNextEntry = entry
521
+ defer func() { tnNextEntry = "" }()
522
+ return TnNewWorker(filename, options...)
523
+ }
524
+
466
525
  func TnNewWorker(filename interface{}, options ...interface{}) *TnWorker {
467
526
  tnNextThreadID++
468
527
  w := &TnWorker{threadId: tnNextThreadID}
@@ -505,6 +564,7 @@ func TnNewWorker(filename interface{}, options ...interface{}) *TnWorker {
505
564
  }
506
565
  }
507
566
  }
567
+ env = tnSpawnEntryEnv(env)
508
568
  env = append(env, "TN_WORKER_ADDR="+ln.Addr().String(), "TN_WORKER_TOKEN="+token)
509
569
  setup, err := json.Marshal(map[string]interface{}{
510
570
  "workerData": tnCloneEncode(workerData),
@@ -658,8 +718,8 @@ func (w *TnWorker) unref() *TnWorker {
658
718
  const EMITTER = 'on=*TnEventEmitter; once=*TnEventEmitter; addListener=*TnEventEmitter; off=*TnEventEmitter; removeListener=*TnEventEmitter; removeAllListeners=*TnEventEmitter; emit=bool; listenerCount=float64';
659
719
  export function registerWorkerThreads(r) {
660
720
  defineModule(r, 'worker_threads');
661
- defineHelper(r, 'nodeClone', ['encoding/base64', 'encoding/json', 'fmt', 'math/big', 'reflect', 'strings', 'time', 'unsafe'], ['dynamic', 'orderedMap', 'error'], cloneHelper);
662
- defineHelper(r, 'nodeWorker', ['bufio', 'crypto/rand', 'encoding/hex', 'encoding/json', 'fmt', 'net', 'os', 'os/exec', 'reflect', 'strings', 'sync', 'time'], ['nodeClone', 'nodeIpc', 'nodeEvents', 'eventLoop', 'nodeInvoke', 'dynamic', 'nodeChild'], workerHelper);
721
+ defineHelper(r, 'nodeClone', ['encoding/base64', 'encoding/json', 'fmt', 'math/big', 'reflect', 'sort', 'strings', 'time', 'unsafe'], ['dynamic', 'orderedMap', 'error'], cloneHelper);
722
+ defineHelper(r, 'nodeWorker', ['bufio', 'crypto/rand', 'encoding/hex', 'encoding/json', 'fmt', 'net', 'os', 'os/exec', 'reflect', 'strings', 'sync', 'time'], ['nodeClone', 'nodeIpc', 'nodeEvents', 'eventLoop', 'nodeInvoke', 'dynamic', 'nodeChild', 'entryPoints'], workerHelper);
663
723
  const use = () => r.helper('nodeWorker');
664
724
  defineClass(r, 'worker_threads.Worker', '*TnWorker', 'class', `${EMITTER}; postMessage=; terminate=chan float64; ref=*TnWorker; unref=*TnWorker`, '', 'threadId=float64', '');
665
725
  defineClass(r, 'worker_threads.MessagePort', '*TnMessagePort', 'class', `${EMITTER}; postMessage=; start=; close=; ref=*TnMessagePort; unref=*TnMessagePort; hasRef=bool`, '', 'onmessage=interface{}', 'onmessage');
@@ -686,10 +746,10 @@ export function registerWorkerThreads(r) {
686
746
  r.paramTypers['worker_threads.BroadcastChannel#addEventListener'] = (_n) => ['*TnMessageEvent'];
687
747
  r.constructors['worker_threads.Worker'] = (c) => {
688
748
  use();
689
- // The worker runs this program again: other files can't be loaded at runtime
690
- if (isStringNode(c.nodes[0]) && /\.(m?[jt]s|tsx?)$/.test(String(c.nodes[0].text))) {
691
- console.warn(`[TypeNative] new Worker('${c.nodes[0].text}') runs the current program; use new Worker(__filename) / new URL(import.meta.url) and branch on isMainThread`);
692
- }
749
+ // new Worker('./w.ts'): that file is compiled in as a second entry point
750
+ const entry = r.entryPoint(c.nodes[0]);
751
+ if (entry !== '')
752
+ return `TnNewWorkerAt(${JSON.stringify(entry)}, ${c.args.join(', ')})`;
693
753
  return `TnNewWorker(${c.args.join(', ')})`;
694
754
  };
695
755
  r.constructors['worker_threads.MessageChannel'] = (_c) => {