typenative 0.3.1 → 0.4.0

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 (147) hide show
  1. package/CHANGELOG.md +57 -0
  2. package/README.md +17 -1
  3. package/bin/cli.js +25 -11
  4. package/bin/go/convert.js +11 -1
  5. package/bin/index.js +221 -47
  6. package/bin/main.js +35 -14
  7. package/bin/node/assert.js +2 -2
  8. package/bin/node/buffer.js +9 -0
  9. package/bin/node/dns.js +1 -1
  10. package/bin/node/events.js +1 -1
  11. package/bin/node/fs.js +1 -1
  12. package/bin/node/fs_watch.js +407 -0
  13. package/bin/node/http2.js +33 -6
  14. package/bin/node/readline.js +1 -1
  15. package/bin/node/registry.js +2 -1
  16. package/bin/node/stream.js +6 -3
  17. package/bin/node/timers.js +1 -1
  18. package/bin/node/typed_arrays.js +608 -0
  19. package/bin/node/util.js +3 -0
  20. package/bin/node/zlib.js +131 -16
  21. package/bin/transpiler.js +635 -44
  22. package/bin/version.js +1 -1
  23. package/conformance.md +16 -4
  24. package/examples/README.md +54 -0
  25. package/examples/fibonacci/README.md +89 -0
  26. package/examples/fibonacci/bench.mjs +87 -0
  27. package/examples/fibonacci/main.ts +21 -0
  28. package/examples/hello-world/README.md +62 -0
  29. package/examples/hello-world/bench.mjs +66 -0
  30. package/examples/hello-world/main.ts +7 -0
  31. package/examples/json-server/README.md +125 -0
  32. package/examples/json-server/bench.mjs +171 -0
  33. package/examples/json-server/main.ts +67 -0
  34. package/govendor/github.com/andybalholm/brotli/LICENSE +19 -0
  35. package/govendor/github.com/andybalholm/brotli/README.md +19 -0
  36. package/govendor/github.com/andybalholm/brotli/backward_references.go +185 -0
  37. package/govendor/github.com/andybalholm/brotli/backward_references_hq.go +796 -0
  38. package/govendor/github.com/andybalholm/brotli/bit_cost.go +436 -0
  39. package/govendor/github.com/andybalholm/brotli/bit_reader.go +266 -0
  40. package/govendor/github.com/andybalholm/brotli/bitwriter.go +56 -0
  41. package/govendor/github.com/andybalholm/brotli/block_splitter.go +144 -0
  42. package/govendor/github.com/andybalholm/brotli/block_splitter_command.go +434 -0
  43. package/govendor/github.com/andybalholm/brotli/block_splitter_distance.go +433 -0
  44. package/govendor/github.com/andybalholm/brotli/block_splitter_literal.go +433 -0
  45. package/govendor/github.com/andybalholm/brotli/brotli_bit_stream.go +1435 -0
  46. package/govendor/github.com/andybalholm/brotli/cluster.go +30 -0
  47. package/govendor/github.com/andybalholm/brotli/cluster_command.go +164 -0
  48. package/govendor/github.com/andybalholm/brotli/cluster_distance.go +326 -0
  49. package/govendor/github.com/andybalholm/brotli/cluster_literal.go +326 -0
  50. package/govendor/github.com/andybalholm/brotli/command.go +254 -0
  51. package/govendor/github.com/andybalholm/brotli/compress_fragment.go +834 -0
  52. package/govendor/github.com/andybalholm/brotli/compress_fragment_two_pass.go +775 -0
  53. package/govendor/github.com/andybalholm/brotli/constants.go +77 -0
  54. package/govendor/github.com/andybalholm/brotli/context.go +2176 -0
  55. package/govendor/github.com/andybalholm/brotli/decode.go +2570 -0
  56. package/govendor/github.com/andybalholm/brotli/dictionary.go +122890 -0
  57. package/govendor/github.com/andybalholm/brotli/dictionary_hash.go +32779 -0
  58. package/govendor/github.com/andybalholm/brotli/encode.go +1220 -0
  59. package/govendor/github.com/andybalholm/brotli/encoder.go +177 -0
  60. package/govendor/github.com/andybalholm/brotli/encoder_dict.go +22 -0
  61. package/govendor/github.com/andybalholm/brotli/encoder_fast.go +201 -0
  62. package/govendor/github.com/andybalholm/brotli/entropy_encode.go +592 -0
  63. package/govendor/github.com/andybalholm/brotli/entropy_encode_static.go +4399 -0
  64. package/govendor/github.com/andybalholm/brotli/fast_log.go +290 -0
  65. package/govendor/github.com/andybalholm/brotli/find_match_length.go +45 -0
  66. package/govendor/github.com/andybalholm/brotli/go.mod +3 -0
  67. package/govendor/github.com/andybalholm/brotli/h10.go +287 -0
  68. package/govendor/github.com/andybalholm/brotli/h5.go +214 -0
  69. package/govendor/github.com/andybalholm/brotli/h6.go +216 -0
  70. package/govendor/github.com/andybalholm/brotli/hash.go +342 -0
  71. package/govendor/github.com/andybalholm/brotli/hash_composite.go +93 -0
  72. package/govendor/github.com/andybalholm/brotli/hash_forgetful_chain.go +252 -0
  73. package/govendor/github.com/andybalholm/brotli/hash_longest_match_quickly.go +214 -0
  74. package/govendor/github.com/andybalholm/brotli/hash_rolling.go +168 -0
  75. package/govendor/github.com/andybalholm/brotli/histogram.go +226 -0
  76. package/govendor/github.com/andybalholm/brotli/http.go +201 -0
  77. package/govendor/github.com/andybalholm/brotli/huffman.go +653 -0
  78. package/govendor/github.com/andybalholm/brotli/literal_cost.go +182 -0
  79. package/govendor/github.com/andybalholm/brotli/matchfinder/bargain1.go +212 -0
  80. package/govendor/github.com/andybalholm/brotli/matchfinder/bargain2.go +248 -0
  81. package/govendor/github.com/andybalholm/brotli/matchfinder/bargain3.go +278 -0
  82. package/govendor/github.com/andybalholm/brotli/matchfinder/emitter.go +34 -0
  83. package/govendor/github.com/andybalholm/brotli/matchfinder/m0.go +175 -0
  84. package/govendor/github.com/andybalholm/brotli/matchfinder/m4.go +339 -0
  85. package/govendor/github.com/andybalholm/brotli/matchfinder/matchfinder.go +103 -0
  86. package/govendor/github.com/andybalholm/brotli/matchfinder/pathfinder.go +328 -0
  87. package/govendor/github.com/andybalholm/brotli/matchfinder/textencoder.go +53 -0
  88. package/govendor/github.com/andybalholm/brotli/matchfinder/trio.go +327 -0
  89. package/govendor/github.com/andybalholm/brotli/matchfinder/zdfast.go +258 -0
  90. package/govendor/github.com/andybalholm/brotli/matchfinder/zfast.go +206 -0
  91. package/govendor/github.com/andybalholm/brotli/matchfinder/zm.go +302 -0
  92. package/govendor/github.com/andybalholm/brotli/memory.go +66 -0
  93. package/govendor/github.com/andybalholm/brotli/metablock.go +574 -0
  94. package/govendor/github.com/andybalholm/brotli/metablock_command.go +165 -0
  95. package/govendor/github.com/andybalholm/brotli/metablock_distance.go +165 -0
  96. package/govendor/github.com/andybalholm/brotli/metablock_literal.go +165 -0
  97. package/govendor/github.com/andybalholm/brotli/params.go +37 -0
  98. package/govendor/github.com/andybalholm/brotli/platform.go +103 -0
  99. package/govendor/github.com/andybalholm/brotli/prefix.go +30 -0
  100. package/govendor/github.com/andybalholm/brotli/prefix_dec.go +723 -0
  101. package/govendor/github.com/andybalholm/brotli/quality.go +196 -0
  102. package/govendor/github.com/andybalholm/brotli/reader.go +127 -0
  103. package/govendor/github.com/andybalholm/brotli/ringbuffer.go +134 -0
  104. package/govendor/github.com/andybalholm/brotli/state.go +313 -0
  105. package/govendor/github.com/andybalholm/brotli/static_dict.go +662 -0
  106. package/govendor/github.com/andybalholm/brotli/static_dict_lut.go +75094 -0
  107. package/govendor/github.com/andybalholm/brotli/symbol_list.go +22 -0
  108. package/govendor/github.com/andybalholm/brotli/transform.go +641 -0
  109. package/govendor/github.com/andybalholm/brotli/utf8_util.go +70 -0
  110. package/govendor/github.com/andybalholm/brotli/util.go +7 -0
  111. package/govendor/github.com/andybalholm/brotli/write_bits.go +52 -0
  112. package/govendor/github.com/andybalholm/brotli/writer.go +162 -0
  113. package/govendor/github.com/fsnotify/fsnotify/.mailmap +2 -0
  114. package/govendor/github.com/fsnotify/fsnotify/CHANGELOG.md +651 -0
  115. package/govendor/github.com/fsnotify/fsnotify/CONTRIBUTING.md +147 -0
  116. package/govendor/github.com/fsnotify/fsnotify/LICENSE +25 -0
  117. package/govendor/github.com/fsnotify/fsnotify/README.md +214 -0
  118. package/govendor/github.com/fsnotify/fsnotify/backend_fen.go +469 -0
  119. package/govendor/github.com/fsnotify/fsnotify/backend_inotify.go +597 -0
  120. package/govendor/github.com/fsnotify/fsnotify/backend_kqueue.go +735 -0
  121. package/govendor/github.com/fsnotify/fsnotify/backend_other.go +22 -0
  122. package/govendor/github.com/fsnotify/fsnotify/backend_windows.go +702 -0
  123. package/govendor/github.com/fsnotify/fsnotify/fsnotify.go +526 -0
  124. package/govendor/github.com/fsnotify/fsnotify/go.mod +3 -0
  125. package/govendor/github.com/fsnotify/fsnotify/internal/darwin.go +20 -0
  126. package/govendor/github.com/fsnotify/fsnotify/internal/debug_darwin.go +15 -0
  127. package/govendor/github.com/fsnotify/fsnotify/internal/debug_dragonfly.go +15 -0
  128. package/govendor/github.com/fsnotify/fsnotify/internal/debug_freebsd.go +20 -0
  129. package/govendor/github.com/fsnotify/fsnotify/internal/debug_kqueue.go +32 -0
  130. package/govendor/github.com/fsnotify/fsnotify/internal/debug_linux.go +56 -0
  131. package/govendor/github.com/fsnotify/fsnotify/internal/debug_netbsd.go +15 -0
  132. package/govendor/github.com/fsnotify/fsnotify/internal/debug_openbsd.go +16 -0
  133. package/govendor/github.com/fsnotify/fsnotify/internal/debug_solaris.go +45 -0
  134. package/govendor/github.com/fsnotify/fsnotify/internal/debug_windows.go +40 -0
  135. package/govendor/github.com/fsnotify/fsnotify/internal/freebsd.go +20 -0
  136. package/govendor/github.com/fsnotify/fsnotify/internal/internal.go +2 -0
  137. package/govendor/github.com/fsnotify/fsnotify/internal/unix.go +20 -0
  138. package/govendor/github.com/fsnotify/fsnotify/internal/unix2.go +25 -0
  139. package/govendor/github.com/fsnotify/fsnotify/internal/windows.go +40 -0
  140. package/govendor/github.com/fsnotify/fsnotify/shared.go +64 -0
  141. package/govendor/github.com/fsnotify/fsnotify/staticcheck.conf +3 -0
  142. package/govendor/github.com/fsnotify/fsnotify/system_bsd.go +7 -0
  143. package/govendor/github.com/fsnotify/fsnotify/system_darwin.go +8 -0
  144. package/govendor/manifest.txt +3 -1
  145. package/package.json +1 -1
  146. package/types/typenative-npm.d.ts +72 -0
  147. package/types/typenative.d.ts +117 -1
