@omnibuf/core 0.0.8 → 0.1.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.
- package/dist/blind.d.ts +3 -3
- package/dist/blind.d.ts.map +1 -1
- package/dist/blind.js +191 -31
- package/dist/blind.js.map +1 -1
- package/dist/encoder.d.ts +5 -5
- package/dist/encoder.d.ts.map +1 -1
- package/dist/encoder.js +25 -4
- package/dist/encoder.js.map +1 -1
- package/dist/protobuf-es.d.ts +2 -0
- package/dist/protobuf-es.d.ts.map +1 -1
- package/dist/protobuf-es.js +40 -8
- package/dist/protobuf-es.js.map +1 -1
- package/dist/readers.d.ts +4 -3
- package/dist/readers.d.ts.map +1 -1
- package/dist/readers.js +405 -120
- package/dist/readers.js.map +1 -1
- package/dist/schema.d.ts +9 -4
- package/dist/schema.d.ts.map +1 -1
- package/dist/schema.js +202 -79
- package/dist/schema.js.map +1 -1
- package/dist/validation.d.ts.map +1 -1
- package/dist/validation.js +16 -14
- package/dist/validation.js.map +1 -1
- package/dist/wire.d.ts +16 -3
- package/dist/wire.d.ts.map +1 -1
- package/dist/wire.js +303 -23
- package/dist/wire.js.map +1 -1
- package/package.json +1 -1
package/dist/readers.js
CHANGED
|
@@ -1,21 +1,23 @@
|
|
|
1
1
|
// ============================================================================
|
|
2
2
|
// Header-Scanning Field Readers (O(1) Per-Field Skip) & Wire Splicing (Opaque API)
|
|
3
3
|
// ============================================================================
|
|
4
|
+
import { decodeSchemaMeta } from './blind.js';
|
|
4
5
|
import { Encoder } from './encoder.js';
|
|
5
|
-
import {
|
|
6
|
+
import { validateMessage, validateValue } from './validation.js';
|
|
7
|
+
import { WireArray, WireBoolFalse, WireBoolTrue, WireBytes, WireFixed32, WireFixed64, WireFloat32, WireFloat64, WireMap, WireSfixed32, WireSfixed64, WireSint, WireString, WireSubMsg, WireUint, decodeUTF8, decodeVarint, decodeVarintAuto, decodeVarintBigInt, decodeZigZag, decodeZigZag32, decodeZigZagAuto, decodeZigZagBigInt, float32FromBits, float64FromBits, locateField, nextContainerField, parseArrayHeader, parseMapHeader, readLenSlice, roundFloat32Shortest, skipValidatedValue, validateField0At, } from './wire.js';
|
|
6
8
|
// ============================================================================
|
|
7
9
|
// Scalar Readers
|
|
8
10
|
// ============================================================================
|
|
9
11
|
export function readUint(packet, fieldNum) {
|
|
10
|
-
const { valSlice,
|
|
11
|
-
if (!ok
|
|
12
|
+
const { valSlice, ok } = locateField(packet, fieldNum, 1 << WireUint);
|
|
13
|
+
if (!ok)
|
|
12
14
|
return [0, false];
|
|
13
15
|
const [v, n] = decodeVarint(valSlice, 0);
|
|
14
16
|
return [v, n > 0];
|
|
15
17
|
}
|
|
16
18
|
export function readUint32(packet, fieldNum) {
|
|
17
|
-
const { valSlice,
|
|
18
|
-
if (!ok ||
|
|
19
|
+
const { valSlice, ok } = locateField(packet, fieldNum, 1 << WireUint);
|
|
20
|
+
if (!ok || valSlice.length === 0)
|
|
19
21
|
return [0, false];
|
|
20
22
|
const b0 = valSlice[0];
|
|
21
23
|
if ((b0 & 7) !== 0) {
|
|
@@ -28,30 +30,32 @@ export function readUint32(packet, fieldNum) {
|
|
|
28
30
|
return [lo, true];
|
|
29
31
|
}
|
|
30
32
|
export function readInt32(packet, fieldNum) {
|
|
31
|
-
const
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
33
|
+
const { valSlice, ok } = locateField(packet, fieldNum, 1 << WireSint);
|
|
34
|
+
if (!ok)
|
|
35
|
+
return [0, false];
|
|
36
|
+
const [u, n] = decodeVarintBigInt(valSlice, 0);
|
|
37
|
+
if (n === 0)
|
|
38
|
+
return [0, false];
|
|
39
|
+
return [decodeZigZag32(u), true];
|
|
37
40
|
}
|
|
41
|
+
export const readEnum = readInt32;
|
|
38
42
|
export function readUintBigInt(packet, fieldNum) {
|
|
39
|
-
const { valSlice,
|
|
40
|
-
if (!ok
|
|
43
|
+
const { valSlice, ok } = locateField(packet, fieldNum, 1 << WireUint);
|
|
44
|
+
if (!ok)
|
|
41
45
|
return [0n, false];
|
|
42
46
|
const [v, n] = decodeVarintBigInt(valSlice, 0);
|
|
43
47
|
return [v, n > 0];
|
|
44
48
|
}
|
|
45
49
|
export function readUintAuto(packet, fieldNum) {
|
|
46
|
-
const { valSlice,
|
|
47
|
-
if (!ok
|
|
50
|
+
const { valSlice, ok } = locateField(packet, fieldNum, 1 << WireUint);
|
|
51
|
+
if (!ok)
|
|
48
52
|
return [0, false];
|
|
49
53
|
const [v, n] = decodeVarintAuto(valSlice, 0);
|
|
50
54
|
return [v, n > 0];
|
|
51
55
|
}
|
|
52
56
|
export function readInt(packet, fieldNum) {
|
|
53
|
-
const { valSlice,
|
|
54
|
-
if (!ok
|
|
57
|
+
const { valSlice, ok } = locateField(packet, fieldNum, 1 << WireSint);
|
|
58
|
+
if (!ok)
|
|
55
59
|
return [0, false];
|
|
56
60
|
const [u, n] = decodeVarintBigInt(valSlice, 0);
|
|
57
61
|
if (n === 0)
|
|
@@ -59,8 +63,8 @@ export function readInt(packet, fieldNum) {
|
|
|
59
63
|
return [decodeZigZag(u), true];
|
|
60
64
|
}
|
|
61
65
|
export function readIntBigInt(packet, fieldNum) {
|
|
62
|
-
const { valSlice,
|
|
63
|
-
if (!ok
|
|
66
|
+
const { valSlice, ok } = locateField(packet, fieldNum, 1 << WireSint);
|
|
67
|
+
if (!ok)
|
|
64
68
|
return [0n, false];
|
|
65
69
|
const [u, n] = decodeVarintBigInt(valSlice, 0);
|
|
66
70
|
if (n === 0)
|
|
@@ -68,8 +72,8 @@ export function readIntBigInt(packet, fieldNum) {
|
|
|
68
72
|
return [decodeZigZagBigInt(u), true];
|
|
69
73
|
}
|
|
70
74
|
export function readIntAuto(packet, fieldNum) {
|
|
71
|
-
const { valSlice,
|
|
72
|
-
if (!ok
|
|
75
|
+
const { valSlice, ok } = locateField(packet, fieldNum, 1 << WireSint);
|
|
76
|
+
if (!ok)
|
|
73
77
|
return [0, false];
|
|
74
78
|
const [u, n] = decodeVarintBigInt(valSlice, 0);
|
|
75
79
|
if (n === 0)
|
|
@@ -77,39 +81,39 @@ export function readIntAuto(packet, fieldNum) {
|
|
|
77
81
|
return [decodeZigZagAuto(u), true];
|
|
78
82
|
}
|
|
79
83
|
export function readBool(packet, fieldNum) {
|
|
80
|
-
const { wireType, ok } = locateField(packet, fieldNum);
|
|
81
|
-
if (!ok
|
|
84
|
+
const { wireType, ok } = locateField(packet, fieldNum, (1 << WireBoolFalse) | (1 << WireBoolTrue));
|
|
85
|
+
if (!ok) {
|
|
82
86
|
return [false, false];
|
|
83
87
|
}
|
|
84
88
|
return [wireType === WireBoolTrue, true];
|
|
85
89
|
}
|
|
86
90
|
export function readFixed32(packet, fieldNum) {
|
|
87
|
-
const { valSlice,
|
|
88
|
-
if (!ok ||
|
|
91
|
+
const { valSlice, ok } = locateField(packet, fieldNum, 1 << WireFixed32);
|
|
92
|
+
if (!ok || valSlice.length < 4) {
|
|
89
93
|
return [0, false];
|
|
90
94
|
}
|
|
91
95
|
const bits = (valSlice[0] | (valSlice[1] << 8) | (valSlice[2] << 16) | (valSlice[3] << 24)) >>> 0;
|
|
92
96
|
return [bits, true];
|
|
93
97
|
}
|
|
94
98
|
export function readSfixed32(packet, fieldNum) {
|
|
95
|
-
const { valSlice,
|
|
96
|
-
if (!ok ||
|
|
99
|
+
const { valSlice, ok } = locateField(packet, fieldNum, 1 << WireSfixed32);
|
|
100
|
+
if (!ok || valSlice.length < 4) {
|
|
97
101
|
return [0, false];
|
|
98
102
|
}
|
|
99
103
|
const bits = valSlice[0] | (valSlice[1] << 8) | (valSlice[2] << 16) | (valSlice[3] << 24) | 0;
|
|
100
104
|
return [bits, true];
|
|
101
105
|
}
|
|
102
106
|
export function readFloat32(packet, fieldNum) {
|
|
103
|
-
const { valSlice,
|
|
104
|
-
if (!ok ||
|
|
107
|
+
const { valSlice, ok } = locateField(packet, fieldNum, 1 << WireFloat32);
|
|
108
|
+
if (!ok || valSlice.length < 4) {
|
|
105
109
|
return [0, false];
|
|
106
110
|
}
|
|
107
111
|
const bits = (valSlice[0] | (valSlice[1] << 8) | (valSlice[2] << 16) | (valSlice[3] << 24)) >>> 0;
|
|
108
112
|
return [float32FromBits(bits), true];
|
|
109
113
|
}
|
|
110
114
|
export function readFixed64(packet, fieldNum) {
|
|
111
|
-
const { valSlice,
|
|
112
|
-
if (!ok ||
|
|
115
|
+
const { valSlice, ok } = locateField(packet, fieldNum, 1 << WireFixed64);
|
|
116
|
+
if (!ok || valSlice.length < 8) {
|
|
113
117
|
return [0n, false];
|
|
114
118
|
}
|
|
115
119
|
let u64 = 0n;
|
|
@@ -125,8 +129,8 @@ export function readFixed64Auto(packet, fieldNum) {
|
|
|
125
129
|
return [u64 <= 9007199254740991n ? Number(u64) : u64, true];
|
|
126
130
|
}
|
|
127
131
|
export function readSfixed64(packet, fieldNum) {
|
|
128
|
-
const { valSlice,
|
|
129
|
-
if (!ok ||
|
|
132
|
+
const { valSlice, ok } = locateField(packet, fieldNum, 1 << WireSfixed64);
|
|
133
|
+
if (!ok || valSlice.length < 8) {
|
|
130
134
|
return [0n, false];
|
|
131
135
|
}
|
|
132
136
|
let u64 = 0n;
|
|
@@ -142,8 +146,8 @@ export function readSfixed64Auto(packet, fieldNum) {
|
|
|
142
146
|
return [s64 >= -9007199254740991n && s64 <= 9007199254740991n ? Number(s64) : s64, true];
|
|
143
147
|
}
|
|
144
148
|
export function readFloat64(packet, fieldNum) {
|
|
145
|
-
const { valSlice,
|
|
146
|
-
if (!ok ||
|
|
149
|
+
const { valSlice, ok } = locateField(packet, fieldNum, 1 << WireFloat64);
|
|
150
|
+
if (!ok || valSlice.length < 8) {
|
|
147
151
|
return [0, false];
|
|
148
152
|
}
|
|
149
153
|
let u64 = 0n;
|
|
@@ -153,8 +157,8 @@ export function readFloat64(packet, fieldNum) {
|
|
|
153
157
|
return [float64FromBits(u64), true];
|
|
154
158
|
}
|
|
155
159
|
function locateStringSlice(packet, fieldNum) {
|
|
156
|
-
const { valSlice,
|
|
157
|
-
if (!ok ||
|
|
160
|
+
const { valSlice, ok } = locateField(packet, fieldNum, 1 << WireString);
|
|
161
|
+
if (!ok || valSlice.length === 0) {
|
|
158
162
|
return [new Uint8Array(0), false];
|
|
159
163
|
}
|
|
160
164
|
const b0 = valSlice[0];
|
|
@@ -195,8 +199,8 @@ export function readString(packet, fieldNum) {
|
|
|
195
199
|
}
|
|
196
200
|
}
|
|
197
201
|
export function readBytes(packet, fieldNum) {
|
|
198
|
-
const { valSlice,
|
|
199
|
-
if (!ok
|
|
202
|
+
const { valSlice, ok } = locateField(packet, fieldNum, 1 << WireBytes);
|
|
203
|
+
if (!ok) {
|
|
200
204
|
return [new Uint8Array(0), false];
|
|
201
205
|
}
|
|
202
206
|
const [bLen, bn] = decodeVarintBigInt(valSlice, 0);
|
|
@@ -242,6 +246,12 @@ export function readSubMsg(packet, fieldNum) {
|
|
|
242
246
|
let off = 0;
|
|
243
247
|
for (let i = 0; i < chunks.length; i++) {
|
|
244
248
|
const c = chunks[i];
|
|
249
|
+
try {
|
|
250
|
+
validateMessage(c, 1);
|
|
251
|
+
}
|
|
252
|
+
catch {
|
|
253
|
+
return [new Uint8Array(0), false];
|
|
254
|
+
}
|
|
245
255
|
merged.set(c, off);
|
|
246
256
|
off += c.length;
|
|
247
257
|
}
|
|
@@ -256,6 +266,7 @@ export function readElem(arrPayload, index) {
|
|
|
256
266
|
}
|
|
257
267
|
let pos = startP;
|
|
258
268
|
const n = arrPayload.length;
|
|
269
|
+
let foundElem = new Uint8Array(0);
|
|
259
270
|
for (let i = 0; i < count; i++) {
|
|
260
271
|
if (pos >= n)
|
|
261
272
|
return [new Uint8Array(0), false];
|
|
@@ -285,11 +296,14 @@ export function readElem(arrPayload, index) {
|
|
|
285
296
|
return [new Uint8Array(0), false];
|
|
286
297
|
}
|
|
287
298
|
if (i === index) {
|
|
288
|
-
|
|
299
|
+
foundElem = arrPayload.subarray(pos, pos + elemLen);
|
|
289
300
|
}
|
|
290
301
|
pos += elemLen;
|
|
291
302
|
}
|
|
292
|
-
|
|
303
|
+
if (pos !== n) {
|
|
304
|
+
return [new Uint8Array(0), false];
|
|
305
|
+
}
|
|
306
|
+
return [foundElem, true];
|
|
293
307
|
}
|
|
294
308
|
export function countSubMsgArrElems(arrPayload) {
|
|
295
309
|
const [elemType, count, startP, ok] = parseArrayHeader(arrPayload);
|
|
@@ -348,17 +362,26 @@ export function readSubMsgArrElem(packet, fieldNum, index) {
|
|
|
348
362
|
return [new Uint8Array(0), false];
|
|
349
363
|
let remIdx = index;
|
|
350
364
|
let pos = 0;
|
|
365
|
+
let foundElem = new Uint8Array(0);
|
|
366
|
+
let found = false;
|
|
351
367
|
while (true) {
|
|
352
368
|
const { body, nextPos, matched, valid } = nextContainerField(packet, pos, fieldNum, WireArray, 2);
|
|
353
|
-
if (!valid
|
|
369
|
+
if (!valid)
|
|
354
370
|
return [new Uint8Array(0), false];
|
|
371
|
+
if (!matched)
|
|
372
|
+
return [foundElem, found];
|
|
355
373
|
pos = nextPos;
|
|
374
|
+
if (!found) {
|
|
375
|
+
const [elem, elemOk] = readElem(body, remIdx);
|
|
376
|
+
if (elemOk) {
|
|
377
|
+
foundElem = elem;
|
|
378
|
+
found = true;
|
|
379
|
+
continue;
|
|
380
|
+
}
|
|
381
|
+
}
|
|
356
382
|
const [c, validArr] = countSubMsgArrElems(body);
|
|
357
383
|
if (!validArr)
|
|
358
384
|
return [new Uint8Array(0), false];
|
|
359
|
-
if (remIdx < c) {
|
|
360
|
-
return readElem(body, remIdx);
|
|
361
|
-
}
|
|
362
385
|
remIdx -= c;
|
|
363
386
|
}
|
|
364
387
|
}
|
|
@@ -395,31 +418,136 @@ export function readArrNestedString(packet, arrField, index, targetField) {
|
|
|
395
418
|
// ============================================================================
|
|
396
419
|
// Packed & Counted Array Readers
|
|
397
420
|
// ============================================================================
|
|
421
|
+
function validateCountedArrBody(body, elemType, count, startP) {
|
|
422
|
+
const n = body.length;
|
|
423
|
+
let p = startP;
|
|
424
|
+
switch (elemType) {
|
|
425
|
+
case WireBoolFalse: {
|
|
426
|
+
if (n - p !== count)
|
|
427
|
+
return false;
|
|
428
|
+
for (let i = 0; i < count; i++) {
|
|
429
|
+
const b = body[p + i];
|
|
430
|
+
if (b !== 0 && b !== 1)
|
|
431
|
+
return false;
|
|
432
|
+
}
|
|
433
|
+
return true;
|
|
434
|
+
}
|
|
435
|
+
case WireFixed32:
|
|
436
|
+
case WireSfixed32:
|
|
437
|
+
case WireFloat32:
|
|
438
|
+
return n - p === count * 4;
|
|
439
|
+
case WireFixed64:
|
|
440
|
+
case WireSfixed64:
|
|
441
|
+
case WireFloat64:
|
|
442
|
+
return n - p === count * 8;
|
|
443
|
+
case WireString: {
|
|
444
|
+
for (let i = 0; i < count; i++) {
|
|
445
|
+
if (p >= n)
|
|
446
|
+
return false;
|
|
447
|
+
const [sLen, sn] = decodeVarintBigInt(body, p);
|
|
448
|
+
if (sn === 0 || sLen > BigInt(n - (p + sn)))
|
|
449
|
+
return false;
|
|
450
|
+
p += sn;
|
|
451
|
+
const end = p + Number(sLen);
|
|
452
|
+
try {
|
|
453
|
+
decodeUTF8(body, p, end);
|
|
454
|
+
}
|
|
455
|
+
catch {
|
|
456
|
+
return false;
|
|
457
|
+
}
|
|
458
|
+
p = end;
|
|
459
|
+
}
|
|
460
|
+
return p === n;
|
|
461
|
+
}
|
|
462
|
+
case WireBytes: {
|
|
463
|
+
for (let i = 0; i < count; i++) {
|
|
464
|
+
if (p >= n)
|
|
465
|
+
return false;
|
|
466
|
+
const [bLen, bn] = decodeVarintBigInt(body, p);
|
|
467
|
+
if (bn === 0 || bLen > BigInt(n - (p + bn)))
|
|
468
|
+
return false;
|
|
469
|
+
p += bn + Number(bLen);
|
|
470
|
+
}
|
|
471
|
+
return p === n;
|
|
472
|
+
}
|
|
473
|
+
case WireUint:
|
|
474
|
+
case WireSint: {
|
|
475
|
+
for (let i = 0; i < count; i++) {
|
|
476
|
+
if (p >= n)
|
|
477
|
+
return false;
|
|
478
|
+
const [, vn] = decodeVarintBigInt(body, p);
|
|
479
|
+
if (vn === 0)
|
|
480
|
+
return false;
|
|
481
|
+
p += vn;
|
|
482
|
+
}
|
|
483
|
+
return p === n;
|
|
484
|
+
}
|
|
485
|
+
case WireSubMsg: {
|
|
486
|
+
for (let i = 0; i < count; i++) {
|
|
487
|
+
if (p >= n)
|
|
488
|
+
return false;
|
|
489
|
+
const [sLen, sn] = decodeVarintBigInt(body, p);
|
|
490
|
+
if (sn === 0 || sLen > BigInt(n - (p + sn)))
|
|
491
|
+
return false;
|
|
492
|
+
p += sn;
|
|
493
|
+
const end = p + Number(sLen);
|
|
494
|
+
try {
|
|
495
|
+
validateMessage(body.subarray(p, end), 1);
|
|
496
|
+
}
|
|
497
|
+
catch {
|
|
498
|
+
return false;
|
|
499
|
+
}
|
|
500
|
+
p = end;
|
|
501
|
+
}
|
|
502
|
+
return p === n;
|
|
503
|
+
}
|
|
504
|
+
default: {
|
|
505
|
+
for (let i = 0; i < count; i++) {
|
|
506
|
+
try {
|
|
507
|
+
p = validateValue(body, p, elemType, 1);
|
|
508
|
+
}
|
|
509
|
+
catch {
|
|
510
|
+
return false;
|
|
511
|
+
}
|
|
512
|
+
}
|
|
513
|
+
return p === n;
|
|
514
|
+
}
|
|
515
|
+
}
|
|
516
|
+
}
|
|
398
517
|
export function countedArrLen(packet, fieldNum, expElemWT) {
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
518
|
+
let total = 0;
|
|
519
|
+
let pos = 0;
|
|
520
|
+
while (true) {
|
|
521
|
+
const { body, nextPos, matched, valid } = nextContainerField(packet, pos, fieldNum, WireArray, 2);
|
|
522
|
+
if (!valid)
|
|
523
|
+
return 0;
|
|
524
|
+
if (!matched)
|
|
525
|
+
return total;
|
|
526
|
+
pos = nextPos;
|
|
527
|
+
const [elemType, c, startP, headerOk] = parseArrayHeader(body);
|
|
528
|
+
if (!headerOk)
|
|
529
|
+
return 0;
|
|
530
|
+
if (expElemWT !== undefined && elemType !== expElemWT) {
|
|
531
|
+
return 0;
|
|
532
|
+
}
|
|
533
|
+
if (!validateCountedArrBody(body, elemType, c, startP)) {
|
|
534
|
+
return 0;
|
|
535
|
+
}
|
|
536
|
+
total += c;
|
|
537
|
+
}
|
|
413
538
|
}
|
|
414
539
|
export function appendStringArrBody(dst, body) {
|
|
540
|
+
const origLen = dst.length;
|
|
415
541
|
const n = body.length;
|
|
416
542
|
const [elemType, c, startP, ok] = parseArrayHeader(body);
|
|
417
543
|
if (!ok || elemType !== WireString)
|
|
418
544
|
return [[], false];
|
|
419
545
|
let p = startP;
|
|
420
546
|
for (let i = 0; i < c; i++) {
|
|
421
|
-
if (p >= n)
|
|
547
|
+
if (p >= n) {
|
|
548
|
+
dst.length = origLen;
|
|
422
549
|
return [[], false];
|
|
550
|
+
}
|
|
423
551
|
const sb = body[p];
|
|
424
552
|
let lenNum = 0;
|
|
425
553
|
if ((sb & 1) !== 0) {
|
|
@@ -427,25 +555,37 @@ export function appendStringArrBody(dst, body) {
|
|
|
427
555
|
p += 1;
|
|
428
556
|
}
|
|
429
557
|
else if ((sb & 2) !== 0) {
|
|
430
|
-
if (p + 2 > n)
|
|
558
|
+
if (p + 2 > n) {
|
|
559
|
+
dst.length = origLen;
|
|
431
560
|
return [[], false];
|
|
561
|
+
}
|
|
432
562
|
lenNum = (sb | (body[p + 1] << 8)) >>> 2;
|
|
433
563
|
p += 2;
|
|
434
564
|
}
|
|
435
565
|
else {
|
|
436
566
|
const [sLen, sn] = decodeVarintBigInt(body, p);
|
|
437
567
|
if (sn === 0 || sLen > BigInt(n - (p + sn))) {
|
|
568
|
+
dst.length = origLen;
|
|
438
569
|
return [[], false];
|
|
439
570
|
}
|
|
440
571
|
p += sn;
|
|
441
572
|
lenNum = Number(sLen);
|
|
442
573
|
}
|
|
443
|
-
if (p + lenNum > n)
|
|
574
|
+
if (p + lenNum > n) {
|
|
575
|
+
dst.length = origLen;
|
|
444
576
|
return [[], false];
|
|
445
|
-
|
|
577
|
+
}
|
|
578
|
+
try {
|
|
579
|
+
dst.push(decodeUTF8(body, p, p + lenNum));
|
|
580
|
+
}
|
|
581
|
+
catch {
|
|
582
|
+
dst.length = origLen;
|
|
583
|
+
return [[], false];
|
|
584
|
+
}
|
|
446
585
|
p += lenNum;
|
|
447
586
|
}
|
|
448
587
|
if (p !== n) {
|
|
588
|
+
dst.length = origLen;
|
|
449
589
|
return [[], false];
|
|
450
590
|
}
|
|
451
591
|
return [dst, true];
|
|
@@ -535,7 +675,7 @@ export function appendEnumArrBody(dst, body) {
|
|
|
535
675
|
if (vn === 0)
|
|
536
676
|
return [[], false];
|
|
537
677
|
p += vn;
|
|
538
|
-
dst.push(
|
|
678
|
+
dst.push(decodeZigZag32(v));
|
|
539
679
|
}
|
|
540
680
|
if (p !== body.length) {
|
|
541
681
|
return [[], false];
|
|
@@ -889,10 +1029,15 @@ export function readSubMsgMerged(packet, fieldNum, decodeFn) {
|
|
|
889
1029
|
wt = Number(tag & 0x0fn);
|
|
890
1030
|
pos += tn;
|
|
891
1031
|
}
|
|
892
|
-
if (fnum === 0
|
|
893
|
-
|
|
894
|
-
|
|
895
|
-
|
|
1032
|
+
if (fnum === 0) {
|
|
1033
|
+
const f0End = validateField0At(packet, pos, wt, 0);
|
|
1034
|
+
if (f0End < 0)
|
|
1035
|
+
return [null, false];
|
|
1036
|
+
pos = f0End;
|
|
1037
|
+
continue;
|
|
1038
|
+
}
|
|
1039
|
+
if (fnum === fieldNum && wt === WireSubMsg) {
|
|
1040
|
+
if (pos >= n)
|
|
896
1041
|
return [null, false];
|
|
897
1042
|
let lenNum = 0;
|
|
898
1043
|
const lb = packet[pos];
|
|
@@ -915,19 +1060,23 @@ export function readSubMsgMerged(packet, fieldNum, decodeFn) {
|
|
|
915
1060
|
}
|
|
916
1061
|
if (pos + lenNum > n)
|
|
917
1062
|
return [null, false];
|
|
918
|
-
|
|
919
|
-
|
|
920
|
-
|
|
1063
|
+
try {
|
|
1064
|
+
out = useRange
|
|
1065
|
+
? decodeFn(packet, out, found, pos, pos + lenNum)
|
|
1066
|
+
: decodeFn(packet.subarray(pos, pos + lenNum), out, found);
|
|
1067
|
+
}
|
|
1068
|
+
catch {
|
|
1069
|
+
return [null, false];
|
|
1070
|
+
}
|
|
921
1071
|
found = true;
|
|
922
1072
|
pos += lenNum;
|
|
923
1073
|
continue;
|
|
924
1074
|
}
|
|
925
|
-
|
|
926
|
-
|
|
927
|
-
}
|
|
928
|
-
catch {
|
|
1075
|
+
const nextPos = skipValidatedValue(packet, pos, wt);
|
|
1076
|
+
if (nextPos < 0) {
|
|
929
1077
|
return [null, false];
|
|
930
1078
|
}
|
|
1079
|
+
pos = nextPos;
|
|
931
1080
|
}
|
|
932
1081
|
return [out ?? null, found];
|
|
933
1082
|
}
|
|
@@ -951,7 +1100,12 @@ export function readSubMsgArrDecoded(packet, fieldNum, decodeFn) {
|
|
|
951
1100
|
const [el, en] = decodeVarintBigInt(body, p);
|
|
952
1101
|
p += en;
|
|
953
1102
|
const elNum = Number(el);
|
|
954
|
-
|
|
1103
|
+
try {
|
|
1104
|
+
out.push(decodeFn(body.subarray(p, p + elNum)));
|
|
1105
|
+
}
|
|
1106
|
+
catch {
|
|
1107
|
+
return [[], false];
|
|
1108
|
+
}
|
|
955
1109
|
p += elNum;
|
|
956
1110
|
}
|
|
957
1111
|
}
|
|
@@ -997,7 +1151,7 @@ function readMapEntryPayload(body, p, wt, scalarKind, decodeSubMsg) {
|
|
|
997
1151
|
throw new Error('omnibuf: truncated map sint');
|
|
998
1152
|
const s = decodeZigZagAuto(v);
|
|
999
1153
|
if (scalarKind === 'int32' || scalarKind === 'sint32' || scalarKind === 'enum') {
|
|
1000
|
-
return [Number(s) | 0, p + vn];
|
|
1154
|
+
return [typeof s === 'bigint' ? Number(BigInt.asIntN(32, s)) : s | 0, p + vn];
|
|
1001
1155
|
}
|
|
1002
1156
|
return [s, p + vn];
|
|
1003
1157
|
}
|
|
@@ -1059,7 +1213,47 @@ function readMapEntryPayload(body, p, wt, scalarKind, decodeSubMsg) {
|
|
|
1059
1213
|
throw new Error(`omnibuf: unsupported map wire type ${wt}`);
|
|
1060
1214
|
}
|
|
1061
1215
|
}
|
|
1216
|
+
function expectedMapEntryWireType(kind) {
|
|
1217
|
+
switch (kind) {
|
|
1218
|
+
case 'uint32':
|
|
1219
|
+
case 'uint64':
|
|
1220
|
+
return WireUint;
|
|
1221
|
+
case 'int32':
|
|
1222
|
+
case 'int64':
|
|
1223
|
+
case 'sint32':
|
|
1224
|
+
case 'sint64':
|
|
1225
|
+
case 'enum':
|
|
1226
|
+
return WireSint;
|
|
1227
|
+
case 'bool':
|
|
1228
|
+
return WireBoolFalse;
|
|
1229
|
+
case 'fixed32':
|
|
1230
|
+
return WireFixed32;
|
|
1231
|
+
case 'fixed64':
|
|
1232
|
+
return WireFixed64;
|
|
1233
|
+
case 'sfixed32':
|
|
1234
|
+
return WireSfixed32;
|
|
1235
|
+
case 'sfixed64':
|
|
1236
|
+
return WireSfixed64;
|
|
1237
|
+
case 'float32':
|
|
1238
|
+
return WireFloat32;
|
|
1239
|
+
case 'float64':
|
|
1240
|
+
return WireFloat64;
|
|
1241
|
+
case 'string':
|
|
1242
|
+
return WireString;
|
|
1243
|
+
case 'bytes':
|
|
1244
|
+
return WireBytes;
|
|
1245
|
+
case 'submsg':
|
|
1246
|
+
return WireSubMsg;
|
|
1247
|
+
default:
|
|
1248
|
+
return -1;
|
|
1249
|
+
}
|
|
1250
|
+
}
|
|
1062
1251
|
export function readTypedMap(packet, fieldNum, keyType, valType, decodeSubMsg) {
|
|
1252
|
+
const expKeyWT = expectedMapEntryWireType(keyType);
|
|
1253
|
+
const expValWT = expectedMapEntryWireType(valType);
|
|
1254
|
+
if (expKeyWT < 0 || expValWT < 0) {
|
|
1255
|
+
return [{}, false];
|
|
1256
|
+
}
|
|
1063
1257
|
const out = {};
|
|
1064
1258
|
let found = false;
|
|
1065
1259
|
let pos = 0;
|
|
@@ -1071,21 +1265,26 @@ export function readTypedMap(packet, fieldNum, keyType, valType, decodeSubMsg) {
|
|
|
1071
1265
|
return [out, found];
|
|
1072
1266
|
pos = nextPos;
|
|
1073
1267
|
const [keyWT, valWT, c, startP, ok] = parseMapHeader(body);
|
|
1074
|
-
if (!ok) {
|
|
1268
|
+
if (!ok || keyWT !== expKeyWT || valWT !== expValWT) {
|
|
1075
1269
|
return [{}, false];
|
|
1076
1270
|
}
|
|
1077
1271
|
found = true;
|
|
1078
1272
|
let p = startP;
|
|
1079
|
-
|
|
1080
|
-
|
|
1081
|
-
|
|
1082
|
-
|
|
1083
|
-
|
|
1084
|
-
|
|
1085
|
-
|
|
1086
|
-
|
|
1087
|
-
|
|
1088
|
-
|
|
1273
|
+
try {
|
|
1274
|
+
for (let i = 0; i < c; i++) {
|
|
1275
|
+
const [kVal, p1] = readMapEntryPayload(body, p, keyWT, keyType);
|
|
1276
|
+
const [vVal, p2] = readMapEntryPayload(body, p1, valWT, valType, decodeSubMsg);
|
|
1277
|
+
p = p2;
|
|
1278
|
+
Object.defineProperty(out, String(kVal), {
|
|
1279
|
+
value: vVal,
|
|
1280
|
+
writable: true,
|
|
1281
|
+
enumerable: true,
|
|
1282
|
+
configurable: true,
|
|
1283
|
+
});
|
|
1284
|
+
}
|
|
1285
|
+
}
|
|
1286
|
+
catch {
|
|
1287
|
+
return [{}, false];
|
|
1089
1288
|
}
|
|
1090
1289
|
if (p !== body.length) {
|
|
1091
1290
|
return [{}, false];
|
|
@@ -1118,7 +1317,13 @@ export function lookupMapStringUint(packet, fieldNum, targetKey) {
|
|
|
1118
1317
|
}
|
|
1119
1318
|
p += kn;
|
|
1120
1319
|
const kLenNum = Number(kLen);
|
|
1121
|
-
|
|
1320
|
+
let k;
|
|
1321
|
+
try {
|
|
1322
|
+
k = decodeUTF8(body, p, p + kLenNum);
|
|
1323
|
+
}
|
|
1324
|
+
catch {
|
|
1325
|
+
return [0, false];
|
|
1326
|
+
}
|
|
1122
1327
|
p += kLenNum;
|
|
1123
1328
|
const [v, vn] = decodeVarintAuto(body, p);
|
|
1124
1329
|
if (vn === 0)
|
|
@@ -1175,8 +1380,13 @@ export function activeOneofSlice(packet, targetField, oneofSpecs) {
|
|
|
1175
1380
|
wt = Number(tag & 0x0fn);
|
|
1176
1381
|
pos += tn;
|
|
1177
1382
|
}
|
|
1178
|
-
if (fnum === 0
|
|
1179
|
-
|
|
1383
|
+
if (fnum === 0) {
|
|
1384
|
+
const f0End = validateField0At(packet, pos, wt, 0);
|
|
1385
|
+
if (f0End < 0) {
|
|
1386
|
+
return null;
|
|
1387
|
+
}
|
|
1388
|
+
pos = f0End;
|
|
1389
|
+
continue;
|
|
1180
1390
|
}
|
|
1181
1391
|
for (let i = 0; i < oneofSpecs.length; i++) {
|
|
1182
1392
|
const spec = oneofSpecs[i];
|
|
@@ -1201,14 +1411,53 @@ export function activeOneofSlice(packet, targetField, oneofSpecs) {
|
|
|
1201
1411
|
}
|
|
1202
1412
|
const sharedSpliceEncoder = new Encoder(8192);
|
|
1203
1413
|
let sharedSpliceInUse = false;
|
|
1414
|
+
function extractDirtySetFromBigInt(mask, maxField) {
|
|
1415
|
+
const dirtySet = new Set();
|
|
1416
|
+
let remMask = mask & ~1n;
|
|
1417
|
+
let bitBase = 0;
|
|
1418
|
+
while (remMask !== 0n && bitBase <= maxField) {
|
|
1419
|
+
if ((remMask & 0xffffffffffffffffn) === 0n) {
|
|
1420
|
+
let shift = 64;
|
|
1421
|
+
while ((remMask & ((1n << BigInt(shift)) - 1n)) === 0n && bitBase + shift <= maxField) {
|
|
1422
|
+
shift *= 2;
|
|
1423
|
+
}
|
|
1424
|
+
if (shift > 64)
|
|
1425
|
+
shift >>= 1;
|
|
1426
|
+
remMask >>= BigInt(shift);
|
|
1427
|
+
bitBase += shift;
|
|
1428
|
+
continue;
|
|
1429
|
+
}
|
|
1430
|
+
let wordLo = Number(remMask & 0xffffffffn) >>> 0;
|
|
1431
|
+
let wordHi = Number((remMask >> 32n) & 0xffffffffn) >>> 0;
|
|
1432
|
+
while (wordLo !== 0) {
|
|
1433
|
+
const tz = 31 - Math.clz32(wordLo & -wordLo);
|
|
1434
|
+
const fn = bitBase + tz;
|
|
1435
|
+
if (fn >= 1 && fn <= maxField)
|
|
1436
|
+
dirtySet.add(fn);
|
|
1437
|
+
wordLo &= wordLo - 1;
|
|
1438
|
+
}
|
|
1439
|
+
while (wordHi !== 0) {
|
|
1440
|
+
const tz = 31 - Math.clz32(wordHi & -wordHi);
|
|
1441
|
+
const fn = bitBase + 32 + tz;
|
|
1442
|
+
if (fn >= 1 && fn <= maxField)
|
|
1443
|
+
dirtySet.add(fn);
|
|
1444
|
+
wordHi &= wordHi - 1;
|
|
1445
|
+
}
|
|
1446
|
+
remMask >>= 64n;
|
|
1447
|
+
bitBase += 64;
|
|
1448
|
+
}
|
|
1449
|
+
return dirtySet;
|
|
1450
|
+
}
|
|
1204
1451
|
/**
|
|
1205
1452
|
* Splices unmodified contiguous byte ranges from `raw` and invokes `appendDirty`
|
|
1206
|
-
* only for fields whose bit is set in `dirtyMask
|
|
1453
|
+
* only for fields whose bit is set in `dirtyMask` (or present in a `ReadonlySet<number>`),
|
|
1454
|
+
* avoiding any decoding of untouched fields.
|
|
1207
1455
|
*/
|
|
1208
1456
|
export function spliceFields(raw, dirtyMask, maxField, appendDirty, enc) {
|
|
1209
|
-
if (maxField <= 30) {
|
|
1457
|
+
if (maxField <= 30 && (typeof dirtyMask === 'number' || typeof dirtyMask === 'bigint')) {
|
|
1210
1458
|
const mask32 = typeof dirtyMask === 'bigint' ? Number(dirtyMask & 0x7fffffffn) : dirtyMask | 0;
|
|
1211
1459
|
if (mask32 === 0) {
|
|
1460
|
+
validateMessage(raw, 0);
|
|
1212
1461
|
if (enc !== undefined) {
|
|
1213
1462
|
enc.detachIfOverlaps(raw, 0);
|
|
1214
1463
|
enc.writeRaw(raw);
|
|
@@ -1258,10 +1507,17 @@ export function spliceFields(raw, dirtyMask, maxField, appendDirty, enc) {
|
|
|
1258
1507
|
}
|
|
1259
1508
|
const fnum = tag <= 0x7fffffff ? tag >>> 4 : Math.floor(tag / 16);
|
|
1260
1509
|
const wt = tag & 0x0f;
|
|
1261
|
-
if (fnum === 0
|
|
1262
|
-
|
|
1510
|
+
if (fnum === 0) {
|
|
1511
|
+
if (wt !== WireSubMsg) {
|
|
1512
|
+
throw new Error('omnibuf: invalid Field #0 wire type');
|
|
1513
|
+
}
|
|
1514
|
+
const [f0Body, f0End] = readLenSlice(raw, pos, 0);
|
|
1515
|
+
decodeSchemaMeta(f0Body, 1);
|
|
1516
|
+
pos = f0End;
|
|
1517
|
+
}
|
|
1518
|
+
else {
|
|
1519
|
+
pos = validateValue(raw, pos, wt, 0);
|
|
1263
1520
|
}
|
|
1264
|
-
pos = skipValue(raw, pos, wt);
|
|
1265
1521
|
const fieldEnd = pos;
|
|
1266
1522
|
const bit = fnum >= 1 && fnum <= maxField ? 1 << fnum : 0;
|
|
1267
1523
|
if ((mask32 & bit) !== 0) {
|
|
@@ -1296,8 +1552,11 @@ export function spliceFields(raw, dirtyMask, maxField, appendDirty, enc) {
|
|
|
1296
1552
|
sharedSpliceInUse = false;
|
|
1297
1553
|
}
|
|
1298
1554
|
}
|
|
1299
|
-
const
|
|
1300
|
-
|
|
1555
|
+
const dirtySet = typeof dirtyMask === 'object' && dirtyMask !== null
|
|
1556
|
+
? dirtyMask
|
|
1557
|
+
: extractDirtySetFromBigInt(typeof dirtyMask === 'bigint' ? dirtyMask : BigInt(dirtyMask >>> 0), maxField);
|
|
1558
|
+
if (dirtySet.size === 0) {
|
|
1559
|
+
validateMessage(raw, 0);
|
|
1301
1560
|
if (enc !== undefined) {
|
|
1302
1561
|
enc.detachIfOverlaps(raw, 0);
|
|
1303
1562
|
enc.writeRaw(raw);
|
|
@@ -1315,45 +1574,71 @@ export function spliceFields(raw, dirtyMask, maxField, appendDirty, enc) {
|
|
|
1315
1574
|
const n = raw.length;
|
|
1316
1575
|
let pos = 0;
|
|
1317
1576
|
let cleanStart = 0;
|
|
1318
|
-
|
|
1577
|
+
const emittedSet = new Set();
|
|
1319
1578
|
while (pos < n) {
|
|
1320
1579
|
const fieldStart = pos;
|
|
1321
|
-
|
|
1322
|
-
|
|
1323
|
-
|
|
1324
|
-
|
|
1325
|
-
|
|
1326
|
-
|
|
1327
|
-
|
|
1328
|
-
|
|
1329
|
-
|
|
1580
|
+
let tag = 0;
|
|
1581
|
+
const b0 = raw[pos];
|
|
1582
|
+
if ((b0 & 1) !== 0) {
|
|
1583
|
+
tag = b0 >>> 1;
|
|
1584
|
+
pos += 1;
|
|
1585
|
+
}
|
|
1586
|
+
else if ((b0 & 2) !== 0) {
|
|
1587
|
+
if (pos + 2 > n)
|
|
1588
|
+
throw new Error('omnibuf: invalid tag while splicing');
|
|
1589
|
+
tag = ((b0 | (raw[pos + 1] << 8)) >>> 2) >>> 0;
|
|
1590
|
+
pos += 2;
|
|
1591
|
+
}
|
|
1592
|
+
else {
|
|
1593
|
+
const [t64, width] = decodeVarintBigInt(raw, pos);
|
|
1594
|
+
if (!width || t64 >> 4n > 536870911n)
|
|
1595
|
+
throw new Error('omnibuf: invalid tag while splicing');
|
|
1596
|
+
tag = Number(t64);
|
|
1597
|
+
pos += width;
|
|
1598
|
+
}
|
|
1599
|
+
const fnum = tag <= 0x7fffffff ? tag >>> 4 : Math.floor(tag / 16);
|
|
1600
|
+
const wt = tag & 0x0f;
|
|
1601
|
+
if (fnum === 0) {
|
|
1602
|
+
if (wt !== WireSubMsg) {
|
|
1603
|
+
throw new Error('omnibuf: invalid Field #0 wire type');
|
|
1604
|
+
}
|
|
1605
|
+
const [f0Body, f0End] = readLenSlice(raw, pos, 0);
|
|
1606
|
+
decodeSchemaMeta(f0Body, 1);
|
|
1607
|
+
pos = f0End;
|
|
1608
|
+
}
|
|
1609
|
+
else {
|
|
1610
|
+
pos = validateValue(raw, pos, wt, 0);
|
|
1611
|
+
}
|
|
1330
1612
|
const fieldEnd = pos;
|
|
1331
|
-
|
|
1332
|
-
if ((mask & bit) !== 0n) {
|
|
1613
|
+
if (fnum >= 1 && fnum <= maxField && dirtySet.has(fnum)) {
|
|
1333
1614
|
if (cleanStart < fieldStart) {
|
|
1334
1615
|
activeEnc.writeRaw(raw.subarray(cleanStart, fieldStart));
|
|
1335
1616
|
}
|
|
1336
|
-
if ((
|
|
1617
|
+
if (!emittedSet.has(fnum)) {
|
|
1337
1618
|
appendDirty(activeEnc, fnum);
|
|
1338
|
-
|
|
1619
|
+
emittedSet.add(fnum);
|
|
1339
1620
|
}
|
|
1340
1621
|
cleanStart = fieldEnd;
|
|
1341
1622
|
}
|
|
1342
|
-
else {
|
|
1343
|
-
|
|
1623
|
+
else if (fnum >= 1) {
|
|
1624
|
+
emittedSet.add(fnum);
|
|
1344
1625
|
}
|
|
1345
1626
|
}
|
|
1346
1627
|
if (cleanStart < n) {
|
|
1347
1628
|
activeEnc.writeRaw(raw.subarray(cleanStart, n));
|
|
1348
1629
|
}
|
|
1349
|
-
const
|
|
1350
|
-
|
|
1351
|
-
|
|
1352
|
-
|
|
1353
|
-
appendDirty(activeEnc, fnum);
|
|
1354
|
-
}
|
|
1630
|
+
const remaining = [];
|
|
1631
|
+
for (const fn of dirtySet) {
|
|
1632
|
+
if (fn >= 1 && fn <= maxField && !emittedSet.has(fn)) {
|
|
1633
|
+
remaining.push(fn);
|
|
1355
1634
|
}
|
|
1356
1635
|
}
|
|
1636
|
+
if (remaining.length > 1) {
|
|
1637
|
+
remaining.sort((a, b) => a - b);
|
|
1638
|
+
}
|
|
1639
|
+
for (let i = 0; i < remaining.length; i++) {
|
|
1640
|
+
appendDirty(activeEnc, remaining[i]);
|
|
1641
|
+
}
|
|
1357
1642
|
return activeEnc.finish();
|
|
1358
1643
|
}
|
|
1359
1644
|
//# sourceMappingURL=readers.js.map
|