MIRROR: javascript for ๐'s, a tiny runtime with big ambitions
revise TextEncoding and add brotli
+178
-65
+5
-2
examples/spec/escapes.js
+5
-2
examples/spec/escapes.js
···
10
10
test('form feed (\\f) charCodeAt', '\f'.charCodeAt(0), 12);
11
11
test('carriage return (\\r) charCodeAt', '\r'.charCodeAt(0), 13);
12
12
13
-
test('escaped quote single', '\''.length, 1);
14
-
test('escaped quote double', "\"".length, 1);
13
+
test('escaped quote single', "'".length, 1);
14
+
test('escaped quote double', '"'.length, 1);
15
15
test('escaped backslash', '\\'.charCodeAt(0), 92);
16
16
17
17
test('hex escape \\x41', '\x41', 'A');
···
23
23
test('unicode \\u00e9 (รฉ)', '\u00e9', 'รฉ');
24
24
test('unicode \\u263A (smiley)', '\u263A', 'โบ');
25
25
test('unicode \\u4e2d (ไธญ)', '\u4e2d', 'ไธญ');
26
+
27
+
test('unicode code point escape keeps following chars', '\u{1F499} streams', '๐ streams');
28
+
test('unicode code point escape in string body keeps spaces', 'I \u{1F499} streams', 'I ๐ streams');
26
29
27
30
test('string with null char length', 'a\0b'.length, 3);
28
31
test('string with null indexOf', 'a\0b'.indexOf('\0'), 1);
+2
include/modules/textcodec.h
+2
include/modules/textcodec.h
+25
meson/deps/meson.build
+25
meson/deps/meson.build
···
55
55
'inc': '',
56
56
'build_dir': true,
57
57
},
58
+
'google-brotli': {
59
+
'dir': 'brotli-1.1.0',
60
+
'inc': 'c/include',
61
+
},
58
62
}
59
63
60
64
subprojects_src = src_root / 'vendor'
···
71
75
zlib_dep = zlib_ng_sub.get_variable('zlib_ng_dep')
72
76
zlib_ng_srcdir = subprojects_src / deps_info['zlib-ng']['dir']
73
77
zlib_ng_builddir = subprojects_build / deps_info['zlib-ng']['dir']
78
+
79
+
brotli_common_dep = dependency('libbrotlicommon',
80
+
fallback: ['google-brotli', 'libbrotlicommon'],
81
+
required: true,
82
+
static: is_static,
83
+
)
84
+
brotli_dec_dep = dependency('libbrotlidec',
85
+
fallback: ['google-brotli', 'libbrotlidec'],
86
+
required: true,
87
+
static: is_static,
88
+
)
89
+
brotli_enc_dep = dependency('libbrotlienc',
90
+
fallback: ['google-brotli', 'libbrotlienc'],
91
+
required: true,
92
+
static: is_static,
93
+
)
74
94
75
95
cmake_prefix = get_option('deps_prefix_cmake')
76
96
···
174
194
'inc': '',
175
195
'build_dir': true,
176
196
},
197
+
'google-brotli': {
198
+
'dir': 'brotli-1.1.0',
199
+
'inc': 'c/include',
200
+
},
177
201
}
178
202
179
203
subprojects_src = src_root / 'vendor'
···
184
208
libuv_include_path = subprojects_src / deps_info['libuv']['dir'] / deps_info['libuv']['inc']
185
209
llhttp_include_path = subprojects_src / deps_info['llhttp']['dir'] / deps_info['llhttp']['inc']
186
210
zlib_include_path = subprojects_build / deps_info['zlib-ng']['dir'] / deps_info['zlib-ng']['inc']
211
+
brotli_include_path = subprojects_src / deps_info['google-brotli']['dir'] / deps_info['google-brotli']['inc']
187
212
188
213
pkg_zig_dir = src_root / 'src' / 'pkg'
189
214
pkg_build_dir = meson.current_build_dir()
+1
-1
src/escape.c
+1
-1
src/escape.c
+65
-11
src/modules/textcodec.c
+65
-11
src/modules/textcodec.c
···
44
44
45
45
static int resolve_encoding(const char *s, size_t len) {
46
46
static const struct { const char *label; uint8_t len; td_encoding_t enc; } map[] = {
47
-
{"unicode-1-1-utf-8", 18, TD_ENC_UTF8}, {"unicode11utf8", 13, TD_ENC_UTF8},
47
+
{"unicode-1-1-utf-8", 17, TD_ENC_UTF8}, {"unicode11utf8", 13, TD_ENC_UTF8},
48
48
{"unicode20utf8", 13, TD_ENC_UTF8}, {"utf-8", 5, TD_ENC_UTF8},
49
49
{"utf8", 4, TD_ENC_UTF8}, {"x-unicode20utf8",17, TD_ENC_UTF8},
50
+
{"windows-1252", 12, TD_ENC_WINDOWS_1252}, {"ascii", 5, TD_ENC_WINDOWS_1252},
50
51
{"unicodefffe", 11, TD_ENC_UTF16BE}, {"utf-16be", 8, TD_ENC_UTF16BE},
51
52
{"csunicode", 9, TD_ENC_UTF16LE}, {"iso-10646-ucs-2",16, TD_ENC_UTF16LE},
52
53
{"ucs-2", 5, TD_ENC_UTF16LE}, {"unicode", 7, TD_ENC_UTF16LE},
53
54
{"unicodefeff", 11, TD_ENC_UTF16LE}, {"utf-16", 6, TD_ENC_UTF16LE},
54
55
{"utf-16le", 8, TD_ENC_UTF16LE},
56
+
{"iso-8859-2", 10, TD_ENC_ISO_8859_2},
55
57
{NULL, 0, 0}
56
58
};
57
59
for (int i = 0; map[i].label; i++) {
···
62
64
63
65
static const char *encoding_name(td_encoding_t enc) {
64
66
switch (enc) {
65
-
case TD_ENC_UTF16LE: return "utf-16le";
66
-
case TD_ENC_UTF16BE: return "utf-16be";
67
-
default: return "utf-8";
67
+
case TD_ENC_UTF16LE: return "utf-16le";
68
+
case TD_ENC_UTF16BE: return "utf-16be";
69
+
case TD_ENC_WINDOWS_1252: return "windows-1252";
70
+
case TD_ENC_ISO_8859_2: return "iso-8859-2";
71
+
default: return "utf-8";
68
72
}}
69
73
70
74
static const char *trim_label(const char *s, size_t len, size_t *out_len) {
···
253
257
#define U16_IS_LOW(cu) ((cu) >= 0xDC00 && (cu) <= 0xDFFF)
254
258
#define U16_PAIR(hi,lo) (0x10000 + ((uint32_t)((hi) - 0xD800) << 10) + ((lo) - 0xDC00))
255
259
260
+
static uint32_t decode_windows_1252_byte(uint8_t byte) {
261
+
static const uint16_t specials[32] = {
262
+
0x20AC, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
263
+
0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x017D, 0x008F,
264
+
0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
265
+
0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x017E, 0x0178,
266
+
};
267
+
if (byte < 0x80) return byte;
268
+
if (byte < 0xA0) return specials[byte - 0x80];
269
+
return byte;
270
+
}
271
+
272
+
static uint32_t decode_iso_8859_2_byte(uint8_t byte) {
273
+
static const uint16_t upper[96] = {
274
+
0x00A0, 0x0104, 0x02D8, 0x0141, 0x00A4, 0x013D, 0x015A, 0x00A7,
275
+
0x00A8, 0x0160, 0x015E, 0x0164, 0x0179, 0x00AD, 0x017D, 0x017B,
276
+
0x00B0, 0x0105, 0x02DB, 0x0142, 0x00B4, 0x013E, 0x015B, 0x02C7,
277
+
0x00B8, 0x0161, 0x015F, 0x0165, 0x017A, 0x02DD, 0x017E, 0x017C,
278
+
0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7,
279
+
0x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E,
280
+
0x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7,
281
+
0x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF,
282
+
0x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7,
283
+
0x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F,
284
+
0x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7,
285
+
0x0159, 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9,
286
+
};
287
+
if (byte < 0xA0) return byte;
288
+
return upper[byte - 0xA0];
289
+
}
290
+
291
+
static utf8proc_ssize_t decode_single_byte(td_state_t *st, const uint8_t *src, size_t len, char *out) {
292
+
size_t o = 0;
293
+
for (size_t i = 0; i < len; i++) {
294
+
uint32_t cp = (st->encoding == TD_ENC_WINDOWS_1252)
295
+
? decode_windows_1252_byte(src[i])
296
+
: decode_iso_8859_2_byte(src[i]);
297
+
o = u8_emit(out, o, (utf8proc_int32_t)cp);
298
+
}
299
+
return (utf8proc_ssize_t)o;
300
+
}
301
+
256
302
static utf8proc_ssize_t utf16_decode(td_state_t *st, const uint8_t *src, size_t len, char *out, bool stream) {
257
303
bool be = (st->encoding == TD_ENC_UTF16BE);
258
304
size_t i = 0, o = 0;
···
330
376
utf8proc_ssize_t n;
331
377
if (st->encoding == TD_ENC_UTF16LE || st->encoding == TD_ENC_UTF16BE) {
332
378
n = utf16_decode(st, src, total, out, stream_mode);
379
+
} else if (st->encoding == TD_ENC_WINDOWS_1252 || st->encoding == TD_ENC_ISO_8859_2) {
380
+
n = decode_single_byte(st, src, total, out);
381
+
st->pending_len = 0;
382
+
st->bom_seen = false;
333
383
} else {
334
384
utf8_dec_t dec = { .ignore_bom = st->ignore_bom, .bom_seen = st->bom_seen };
335
385
n = utf8_whatwg_decode(&dec, src, total, out, st->fatal, stream_mode);
···
377
427
return js_mkerr_typed(js, JS_ERR_TYPE, "TextDecoder constructor requires 'new'");
378
428
379
429
td_encoding_t enc = TD_ENC_UTF8;
380
-
if (nargs > 0 && vtype(args[0]) == T_STR) {
381
-
size_t llen;
382
-
const char *raw = js_getstr(js, args[0], &llen);
383
-
430
+
if (nargs > 0 && !is_undefined(args[0])) {
431
+
ant_value_t label = (vtype(args[0]) == T_STR) ? args[0] : coerce_to_str(js, args[0]);
432
+
if (is_err(label)) return label;
433
+
434
+
size_t llen;
435
+
const char *raw = js_getstr(js, label, &llen);
384
436
if (raw) {
385
437
size_t tlen;
386
438
const char *trimmed = trim_label(raw, llen, &tlen);
387
439
int resolved = resolve_encoding(trimmed, tlen);
388
440
389
441
if (resolved < 0) return js_mkerr_typed(
390
-
js, JS_ERR_RANGE, "Failed to construct 'TextDecoder': The encoding label provided ('%.*s') is invalid.",
442
+
js, JS_ERR_RANGE, "Failed to construct 'TextDecoder': The encoding label provided ('%.*s') is invalid.",
391
443
(int)tlen, trimmed
392
444
);
393
445
···
398
450
bool ignore_bom = false;
399
451
400
452
if (nargs > 1 && is_object_type(args[1])) {
401
-
ant_value_t fv = js_get(js, args[1], "fatal");
453
+
ant_value_t fv = js_getprop_fallback(js, args[1], "fatal");
454
+
if (is_err(fv)) return fv;
402
455
if (vtype(fv) != T_UNDEF) fatal = js_truthy(js, fv);
403
-
ant_value_t bv = js_get(js, args[1], "ignoreBOM");
456
+
ant_value_t bv = js_getprop_fallback(js, args[1], "ignoreBOM");
457
+
if (is_err(bv)) return bv;
404
458
if (vtype(bv) != T_UNDEF) ignore_bom = js_truthy(js, bv);
405
459
}
406
460
+54
-38
src/streams/codec.c
+54
-38
src/streams/codec.c
···
12
12
#include "modules/textcodec.h"
13
13
#include "streams/codec.h"
14
14
#include "streams/transform.h"
15
-
#include "streams/readable.h"
16
15
17
16
ant_value_t g_tes_proto;
18
17
ant_value_t g_tds_proto;
···
114
113
return false;
115
114
}
116
115
116
+
static ant_value_t codec_transform_controller(ant_value_t *args, int nargs) {
117
+
return (nargs > 1) ? args[1] : js_mkundef();
118
+
}
119
+
120
+
static ant_value_t codec_flush_controller(ant_value_t *args, int nargs) {
121
+
return (nargs > 0) ? args[0] : js_mkundef();
122
+
}
123
+
117
124
static ant_value_t tes_transform(ant_t *js, ant_value_t *args, int nargs) {
118
125
ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA);
119
126
ant_value_t state_val = js_get_slot(wrapper, SLOT_DATA);
127
+
120
128
tes_state_t *st = (tes_state_t *)(uintptr_t)(size_t)js_getnum(state_val);
121
-
129
+
ant_value_t ctrl_obj = codec_transform_controller(args, nargs);
122
130
ant_value_t chunk = (nargs > 0) ? args[0] : js_mkundef();
131
+
123
132
size_t str_len = 0;
124
133
const char *str = NULL;
125
134
···
193
202
free(out);
194
203
195
204
ant_value_t result = create_typed_array(js, TYPED_ARRAY_UINT8, ab, 0, o, "Uint8Array");
196
-
ant_value_t ts_obj = js_get_slot(wrapper, SLOT_ENTRIES);
197
-
ant_value_t readable = ts_stream_readable(ts_obj);
198
-
ant_value_t rs_ctrl = rs_stream_controller(js, readable);
199
-
rs_controller_enqueue(js, rs_ctrl, result);
200
-
201
-
return js_mkundef();
205
+
return ts_is_controller(ctrl_obj)
206
+
? ts_ctrl_enqueue(js, ctrl_obj, result)
207
+
: js_mkerr_typed(js, JS_ERR_TYPE, "Invalid TransformStreamDefaultController");
202
208
}
203
209
204
210
static ant_value_t tes_flush(ant_t *js, ant_value_t *args, int nargs) {
205
211
ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA);
206
212
ant_value_t state_val = js_get_slot(wrapper, SLOT_DATA);
207
213
tes_state_t *st = (tes_state_t *)(uintptr_t)(size_t)js_getnum(state_val);
214
+
ant_value_t ctrl_obj = codec_flush_controller(args, nargs);
208
215
209
216
if (st->pending_len > 0) {
210
217
uint8_t fffd[3] = { 0xEF, 0xBF, 0xBD };
···
214
221
st->pending_len = 0;
215
222
216
223
ant_value_t result = create_typed_array(js, TYPED_ARRAY_UINT8, ab, 0, 3, "Uint8Array");
217
-
ant_value_t ts_obj = js_get_slot(wrapper, SLOT_ENTRIES);
218
-
ant_value_t readable = ts_stream_readable(ts_obj);
219
-
ant_value_t rs_ctrl = rs_stream_controller(js, readable);
220
-
rs_controller_enqueue(js, rs_ctrl, result);
224
+
if (!ts_is_controller(ctrl_obj))
225
+
return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid TransformStreamDefaultController");
226
+
return ts_ctrl_enqueue(js, ctrl_obj, result);
221
227
}
222
228
223
229
return js_mkundef();
···
281
287
ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA);
282
288
ant_value_t state_val = js_get_slot(wrapper, SLOT_DATA);
283
289
td_state_t *st = (td_state_t *)(uintptr_t)(size_t)js_getnum(state_val);
290
+
ant_value_t ctrl_obj = codec_transform_controller(args, nargs);
284
291
285
292
ant_value_t chunk = (nargs > 0) ? args[0] : js_mkundef();
286
293
const uint8_t *input = NULL;
287
294
size_t input_len = 0;
288
295
289
-
if (is_object_type(chunk))
290
-
get_chunk_bytes(js, chunk, &input, &input_len);
296
+
if (!is_object_type(chunk) || !get_chunk_bytes(js, chunk, &input, &input_len))
297
+
return js_mkerr_typed(js, JS_ERR_TYPE, "The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
291
298
292
299
ant_value_t result = td_decode(js, st, input, input_len, true);
293
300
if (is_err(result)) return result;
···
295
302
size_t slen = 0;
296
303
const char *sval = js_getstr(js, result, &slen);
297
304
if (sval && slen > 0) {
298
-
ant_value_t ts_obj = js_get_slot(wrapper, SLOT_ENTRIES);
299
-
ant_value_t readable = ts_stream_readable(ts_obj);
300
-
ant_value_t rs_ctrl = rs_stream_controller(js, readable);
301
-
rs_controller_enqueue(js, rs_ctrl, result);
305
+
if (!ts_is_controller(ctrl_obj))
306
+
return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid TransformStreamDefaultController");
307
+
return ts_ctrl_enqueue(js, ctrl_obj, result);
302
308
}
303
309
304
310
return js_mkundef();
···
308
314
ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA);
309
315
ant_value_t state_val = js_get_slot(wrapper, SLOT_DATA);
310
316
td_state_t *st = (td_state_t *)(uintptr_t)(size_t)js_getnum(state_val);
317
+
ant_value_t ctrl_obj = codec_flush_controller(args, nargs);
311
318
312
319
ant_value_t result = td_decode(js, st, NULL, 0, false);
313
320
if (is_err(result)) return result;
···
315
322
size_t slen = 0;
316
323
const char *sval = js_getstr(js, result, &slen);
317
324
if (sval && slen > 0) {
318
-
ant_value_t ts_obj = js_get_slot(wrapper, SLOT_ENTRIES);
319
-
ant_value_t readable = ts_stream_readable(ts_obj);
320
-
ant_value_t rs_ctrl = rs_stream_controller(js, readable);
321
-
rs_controller_enqueue(js, rs_ctrl, result);
325
+
if (!ts_is_controller(ctrl_obj))
326
+
return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid TransformStreamDefaultController");
327
+
return ts_ctrl_enqueue(js, ctrl_obj, result);
322
328
}
323
329
324
330
return js_mkundef();
···
331
337
switch (st->encoding) {
332
338
case TD_ENC_UTF16LE: return js_mkstr(js, "utf-16le", 8);
333
339
case TD_ENC_UTF16BE: return js_mkstr(js, "utf-16be", 8);
340
+
case TD_ENC_WINDOWS_1252: return js_mkstr(js, "windows-1252", 12);
341
+
case TD_ENC_ISO_8859_2: return js_mkstr(js, "iso-8859-2", 10);
334
342
default: return js_mkstr(js, "utf-8", 5);
335
343
}
336
344
}
···
368
376
369
377
static int tds_resolve_encoding(const char *s, size_t len) {
370
378
static const struct { const char *label; uint8_t label_len; td_encoding_t enc; } map[] = {
371
-
{"unicode-1-1-utf-8", 18, TD_ENC_UTF8}, {"unicode11utf8", 13, TD_ENC_UTF8},
379
+
{"unicode-1-1-utf-8", 17, TD_ENC_UTF8}, {"unicode11utf8", 13, TD_ENC_UTF8},
372
380
{"unicode20utf8", 13, TD_ENC_UTF8}, {"utf-8", 5, TD_ENC_UTF8},
373
381
{"utf8", 4, TD_ENC_UTF8}, {"x-unicode20utf8",17, TD_ENC_UTF8},
382
+
{"windows-1252", 12, TD_ENC_WINDOWS_1252}, {"ascii", 5, TD_ENC_WINDOWS_1252},
374
383
{"unicodefffe", 11, TD_ENC_UTF16BE}, {"utf-16be", 8, TD_ENC_UTF16BE},
375
384
{"csunicode", 9, TD_ENC_UTF16LE}, {"iso-10646-ucs-2",16, TD_ENC_UTF16LE},
376
385
{"ucs-2", 5, TD_ENC_UTF16LE}, {"unicode", 7, TD_ENC_UTF16LE},
377
386
{"unicodefeff", 11, TD_ENC_UTF16LE}, {"utf-16", 6, TD_ENC_UTF16LE},
378
387
{"utf-16le", 8, TD_ENC_UTF16LE},
388
+
{"iso-8859-2", 10, TD_ENC_ISO_8859_2},
379
389
{NULL, 0, 0}
380
390
};
381
391
for (int i = 0; map[i].label; i++) {
···
389
399
return js_mkerr_typed(js, JS_ERR_TYPE, "TextDecoderStream constructor requires 'new'");
390
400
391
401
td_encoding_t enc = TD_ENC_UTF8;
392
-
if (nargs > 0 && vtype(args[0]) == T_STR) {
393
-
size_t llen;
394
-
const char *raw = js_getstr(js, args[0], &llen);
395
-
if (raw) {
396
-
size_t tlen;
397
-
const char *trimmed = tds_trim_label(raw, llen, &tlen);
398
-
int resolved = tds_resolve_encoding(trimmed, tlen);
399
-
if (resolved < 0) return js_mkerr_typed(
400
-
js, JS_ERR_RANGE, "Failed to construct 'TextDecoderStream': The encoding label provided ('%.*s') is invalid.",
401
-
(int)tlen, trimmed
402
-
);
403
-
enc = (td_encoding_t)resolved;
404
-
}}
402
+
if (nargs > 0 && !is_undefined(args[0])) {
403
+
ant_value_t label = (vtype(args[0]) == T_STR) ? args[0] : coerce_to_str(js, args[0]);
404
+
if (is_err(label)) return label;
405
+
406
+
size_t llen;
407
+
const char *raw = js_getstr(js, label, &llen);
408
+
if (raw) {
409
+
size_t tlen;
410
+
const char *trimmed = tds_trim_label(raw, llen, &tlen);
411
+
int resolved = tds_resolve_encoding(trimmed, tlen);
412
+
if (resolved < 0) return js_mkerr_typed(
413
+
js, JS_ERR_RANGE, "Failed to construct 'TextDecoderStream': The encoding label provided ('%.*s') is invalid.",
414
+
(int)tlen, trimmed
415
+
);
416
+
enc = (td_encoding_t)resolved;
417
+
}
418
+
}
405
419
406
420
bool fatal = false;
407
421
bool ignore_bom = false;
408
422
if (nargs > 1 && is_object_type(args[1])) {
409
-
ant_value_t fv = js_get(js, args[1], "fatal");
423
+
ant_value_t fv = js_getprop_fallback(js, args[1], "fatal");
424
+
if (is_err(fv)) return fv;
410
425
if (vtype(fv) != T_UNDEF) fatal = js_truthy(js, fv);
411
-
ant_value_t bv = js_get(js, args[1], "ignoreBOM");
426
+
ant_value_t bv = js_getprop_fallback(js, args[1], "ignoreBOM");
427
+
if (is_err(bv)) return bv;
412
428
if (vtype(bv) != T_UNDEF) ignore_bom = js_truthy(js, bv);
413
429
}
414
430
+12
-13
src/streams/compression.c
+12
-13
src/streams/compression.c
···
12
12
#include "modules/buffer.h"
13
13
#include "streams/compression.h"
14
14
#include "streams/transform.h"
15
-
#include "streams/readable.h"
16
15
17
16
ant_value_t g_cs_proto;
18
17
ant_value_t g_ds_proto;
···
135
134
return false;
136
135
}
137
136
138
-
static ant_value_t enqueue_buffer(ant_t *js, ant_value_t ts_obj, const uint8_t *data, size_t len) {
137
+
static ant_value_t enqueue_buffer(ant_t *js, ant_value_t ctrl_obj, const uint8_t *data, size_t len) {
139
138
ArrayBufferData *ab = create_array_buffer_data(len);
140
139
if (!ab) return js_mkerr(js, "out of memory");
141
140
memcpy(ab->data, data, len);
142
141
ant_value_t arr = create_typed_array(js, TYPED_ARRAY_UINT8, ab, 0, len, "Uint8Array");
143
-
ant_value_t readable = ts_stream_readable(ts_obj);
144
-
ant_value_t rs_ctrl = rs_stream_controller(js, readable);
145
-
return rs_controller_enqueue(js, rs_ctrl, arr);
142
+
if (!ts_is_controller(ctrl_obj))
143
+
return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid TransformStreamDefaultController");
144
+
return ts_ctrl_enqueue(js, ctrl_obj, arr);
146
145
}
147
146
148
147
#define ZCHUNK_SIZE 16384
···
150
149
static ant_value_t cs_transform(ant_t *js, ant_value_t *args, int nargs) {
151
150
ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA);
152
151
ant_value_t state_val = js_get_slot(wrapper, SLOT_DATA);
152
+
153
153
zstate_t *st = (zstate_t *)(uintptr_t)(size_t)js_getnum(state_val);
154
-
ant_value_t ts_obj = js_get_slot(wrapper, SLOT_ENTRIES);
155
-
154
+
ant_value_t ctrl_obj = (nargs > 1) ? args[1] : js_mkundef();
156
155
ant_value_t chunk = (nargs > 0) ? args[0] : js_mkundef();
156
+
157
157
const uint8_t *input = NULL;
158
158
size_t input_len = 0;
159
159
···
174
174
return js_mkerr_typed(js, JS_ERR_TYPE, "Compression failed");
175
175
size_t have = ZCHUNK_SIZE - st->strm.avail_out;
176
176
if (have > 0) {
177
-
ant_value_t r = enqueue_buffer(js, ts_obj, out_buf, have);
177
+
ant_value_t r = enqueue_buffer(js, ctrl_obj, out_buf, have);
178
178
if (is_err(r)) return r;
179
179
}
180
180
} while (st->strm.avail_out == 0);
···
186
186
ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA);
187
187
ant_value_t state_val = js_get_slot(wrapper, SLOT_DATA);
188
188
zstate_t *st = (zstate_t *)(uintptr_t)(size_t)js_getnum(state_val);
189
-
ant_value_t ts_obj = js_get_slot(wrapper, SLOT_ENTRIES);
189
+
ant_value_t ctrl_obj = (nargs > 0) ? args[0] : js_mkundef();
190
190
191
191
st->strm.next_in = NULL;
192
192
st->strm.avail_in = 0;
···
199
199
ret = deflate(&st->strm, Z_FINISH);
200
200
size_t have = ZCHUNK_SIZE - st->strm.avail_out;
201
201
if (have > 0) {
202
-
ant_value_t r = enqueue_buffer(js, ts_obj, out_buf, have);
202
+
ant_value_t r = enqueue_buffer(js, ctrl_obj, out_buf, have);
203
203
if (is_err(r)) return r;
204
204
}
205
205
} while (ret != Z_STREAM_END);
···
274
274
ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA);
275
275
ant_value_t state_val = js_get_slot(wrapper, SLOT_DATA);
276
276
zstate_t *st = (zstate_t *)(uintptr_t)(size_t)js_getnum(state_val);
277
-
ant_value_t ts_obj = js_get_slot(wrapper, SLOT_ENTRIES);
277
+
ant_value_t ctrl_obj = (nargs > 1) ? args[1] : js_mkundef();
278
278
279
279
ant_value_t chunk = (nargs > 0) ? args[0] : js_mkundef();
280
280
const uint8_t *input = NULL;
···
284
284
return js_mkerr_typed(js, JS_ERR_TYPE, "The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
285
285
286
286
if (!input || input_len == 0) return js_mkundef();
287
-
288
287
st->strm.next_in = (Bytef *)input;
289
288
st->strm.avail_in = (uInt)input_len;
290
289
···
297
296
return js_mkerr_typed(js, JS_ERR_TYPE, "Decompression failed");
298
297
size_t have = ZCHUNK_SIZE - st->strm.avail_out;
299
298
if (have > 0) {
300
-
ant_value_t r = enqueue_buffer(js, ts_obj, out_buf, have);
299
+
ant_value_t r = enqueue_buffer(js, ctrl_obj, out_buf, have);
301
300
if (is_err(r)) return r;
302
301
}
303
302
if (ret == Z_STREAM_END) break;
+14
vendor/google-brotli.wrap
+14
vendor/google-brotli.wrap
···
1
+
[wrap-file]
2
+
directory = brotli-1.1.0
3
+
source_url = https://github.com/google/brotli/archive/v1.1.0.tar.gz
4
+
source_filename = brotli-1.1.0.tar.gz
5
+
source_hash = e720a6ca29428b803f4ad165371771f5398faba397edf6778837a18599ea13ff
6
+
source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/google-brotli_1.1.0-3/brotli-1.1.0.tar.gz
7
+
patch_filename = google-brotli_1.1.0-3_patch.zip
8
+
patch_url = https://wrapdb.mesonbuild.com/v2/google-brotli_1.1.0-3/get_patch
9
+
patch_hash = 77e75a3bb019a4b653195a15af17cc65c56fb8cced2519154fce4e6bb43c74e2
10
+
wrapdb_version = 1.1.0-3
11
+
12
+
[provide]
13
+
program_names = brotli
14
+
dependency_names = libbrotlicommon, libbrotlidec, libbrotlienc