@@ -0,0 +1,608 @@
1
+ // Typed arrays other than Uint8Array (which is Go []byte, shared with Buffer),
2
+ // DataView and ArrayBuffer.
3
+ //
4
+ // Int8Array … Float64Array are one generic Go type, TnTypedArray[T], over a
5
+ // slice of the element type (TnInt32Array = TnTypedArray[int32], …). A view
6
+ // built on an ArrayBuffer (a Go []byte) shares its memory in the platform's
7
+ // byte order, as in JS. Elements read as numbers and writes convert like JS
8
+ // (ToInt32 wrapping, Uint8ClampedArray rounding / clamping). Methods taking a
9
+ // callback (map, filter, reduce …) are inlined by the transpiler over
10
+ // tnFloats(); the rest are Go methods here.
11
+ import { defineClass, defineHelper, setResults } from './registry.js';
12
+ // Typed array constructors and their Go element types (BYTES_PER_ELEMENT is the size)
13
+ export const TYPED_ARRAY_KINDS = {
14
+ Int8Array: 'int8',
15
+ Uint8ClampedArray: 'uint8',
16
+ Int16Array: 'int16',
17
+ Uint16Array: 'uint16',
18
+ Int32Array: 'int32',
19
+ Uint32Array: 'uint32',
20
+ Float32Array: 'float32',
21
+ Float64Array: 'float64'
22
+ };
23
+ const ELEMENT_SIZES = {
24
+ int8: 1,
25
+ uint8: 1,
26
+ int16: 2,
27
+ uint16: 2,
28
+ int32: 4,
29
+ uint32: 4,
30
+ float32: 4,
31
+ float64: 8
32
+ };
33
+ // Whether a Go type is one of the typed arrays above
34
+ export function isTypedArrayGoType(goType) {
35
+ if (!goType || !goType.startsWith('*Tn'))
36
+ return false;
37
+ return Object.keys(TYPED_ARRAY_KINDS).includes(goType.slice(3));
38
+ }
39
+ const typedArrayHelper = `// Typed arrays (Int8Array … Float64Array): a slice of the element type
40
+ type tnTypedElem interface {
41
+ int8 | uint8 | int16 | uint16 | int32 | uint32 | float32 | float64
42
+ }
43
+
44
+ type TnTypedArray[T tnTypedElem] struct {
45
+ data []T
46
+ kind string
47
+ clamped bool
48
+ }
49
+
50
+ type TnInt8Array = TnTypedArray[int8]
51
+ type TnUint8ClampedArray = TnTypedArray[uint8]
52
+ type TnInt16Array = TnTypedArray[int16]
53
+ type TnUint16Array = TnTypedArray[uint16]
54
+ type TnInt32Array = TnTypedArray[int32]
55
+ type TnUint32Array = TnTypedArray[uint32]
56
+ type TnFloat32Array = TnTypedArray[float32]
57
+ type TnFloat64Array = TnTypedArray[float64]
58
+
59
+ func tnTypedSize[T tnTypedElem]() int {
60
+ var zero T
61
+ return int(unsafe.Sizeof(zero))
62
+ }
63
+
64
+ // A number converted to the element type the way JS stores it: floats round,
65
+ // integers wrap modulo 2^n (NaN and ±Infinity store 0), clamped bytes round
66
+ // half to even into 0..255
67
+ func tnTypedConv[T tnTypedElem](v float64, clamped bool) T {
68
+ var zero T
69
+ switch any(zero).(type) {
70
+ case float32, float64:
71
+ return T(v)
72
+ }
73
+ if clamped {
74
+ if !(v > 0) {
75
+ return 0
76
+ }
77
+ if v >= 255 {
78
+ top := uint8(255)
79
+ return T(top)
80
+ }
81
+ return T(math.RoundToEven(v))
82
+ }
83
+ if math.IsNaN(v) || math.IsInf(v, 0) {
84
+ return 0
85
+ }
86
+ m := math.Mod(math.Trunc(v), 4294967296)
87
+ if m < 0 {
88
+ m += 4294967296
89
+ }
90
+ return T(uint32(m))
91
+ }
92
+
93
+ func tnTypedRangeError(message string) *TnError {
94
+ return TnNodeError("RangeError", "", message)
95
+ }
96
+
97
+ // The numbers of an array-like source (arrays, Uint8Arrays, typed arrays)
98
+ func tnTypedFloats(src interface{}) []float64 {
99
+ switch s := src.(type) {
100
+ case []float64:
101
+ return s
102
+ case *[]float64:
103
+ return *s
104
+ case []byte:
105
+ out := make([]float64, len(s))
106
+ for i, b := range s {
107
+ out[i] = float64(b)
108
+ }
109
+ return out
110
+ case []interface{}:
111
+ out := make([]float64, len(s))
112
+ for i, v := range s {
113
+ out[i] = TnNumber(v)
114
+ }
115
+ return out
116
+ case interface{ tnFloats() []float64 }:
117
+ return s.tnFloats()
118
+ }
119
+ panic(TnNodeError("TypeError", "", "Cannot convert argument to a typed array"))
120
+ }
121
+
122
+ func tnTypedOf[T tnTypedElem](kind string, clamped bool, values []float64) *TnTypedArray[T] {
123
+ data := make([]T, len(values))
124
+ for i, v := range values {
125
+ data[i] = tnTypedConv[T](v, clamped)
126
+ }
127
+ return &TnTypedArray[T]{data: data, kind: kind, clamped: clamped}
128
+ }
129
+
130
+ // new XArray(), new XArray(length), new XArray(array-like or typed array): a copy
131
+ func TnNewTypedArray[T tnTypedElem](kind string, clamped bool, src ...interface{}) *TnTypedArray[T] {
132
+ if len(src) == 0 || src[0] == nil {
133
+ return &TnTypedArray[T]{data: []T{}, kind: kind, clamped: clamped}
134
+ }
135
+ if n, ok := src[0].(float64); ok {
136
+ if !(n >= 0) || n != math.Trunc(n) || n > 4294967295 {
137
+ panic(tnTypedRangeError("Invalid typed array length: " + TnNumStr(n)))
138
+ }
139
+ return &TnTypedArray[T]{data: make([]T, int(n)), kind: kind, clamped: clamped}
140
+ }
141
+ return tnTypedOf[T](kind, clamped, tnTypedFloats(src[0]))
142
+ }
143
+
144
+ // new XArray(buffer[, byteOffset[, length]]): a view sharing the buffer's memory
145
+ func TnTypedArrayView[T tnTypedElem](kind string, clamped bool, buf []byte, args ...float64) *TnTypedArray[T] {
146
+ size := tnTypedSize[T]()
147
+ offset := 0
148
+ if len(args) > 0 {
149
+ offset = int(args[0])
150
+ }
151
+ if offset%size != 0 {
152
+ panic(tnTypedRangeError("start offset of " + kind + " should be a multiple of " + strconv.Itoa(size)))
153
+ }
154
+ if offset > len(buf) {
155
+ panic(tnTypedRangeError("Start offset " + strconv.Itoa(offset) + " is outside the bounds of the buffer"))
156
+ }
157
+ length := 0
158
+ if len(args) > 1 {
159
+ length = int(args[1])
160
+ if length < 0 || offset+length*size > len(buf) {
161
+ panic(tnTypedRangeError("Invalid typed array length: " + strconv.Itoa(length)))
162
+ }
163
+ } else {
164
+ if (len(buf)-offset)%size != 0 {
165
+ panic(tnTypedRangeError("byte length of " + kind + " should be a multiple of " + strconv.Itoa(size)))
166
+ }
167
+ length = (len(buf) - offset) / size
168
+ }
169
+ if length == 0 {
170
+ return &TnTypedArray[T]{data: []T{}, kind: kind, clamped: clamped}
171
+ }
172
+ data := unsafe.Slice((*T)(unsafe.Pointer(&buf[offset])), length)
173
+ return &TnTypedArray[T]{data: data, kind: kind, clamped: clamped}
174
+ }
175
+
176
+ // XArray.from(source[, mapFn]) / XArray.of(...items)
177
+ func TnTypedArrayFrom[T tnTypedElem](kind string, clamped bool, src interface{}, mapFn ...interface{}) *TnTypedArray[T] {
178
+ values := append([]float64{}, tnTypedFloats(src)...)
179
+ if len(mapFn) > 0 && mapFn[0] != nil {
180
+ for i, v := range values {
181
+ values[i] = TnNumber(TnInvoke(mapFn[0], v, float64(i)))
182
+ }
183
+ }
184
+ return tnTypedOf[T](kind, clamped, values)
185
+ }
186
+
187
+ func TnTypedArrayOf[T tnTypedElem](kind string, clamped bool, items ...float64) *TnTypedArray[T] {
188
+ return tnTypedOf[T](kind, clamped, items)
189
+ }
190
+
191
+ // Element reads: out-of-range and non-integer indices read 0 (undefined in JS)
192
+ func (a *TnTypedArray[T]) Get(i float64) float64 {
193
+ if !(i >= 0) || i >= float64(len(a.data)) || i != math.Trunc(i) {
194
+ return 0
195
+ }
196
+ return float64(a.data[int(i)])
197
+ }
198
+
199
+ // Element writes: out-of-range indices are ignored, as in JS
200
+ func (a *TnTypedArray[T]) Set(i float64, v float64) float64 {
201
+ if i >= 0 && i < float64(len(a.data)) && i == math.Trunc(i) {
202
+ a.data[int(i)] = tnTypedConv[T](v, a.clamped)
203
+ }
204
+ return v
205
+ }
206
+
207
+ func (a *TnTypedArray[T]) tnFloats() []float64 {
208
+ out := make([]float64, len(a.data))
209
+ for i, v := range a.data {
210
+ out[i] = float64(v)
211
+ }
212
+ return out
213
+ }
214
+
215
+ // A new typed array of the same kind (map / filter results)
216
+ func (a *TnTypedArray[T]) tnLike(values []float64) *TnTypedArray[T] {
217
+ return tnTypedOf[T](a.kind, a.clamped, values)
218
+ }
219
+
220
+ func (a *TnTypedArray[T]) Get_length() float64 { return float64(len(a.data)) }
221
+ func (a *TnTypedArray[T]) Get_byteLength() float64 { return float64(len(a.data) * tnTypedSize[T]()) }
222
+ func (a *TnTypedArray[T]) Get_byteOffset() float64 { return 0 }
223
+ func (a *TnTypedArray[T]) Get_BYTES_PER_ELEMENT() float64 { return float64(tnTypedSize[T]()) }
224
+
225
+ // The view's bytes (its byteOffset is 0: .buffer starts where the view does)
226
+ func (a *TnTypedArray[T]) Get_buffer() []byte {
227
+ if len(a.data) == 0 {
228
+ return []byte{}
229
+ }
230
+ return unsafe.Slice((*byte)(unsafe.Pointer(&a.data[0])), len(a.data)*tnTypedSize[T]())
231
+ }
232
+
233
+ // Relative start / end arguments (negative counts from the end), clamped
234
+ func tnTypedBounds(n int, args []float64) (int, int) {
235
+ rel := func(v float64) int {
236
+ if math.IsNaN(v) {
237
+ return 0
238
+ }
239
+ if v < 0 {
240
+ return max(n+int(math.Max(v, -1e15)), 0)
241
+ }
242
+ return min(int(math.Min(v, 1e15)), n)
243
+ }
244
+ start, end := 0, n
245
+ if len(args) > 0 {
246
+ start = rel(args[0])
247
+ }
248
+ if len(args) > 1 {
249
+ end = rel(args[1])
250
+ }
251
+ if end < start {
252
+ end = start
253
+ }
254
+ return start, end
255
+ }
256
+
257
+ func (a *TnTypedArray[T]) fill(v float64, args ...float64) *TnTypedArray[T] {
258
+ start, end := tnTypedBounds(len(a.data), args)
259
+ value := tnTypedConv[T](v, a.clamped)
260
+ for i := start; i < end; i++ {
261
+ a.data[i] = value
262
+ }
263
+ return a
264
+ }
265
+
266
+ // set(source[, offset]): copies an array-like in (overlapping views work)
267
+ func (a *TnTypedArray[T]) set(src interface{}, offset ...float64) {
268
+ at := 0
269
+ if len(offset) > 0 {
270
+ at = int(offset[0])
271
+ }
272
+ values := tnTypedFloats(src)
273
+ if at < 0 || at+len(values) > len(a.data) {
274
+ panic(tnTypedRangeError("offset is out of bounds"))
275
+ }
276
+ for i, v := range values {
277
+ a.data[at+i] = tnTypedConv[T](v, a.clamped)
278
+ }
279
+ }
280
+
281
+ // subarray shares memory; slice copies
282
+ func (a *TnTypedArray[T]) subarray(args ...float64) *TnTypedArray[T] {
283
+ start, end := tnTypedBounds(len(a.data), args)
284
+ return &TnTypedArray[T]{data: a.data[start:end:end], kind: a.kind, clamped: a.clamped}
285
+ }
286
+
287
+ func (a *TnTypedArray[T]) slice(args ...float64) *TnTypedArray[T] {
288
+ start, end := tnTypedBounds(len(a.data), args)
289
+ return &TnTypedArray[T]{data: append([]T{}, a.data[start:end]...), kind: a.kind, clamped: a.clamped}
290
+ }
291
+
292
+ func (a *TnTypedArray[T]) at(i float64) float64 {
293
+ if i < 0 {
294
+ i += float64(len(a.data))
295
+ }
296
+ return a.Get(math.Trunc(i))
297
+ }
298
+
299
+ func (a *TnTypedArray[T]) indexOf(v float64, from ...float64) float64 {
300
+ start, _ := tnTypedBounds(len(a.data), from)
301
+ for i := start; i < len(a.data); i++ {
302
+ if float64(a.data[i]) == v {
303
+ return float64(i)
304
+ }
305
+ }
306
+ return -1
307
+ }
308
+
309
+ func (a *TnTypedArray[T]) lastIndexOf(v float64, from ...float64) float64 {
310
+ end := len(a.data) - 1
311
+ if len(from) > 0 {
312
+ f := math.Trunc(from[0])
313
+ if f < 0 {
314
+ f += float64(len(a.data))
315
+ }
316
+ end = min(int(f), end)
317
+ }
318
+ for i := end; i >= 0; i-- {
319
+ if float64(a.data[i]) == v {
320
+ return float64(i)
321
+ }
322
+ }
323
+ return -1
324
+ }
325
+
326
+ // includes uses SameValueZero: NaN finds NaN
327
+ func (a *TnTypedArray[T]) includes(v float64, from ...float64) bool {
328
+ start, _ := tnTypedBounds(len(a.data), from)
329
+ for i := start; i < len(a.data); i++ {
330
+ x := float64(a.data[i])
331
+ if x == v || (x != x && v != v) {
332
+ return true
333
+ }
334
+ }
335
+ return false
336
+ }
337
+
338
+ func (a *TnTypedArray[T]) join(sep ...string) string {
339
+ separator := ","
340
+ if len(sep) > 0 {
341
+ separator = sep[0]
342
+ }
343
+ parts := make([]string, len(a.data))
344
+ for i, v := range a.data {
345
+ parts[i] = TnNumStr(float64(v))
346
+ }
347
+ return strings.Join(parts, separator)
348
+ }
349
+
350
+ func (a *TnTypedArray[T]) toString() string { return a.join(",") }
351
+ func (a *TnTypedArray[T]) toLocaleString() string { return a.join(",") }
352
+ func (a *TnTypedArray[T]) String() string { return a.join(",") }
353
+
354
+ func (a *TnTypedArray[T]) reverse() *TnTypedArray[T] {
355
+ for i, j := 0, len(a.data)-1; i < j; i, j = i+1, j-1 {
356
+ a.data[i], a.data[j] = a.data[j], a.data[i]
357
+ }
358
+ return a
359
+ }
360
+
361
+ func (a *TnTypedArray[T]) toReversed() *TnTypedArray[T] {
362
+ return a.slice().reverse()
363
+ }
364
+
365
+ // sort([compareFn]): numeric order by default (NaN last)
366
+ func (a *TnTypedArray[T]) sort(compare ...interface{}) *TnTypedArray[T] {
367
+ if len(compare) > 0 && compare[0] != nil {
368
+ cmp := compare[0]
369
+ sort.SliceStable(a.data, func(i, j int) bool {
370
+ x, y := float64(a.data[i]), float64(a.data[j])
371
+ if f, ok := cmp.(func(float64, float64) float64); ok {
372
+ return f(x, y) < 0
373
+ }
374
+ return TnNumber(TnInvoke(cmp, x, y)) < 0
375
+ })
376
+ return a
377
+ }
378
+ sort.SliceStable(a.data, func(i, j int) bool {
379
+ x, y := float64(a.data[i]), float64(a.data[j])
380
+ if x != x {
381
+ return false
382
+ }
383
+ if y != y {
384
+ return true
385
+ }
386
+ if x == 0 && y == 0 {
387
+ return math.Signbit(x) && !math.Signbit(y)
388
+ }
389
+ return x < y
390
+ })
391
+ return a
392
+ }
393
+
394
+ func (a *TnTypedArray[T]) toSorted(compare ...interface{}) *TnTypedArray[T] {
395
+ return a.slice().sort(compare...)
396
+ }
397
+
398
+ func (a *TnTypedArray[T]) with(i float64, v float64) *TnTypedArray[T] {
399
+ index := math.Trunc(i)
400
+ if index < 0 {
401
+ index += float64(len(a.data))
402
+ }
403
+ if !(index >= 0) || index >= float64(len(a.data)) {
404
+ panic(tnTypedRangeError("Invalid typed array index"))
405
+ }
406
+ out := a.slice()
407
+ out.data[int(index)] = tnTypedConv[T](v, a.clamped)
408
+ return out
409
+ }
410
+
411
+ func (a *TnTypedArray[T]) copyWithin(target float64, args ...float64) *TnTypedArray[T] {
412
+ n := len(a.data)
413
+ to, _ := tnTypedBounds(n, []float64{target})
414
+ start, end := tnTypedBounds(n, args)
415
+ copy(a.data[to:], a.data[start:end])
416
+ return a
417
+ }
418
+
419
+ func (a *TnTypedArray[T]) keys() []float64 {
420
+ out := make([]float64, len(a.data))
421
+ for i := range a.data {
422
+ out[i] = float64(i)
423
+ }
424
+ return out
425
+ }
426
+
427
+ func (a *TnTypedArray[T]) values() []float64 { return a.tnFloats() }
428
+
429
+ // util.inspect / console.log: Int32Array(3) [ 1, 2, 3 ]
430
+ func (a *TnTypedArray[T]) TnTypedInspect() (string, []float64) {
431
+ return a.kind + "(" + strconv.Itoa(len(a.data)) + ")", a.tnFloats()
432
+ }
433
+
434
+ // ArrayBuffer.isView: typed arrays, DataViews and Uint8Arrays
435
+ func TnIsView(v interface{}) bool {
436
+ switch v.(type) {
437
+ case []byte, *TnDataView:
438
+ return true
439
+ case interface{ tnFloats() []float64 }:
440
+ return true
441
+ }
442
+ return false
443
+ }
444
+
445
+ // DataView: typed reads and writes at byte offsets of an ArrayBuffer,
446
+ // big-endian unless littleEndian is true
447
+ type TnDataView struct {
448
+ buf []byte
449
+ offset int
450
+ length int
451
+ }
452
+
453
+ func TnNewDataView(buf []byte, args ...float64) *TnDataView {
454
+ offset := 0
455
+ if len(args) > 0 {
456
+ offset = int(args[0])
457
+ }
458
+ if offset < 0 || offset > len(buf) {
459
+ panic(tnTypedRangeError("Start offset " + strconv.Itoa(offset) + " is outside the bounds of the buffer"))
460
+ }
461
+ length := len(buf) - offset
462
+ if len(args) > 1 {
463
+ length = int(args[1])
464
+ if length < 0 || offset+length > len(buf) {
465
+ panic(tnTypedRangeError("Invalid DataView length " + strconv.Itoa(length)))
466
+ }
467
+ }
468
+ return &TnDataView{buf: buf, offset: offset, length: length}
469
+ }
470
+
471
+ func (d *TnDataView) Get_buffer() []byte { return d.buf }
472
+ func (d *TnDataView) Get_byteOffset() float64 { return float64(d.offset) }
473
+ func (d *TnDataView) Get_byteLength() float64 { return float64(d.length) }
474
+
475
+ func (d *TnDataView) at(offset float64, size int) []byte {
476
+ if !(offset >= 0) || offset != math.Trunc(offset) || int(offset)+size > d.length {
477
+ panic(tnTypedRangeError("Offset is outside the bounds of the DataView"))
478
+ }
479
+ start := d.offset + int(offset)
480
+ return d.buf[start : start+size]
481
+ }
482
+
483
+ func tnDataViewOrder(little []bool) binary.ByteOrder {
484
+ if len(little) > 0 && little[0] {
485
+ return binary.LittleEndian
486
+ }
487
+ return binary.BigEndian
488
+ }
489
+
490
+ func (d *TnDataView) getInt8(o float64) float64 { return float64(int8(d.at(o, 1)[0])) }
491
+ func (d *TnDataView) getUint8(o float64) float64 { return float64(d.at(o, 1)[0]) }
492
+ func (d *TnDataView) getInt16(o float64, little ...bool) float64 {
493
+ return float64(int16(tnDataViewOrder(little).Uint16(d.at(o, 2))))
494
+ }
495
+ func (d *TnDataView) getUint16(o float64, little ...bool) float64 {
496
+ return float64(tnDataViewOrder(little).Uint16(d.at(o, 2)))
497
+ }
498
+ func (d *TnDataView) getInt32(o float64, little ...bool) float64 {
499
+ return float64(int32(tnDataViewOrder(little).Uint32(d.at(o, 4))))
500
+ }
501
+ func (d *TnDataView) getUint32(o float64, little ...bool) float64 {
502
+ return float64(tnDataViewOrder(little).Uint32(d.at(o, 4)))
503
+ }
504
+ func (d *TnDataView) getFloat32(o float64, little ...bool) float64 {
505
+ return float64(math.Float32frombits(tnDataViewOrder(little).Uint32(d.at(o, 4))))
506
+ }
507
+ func (d *TnDataView) getFloat64(o float64, little ...bool) float64 {
508
+ return math.Float64frombits(tnDataViewOrder(little).Uint64(d.at(o, 8)))
509
+ }
510
+ func (d *TnDataView) getBigInt64(o float64, little ...bool) *tnbig.Int {
511
+ return tnbig.NewInt(int64(tnDataViewOrder(little).Uint64(d.at(o, 8))))
512
+ }
513
+ func (d *TnDataView) getBigUint64(o float64, little ...bool) *tnbig.Int {
514
+ return new(tnbig.Int).SetUint64(tnDataViewOrder(little).Uint64(d.at(o, 8)))
515
+ }
516
+
517
+ func (d *TnDataView) setInt8(o float64, v float64) { d.at(o, 1)[0] = byte(tnTypedConv[uint8](v, false)) }
518
+ func (d *TnDataView) setUint8(o float64, v float64) { d.at(o, 1)[0] = tnTypedConv[uint8](v, false) }
519
+ func (d *TnDataView) setInt16(o float64, v float64, little ...bool) {
520
+ tnDataViewOrder(little).PutUint16(d.at(o, 2), tnTypedConv[uint16](v, false))
521
+ }
522
+ func (d *TnDataView) setUint16(o float64, v float64, little ...bool) {
523
+ tnDataViewOrder(little).PutUint16(d.at(o, 2), tnTypedConv[uint16](v, false))
524
+ }
525
+ func (d *TnDataView) setInt32(o float64, v float64, little ...bool) {
526
+ tnDataViewOrder(little).PutUint32(d.at(o, 4), tnTypedConv[uint32](v, false))
527
+ }
528
+ func (d *TnDataView) setUint32(o float64, v float64, little ...bool) {
529
+ tnDataViewOrder(little).PutUint32(d.at(o, 4), tnTypedConv[uint32](v, false))
530
+ }
531
+ func (d *TnDataView) setFloat32(o float64, v float64, little ...bool) {
532
+ tnDataViewOrder(little).PutUint32(d.at(o, 4), math.Float32bits(float32(v)))
533
+ }
534
+ func (d *TnDataView) setFloat64(o float64, v float64, little ...bool) {
535
+ tnDataViewOrder(little).PutUint64(d.at(o, 8), math.Float64bits(v))
536
+ }
537
+
538
+ // BigInt writes wrap modulo 2^64 (BigInt.asUintN(64, v))
539
+ func tnDataViewUint64(v *tnbig.Int) uint64 {
540
+ m := new(tnbig.Int).And(v, new(tnbig.Int).SetUint64(math.MaxUint64))
541
+ return m.Uint64()
542
+ }
543
+ func (d *TnDataView) setBigInt64(o float64, v *tnbig.Int, little ...bool) {
544
+ tnDataViewOrder(little).PutUint64(d.at(o, 8), tnDataViewUint64(v))
545
+ }
546
+ func (d *TnDataView) setBigUint64(o float64, v *tnbig.Int, little ...bool) {
547
+ tnDataViewOrder(little).PutUint64(d.at(o, 8), tnDataViewUint64(v))
548
+ }
549
+
550
+ // ArrayBuffer#slice copies (a Uint8Array's subarray / Buffer's slice share)
551
+ func TnArrayBufferSlice(b []byte, args ...float64) []byte {
552
+ start, end := tnTypedBounds(len(b), args)
553
+ return append([]byte{}, b[start:end]...)
554
+ }`;
555
+ export function registerTypedArrays(r) {
556
+ defineHelper(r, 'typedArrays', ['encoding/binary', 'math', 'math/big', 'sort', 'strconv', 'strings', 'unsafe'], ['error', 'dynamic', 'nodeInvoke'], typedArrayHelper);
557
+ const use = () => r.helper('typedArrays');
558
+ for (const name of Object.keys(TYPED_ARRAY_KINDS)) {
559
+ const elem = TYPED_ARRAY_KINDS[name];
560
+ const goType = `*Tn${name}`;
561
+ const key = `globals.${name}`;
562
+ const clamped = name === 'Uint8ClampedArray' ? 'true' : 'false';
563
+ const generic = `[${elem}](${JSON.stringify(name)}, ${clamped}`;
564
+ defineClass(r, key, goType, 'class', `fill=${goType}; set=; subarray=${goType}; slice=${goType}; at=float64; indexOf=float64; lastIndexOf=float64; includes=bool; join=string; toString=string; toLocaleString=string; reverse=${goType}; toReversed=${goType}; sort=${goType}; toSorted=${goType}; with=${goType}; copyWithin=${goType}; keys=[]float64; values=[]float64; tnFloats=[]float64`, '', 'length=float64; byteLength=float64; byteOffset=float64; BYTES_PER_ELEMENT=float64; buffer=[]byte', '');
565
+ r.globals[name] = key;
566
+ r.iterators[goType] = 'tnFloats';
567
+ r.paramTypers[`${key}#sort`] = (_n) => ['float64', 'float64'];
568
+ r.paramTypers[`${key}#toSorted`] = r.paramTypers[`${key}#sort`];
569
+ // new Int32Array(length | array-like) copies; new Int32Array(buffer, …) views
570
+ r.constructors[key] = (call) => {
571
+ use();
572
+ if (call.args.length > 0 && r.isArrayBuffer(call.nodes[0])) {
573
+ return `TnTypedArrayView${generic}, ${call.args.join(', ')})`;
574
+ }
575
+ return `TnNewTypedArray${generic}${call.args.length > 0 ? ', ' + call.args[0] : ''})`;
576
+ };
577
+ r.functions[`${key}.from`] = (call) => {
578
+ use();
579
+ return `TnTypedArrayFrom${generic}, ${call.args.join(', ')})`;
580
+ };
581
+ r.paramTypers[`${key}.from`] = (_n) => ['float64', 'float64'];
582
+ r.functions[`${key}.of`] = (call) => {
583
+ use();
584
+ return `TnTypedArrayOf${generic}${call.args.length > 0 ? ', ' + call.args.join(', ') : ''})`;
585
+ };
586
+ setResults(r, key, `from=${goType}; of=${goType}`);
587
+ r.values[`${key}.BYTES_PER_ELEMENT`] = (_c) => `float64(${ELEMENT_SIZES[elem]})`;
588
+ r.valueTypes[`${key}.BYTES_PER_ELEMENT`] = 'float64';
589
+ }
590
+ defineClass(r, 'globals.DataView', '*TnDataView', 'class', 'getInt8=float64; getUint8=float64; getInt16=float64; getUint16=float64; getInt32=float64; getUint32=float64; getFloat32=float64; getFloat64=float64; getBigInt64=*tnbig.Int; getBigUint64=*tnbig.Int; setInt8=; setUint8=; setInt16=; setUint16=; setInt32=; setUint32=; setFloat32=; setFloat64=; setBigInt64=; setBigUint64=', '', 'buffer=[]byte; byteOffset=float64; byteLength=float64', '');
591
+ r.globals['DataView'] = 'globals.DataView';
592
+ r.constructors['globals.DataView'] = (call) => {
593
+ use();
594
+ return `TnNewDataView(${call.args.join(', ')})`;
595
+ };
596
+ // ArrayBuffer is Go []byte too: new ArrayBuffer(n), ArrayBuffer.isView
597
+ defineClass(r, 'globals.ArrayBuffer', '[]byte', 'Buffer', '', '', '', '');
598
+ r.classByGoType['[]byte'] = 'buffer.Buffer';
599
+ r.globals['ArrayBuffer'] = 'globals.ArrayBuffer';
600
+ r.constructors['globals.ArrayBuffer'] = (call) => call.args.length > 0 ? `make([]byte, int(${call.args[0]}))` : '[]byte{}';
601
+ r.functions['globals.ArrayBuffer.isView'] = (call) => {
602
+ use();
603
+ if (r.isArrayBuffer(call.nodes[0]))
604
+ return 'false';
605
+ return `TnIsView(${call.args[0]})`;
606
+ };
607
+ r.results['globals.ArrayBuffer.isView'] = 'bool';
608
+ }
package/bin/node/util.js CHANGED
@@ -192,6 +192,9 @@ func (ins *tnInspector) format(v interface{}, depth int) string {
192
192
  return x.String() + "n"
193
193
  case []byte:
194
194
  return TnBufferInspect(x)
195
+ case interface{ TnTypedInspect() (string, []float64) }:
196
+ name, values := x.TnTypedInspect()
197
+ return name + " " + ins.format(values, depth)
195
198
  case time.Time:
196
199
  return x.UTC().Format("2006-01-02T15:04:05.000Z07:00")
197
200
  case *regexp.Regexp: