@omnibuf/core 0.0.8 → 0.1.2

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/wire.js CHANGED
@@ -58,7 +58,7 @@ export function parseArrayHeader(body, start = 0, end = body.length) {
58
58
  cn = 2;
59
59
  }
60
60
  else {
61
- const [count64, cBytes] = decodeVarintBigInt(body, start + 1);
61
+ const [count64, cBytes] = decodeVarintBigInt(body, start + 1, end);
62
62
  if (cBytes === 0 || count64 > BigInt(end - (start + 1 + cBytes))) {
63
63
  return [0, 0, 0, false];
64
64
  }
@@ -91,7 +91,7 @@ export function parseArrayHeader(body, start = 0, end = body.length) {
91
91
  return [0, 0, 0, false];
92
92
  }
93
93
  }
94
- else if (countNum > remaining) {
94
+ else if (countNum === 0 ? remaining !== 0 : countNum > remaining) {
95
95
  return [0, 0, 0, false];
96
96
  }
97
97
  return [elemType, countNum, pos, true];
@@ -133,7 +133,7 @@ export function parseMapHeader(body, start = 0, end = body.length) {
133
133
  cn = 2;
134
134
  }
135
135
  else {
136
- const [count64, cBytes] = decodeVarintBigInt(body, start + 2);
136
+ const [count64, cBytes] = decodeVarintBigInt(body, start + 2, end);
137
137
  if (cBytes === 0 || count64 > BigInt(Math.floor((end - (start + 2 + cBytes)) / 2))) {
138
138
  return [0, 0, 0, 0, false];
139
139
  }
@@ -141,7 +141,7 @@ export function parseMapHeader(body, start = 0, end = body.length) {
141
141
  cn = cBytes;
142
142
  }
143
143
  const pos = start + 2 + cn;
144
- if (pos > end || countNum > (end - pos) >>> 1) {
144
+ if (pos > end || (countNum === 0 ? end !== pos : countNum > (end - pos) >>> 1)) {
145
145
  return [0, 0, 0, 0, false];
146
146
  }
147
147
  return [keyWT, valWT, countNum, pos, true];
@@ -153,6 +153,10 @@ const sharedTextDecoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: tru
153
153
  * Returns `null` if any byte is non-ASCII (`>= 0x80`) or if `end - start > 64`.
154
154
  */
155
155
  export function fastDecodeShortASCII(bytes, start, end) {
156
+ if (start < 0)
157
+ start = 0;
158
+ if (end > bytes.length)
159
+ end = bytes.length;
156
160
  const len = end - start;
157
161
  if (len <= 0)
158
162
  return '';
@@ -364,18 +368,27 @@ export function decodeZigZagBigInt(u) {
364
368
  return BigInt.asIntN(64, (b >> 1n) ^ -(b & 1n));
365
369
  }
366
370
  /**
367
- * Maps a ZigZag-encoded unsigned integer back to a signed JS number (when safe)
368
- * or bigint (when outside Number.MAX_SAFE_INTEGER).
371
+ * Maps a ZigZag-encoded unsigned integer back to a signed JS number.
369
372
  */
370
373
  export function decodeZigZag(u) {
371
374
  if (typeof u === 'number' && u <= 0xffffffff) {
372
- return (u >>> 1) ^ -(u & 1);
375
+ const res = (u >>> 1) ^ -(u & 1);
376
+ return res === 0 ? 0 : res;
373
377
  }
374
- const b = decodeZigZagBigInt(u);
375
- if (b >= -9007199254740991n && b <= 9007199254740991n) {
376
- return Number(b);
378
+ const n = Number(decodeZigZagBigInt(u));
379
+ return n === 0 ? 0 : n;
380
+ }
381
+ /**
382
+ * Maps a ZigZag-encoded unsigned integer back to a signed 32-bit JS number,
383
+ * retaining the exact low 32 bits even when the wire value exceeds 2^53.
384
+ */
385
+ export function decodeZigZag32(u) {
386
+ if (typeof u === 'number' && u <= 0xffffffff) {
387
+ const res = (u >>> 1) ^ -(u & 1);
388
+ return res === 0 ? 0 : res;
377
389
  }
378
- return Number(BigInt.asIntN(32, b));
390
+ const n = Number(BigInt.asIntN(32, decodeZigZagBigInt(u)));
391
+ return n === 0 ? 0 : n;
379
392
  }
380
393
  /**
381
394
  * Decodes a ZigZag value returning a JS number when within safe integer bounds,
@@ -767,7 +780,7 @@ function isValidArrayHeaderAt(body, start, end) {
767
780
  case WireSfixed64:
768
781
  return (remaining & 7) === 0 && countNum === remaining >>> 3;
769
782
  default:
770
- return countNum <= remaining;
783
+ return countNum === 0 ? remaining === 0 : countNum <= remaining;
771
784
  }
772
785
  }
773
786
  function isValidMapHeaderAt(body, start, end) {
@@ -807,7 +820,7 @@ function isValidMapHeaderAt(body, start, end) {
807
820
  cn = cBytes;
808
821
  }
809
822
  const pos = start + 2 + cn;
810
- return pos <= end && countNum <= (end - pos) >>> 1;
823
+ return pos <= end && (countNum === 0 ? end === pos : countNum <= (end - pos) >>> 1);
811
824
  }
812
825
  export function skipValidatedValue(b, pos, wireType) {
813
826
  const n = b.length;
@@ -911,6 +924,395 @@ export function skipValue(b, pos, wireType) {
911
924
  }
912
925
  return nextPos;
913
926
  }
927
+ function validateUnknownEntryAt(body, p, wt, depth, limit) {
928
+ if (wt === WireBoolFalse) {
929
+ if (p >= body.length || (body[p] !== 0 && body[p] !== 1))
930
+ return -1;
931
+ return p + 1;
932
+ }
933
+ if (wt === WireSubMsg) {
934
+ if (p >= body.length)
935
+ return -1;
936
+ const [bLen, bn] = decodeVarintBigInt(body, p);
937
+ if (bn === 0 || bLen > BigInt(body.length - (p + bn)))
938
+ return -1;
939
+ const start = p + bn;
940
+ const end = start + Number(bLen);
941
+ if (!validateUnknownMessageBytes(body.subarray(start, end), depth + 1, limit))
942
+ return -1;
943
+ return end;
944
+ }
945
+ if (wt === WireArray || wt === WireMap) {
946
+ return validateUnknownValueAt(body, p, wt, depth, limit);
947
+ }
948
+ return skipValidatedValue(body, p, wt);
949
+ }
950
+ function validateUnknownValueAt(data, pos, wt, depth, limit) {
951
+ if (depth > limit)
952
+ return -1;
953
+ if (wt === WireSubMsg) {
954
+ if (pos >= data.length)
955
+ return -1;
956
+ const [bLen, bn] = decodeVarintBigInt(data, pos);
957
+ if (bn === 0 || bLen > BigInt(data.length - (pos + bn)))
958
+ return -1;
959
+ const start = pos + bn;
960
+ const end = start + Number(bLen);
961
+ if (!validateUnknownMessageBytes(data.subarray(start, end), depth + 1, limit))
962
+ return -1;
963
+ return end;
964
+ }
965
+ if (wt === WireArray) {
966
+ if (depth + 1 > limit || pos >= data.length)
967
+ return -1;
968
+ const [bLen, bn] = decodeVarintBigInt(data, pos);
969
+ if (bn === 0 || bLen < 2n || bLen > BigInt(data.length - (pos + bn)))
970
+ return -1;
971
+ const end = pos + bn + Number(bLen);
972
+ const body = data.subarray(pos + bn, end);
973
+ const [elemType, count, startP, ok] = parseArrayHeader(body);
974
+ if (!ok)
975
+ return -1;
976
+ let p = startP;
977
+ if (elemType === WireBoolFalse) {
978
+ if (body.length - p !== count)
979
+ return -1;
980
+ for (let i = 0; i < count; i++) {
981
+ const b = body[p + i];
982
+ if (b !== 0 && b !== 1)
983
+ return -1;
984
+ }
985
+ return end;
986
+ }
987
+ if (elemType === WireFixed32 || elemType === WireSfixed32 || elemType === WireFloat32) {
988
+ return body.length - p === count * 4 ? end : -1;
989
+ }
990
+ if (elemType === WireFixed64 || elemType === WireSfixed64 || elemType === WireFloat64) {
991
+ return body.length - p === count * 8 ? end : -1;
992
+ }
993
+ for (let i = 0; i < count; i++) {
994
+ p = validateUnknownEntryAt(body, p, elemType, depth + 1, limit);
995
+ if (p < 0)
996
+ return -1;
997
+ }
998
+ return p === body.length ? end : -1;
999
+ }
1000
+ if (wt === WireMap) {
1001
+ if (depth + 1 > limit || pos >= data.length)
1002
+ return -1;
1003
+ const [bLen, bn] = decodeVarintBigInt(data, pos);
1004
+ if (bn === 0 || bLen < 3n || bLen > BigInt(data.length - (pos + bn)))
1005
+ return -1;
1006
+ const end = pos + bn + Number(bLen);
1007
+ const body = data.subarray(pos + bn, end);
1008
+ const [keyWT, valWT, count, startP, ok] = parseMapHeader(body);
1009
+ if (!ok)
1010
+ return -1;
1011
+ let p = startP;
1012
+ for (let i = 0; i < count; i++) {
1013
+ p = validateUnknownEntryAt(body, p, keyWT, depth + 1, limit);
1014
+ if (p < 0)
1015
+ return -1;
1016
+ p = validateUnknownEntryAt(body, p, valWT, depth + 1, limit);
1017
+ if (p < 0)
1018
+ return -1;
1019
+ }
1020
+ return p === body.length ? end : -1;
1021
+ }
1022
+ return skipValidatedValue(data, pos, wt);
1023
+ }
1024
+ function validateUnknownMessageBytes(data, depth, limit = MaxNestingDepth) {
1025
+ if (depth > limit)
1026
+ return false;
1027
+ let pos = 0;
1028
+ while (pos < data.length) {
1029
+ const [tag, tn] = decodeVarintBigInt(data, pos);
1030
+ if (tn === 0 || tag >> 4n > 536870911n)
1031
+ return false;
1032
+ pos += tn;
1033
+ const fnum = Number(tag >> 4n);
1034
+ const wt = Number(tag & 0x0fn);
1035
+ if (fnum === 0) {
1036
+ const nextPos = validateField0At(data, pos, wt, depth, limit);
1037
+ if (nextPos < 0)
1038
+ return false;
1039
+ pos = nextPos;
1040
+ }
1041
+ else {
1042
+ const nextPos = validateUnknownValueAt(data, pos, wt, depth, limit);
1043
+ if (nextPos < 0)
1044
+ return false;
1045
+ pos = nextPos;
1046
+ }
1047
+ }
1048
+ return true;
1049
+ }
1050
+ function isValidUTF8Slice(bytes, start, end) {
1051
+ for (let i = start; i < end; i++) {
1052
+ if (bytes[i] >= 0x80) {
1053
+ try {
1054
+ sharedTextDecoder.decode(bytes.subarray(start, end));
1055
+ return true;
1056
+ }
1057
+ catch {
1058
+ return false;
1059
+ }
1060
+ }
1061
+ }
1062
+ return true;
1063
+ }
1064
+ /**
1065
+ * Validates an `omnibuf.v1.SchemaMeta` payload at `depth`.
1066
+ */
1067
+ export function validateSchemaMetaBytes(data, depth, limit = MaxNestingDepth, start = 0, endLimit = data.length) {
1068
+ if (depth > limit)
1069
+ return false;
1070
+ let pos = start;
1071
+ const n = endLimit;
1072
+ while (pos < n) {
1073
+ let fnum = 0;
1074
+ let wt = 0;
1075
+ const tb = data[pos];
1076
+ if ((tb & 1) !== 0) {
1077
+ fnum = tb >>> 5;
1078
+ wt = (tb >>> 1) & 0x0f;
1079
+ pos += 1;
1080
+ }
1081
+ else if ((tb & 2) !== 0) {
1082
+ if (pos + 2 > n)
1083
+ return false;
1084
+ const u16 = (tb | (data[pos + 1] << 8)) >>> 2;
1085
+ fnum = u16 >>> 4;
1086
+ wt = u16 & 0x0f;
1087
+ pos += 2;
1088
+ }
1089
+ else {
1090
+ const [tag, tn] = decodeVarintBigInt(data, pos, n);
1091
+ if (tn === 0 || tag >> 4n > 536870911n)
1092
+ return false;
1093
+ pos += tn;
1094
+ fnum = Number(tag >> 4n);
1095
+ wt = Number(tag & 0x0fn);
1096
+ }
1097
+ switch (fnum) {
1098
+ case 1: {
1099
+ if (wt !== WireString || pos >= n)
1100
+ return false;
1101
+ let sLen = 0;
1102
+ const sb = data[pos];
1103
+ if ((sb & 1) !== 0) {
1104
+ sLen = sb >>> 1;
1105
+ pos += 1;
1106
+ }
1107
+ else {
1108
+ const [sl64, sn] = decodeVarintBigInt(data, pos, n);
1109
+ if (sn === 0 || sl64 > BigInt(n - (pos + sn)))
1110
+ return false;
1111
+ pos += sn;
1112
+ sLen = Number(sl64);
1113
+ }
1114
+ const end = pos + sLen;
1115
+ if (end > n || !isValidUTF8Slice(data, pos, end))
1116
+ return false;
1117
+ pos = end;
1118
+ break;
1119
+ }
1120
+ case 2: {
1121
+ if (wt !== WireMap || depth + 1 > limit || pos >= n)
1122
+ return false;
1123
+ let bLen = 0;
1124
+ const lb = data[pos];
1125
+ if ((lb & 1) !== 0) {
1126
+ bLen = lb >>> 1;
1127
+ pos += 1;
1128
+ }
1129
+ else if ((lb & 2) !== 0) {
1130
+ if (pos + 2 > n)
1131
+ return false;
1132
+ bLen = (lb | (data[pos + 1] << 8)) >>> 2;
1133
+ pos += 2;
1134
+ }
1135
+ else {
1136
+ const [bl64, bn] = decodeVarintBigInt(data, pos, n);
1137
+ if (bn === 0 || bl64 > BigInt(n - (pos + bn)))
1138
+ return false;
1139
+ pos += bn;
1140
+ bLen = Number(bl64);
1141
+ }
1142
+ const bodyEnd = pos + bLen;
1143
+ if (bLen < 3 || bodyEnd > n)
1144
+ return false;
1145
+ const [keyWT, valWT, count, startP, ok] = parseMapHeader(data, pos, bodyEnd);
1146
+ if (!ok || keyWT !== WireUint || valWT !== WireString)
1147
+ return false;
1148
+ let p = startP;
1149
+ for (let i = 0; i < count; i++) {
1150
+ if (p >= bodyEnd)
1151
+ return false;
1152
+ let kNum = 0;
1153
+ const kb = data[p];
1154
+ if ((kb & 1) !== 0) {
1155
+ kNum = kb >>> 1;
1156
+ p += 1;
1157
+ }
1158
+ else {
1159
+ const [k64, kn] = decodeVarintBigInt(data, p, bodyEnd);
1160
+ if (kn === 0 || k64 === 0n || k64 > 536870911n)
1161
+ return false;
1162
+ p += kn;
1163
+ kNum = Number(k64);
1164
+ }
1165
+ if (kNum === 0 || kNum > 536870911 || p >= bodyEnd)
1166
+ return false;
1167
+ let sLen = 0;
1168
+ const sb = data[p];
1169
+ if ((sb & 1) !== 0) {
1170
+ sLen = sb >>> 1;
1171
+ p += 1;
1172
+ }
1173
+ else {
1174
+ const [sl64, sn] = decodeVarintBigInt(data, p, bodyEnd);
1175
+ if (sn === 0 || sl64 > BigInt(bodyEnd - (p + sn)))
1176
+ return false;
1177
+ p += sn;
1178
+ sLen = Number(sl64);
1179
+ }
1180
+ const sEnd = p + sLen;
1181
+ if (sEnd > bodyEnd || !isValidUTF8Slice(data, p, sEnd))
1182
+ return false;
1183
+ p = sEnd;
1184
+ }
1185
+ if (p !== bodyEnd)
1186
+ return false;
1187
+ pos = bodyEnd;
1188
+ break;
1189
+ }
1190
+ case 3: {
1191
+ if (wt !== WireMap || depth + 1 > limit || pos >= n)
1192
+ return false;
1193
+ let bLen = 0;
1194
+ const lb = data[pos];
1195
+ if ((lb & 1) !== 0) {
1196
+ bLen = lb >>> 1;
1197
+ pos += 1;
1198
+ }
1199
+ else if ((lb & 2) !== 0) {
1200
+ if (pos + 2 > n)
1201
+ return false;
1202
+ bLen = (lb | (data[pos + 1] << 8)) >>> 2;
1203
+ pos += 2;
1204
+ }
1205
+ else {
1206
+ const [bl64, bn] = decodeVarintBigInt(data, pos, n);
1207
+ if (bn === 0 || bl64 > BigInt(n - (pos + bn)))
1208
+ return false;
1209
+ pos += bn;
1210
+ bLen = Number(bl64);
1211
+ }
1212
+ const bodyEnd = pos + bLen;
1213
+ if (bLen < 3 || bodyEnd > n)
1214
+ return false;
1215
+ const [keyWT, valWT, count, startP, ok] = parseMapHeader(data, pos, bodyEnd);
1216
+ if (!ok || keyWT !== WireUint || valWT !== WireSubMsg)
1217
+ return false;
1218
+ let p = startP;
1219
+ for (let i = 0; i < count; i++) {
1220
+ if (p >= bodyEnd)
1221
+ return false;
1222
+ let kNum = 0;
1223
+ const kb = data[p];
1224
+ if ((kb & 1) !== 0) {
1225
+ kNum = kb >>> 1;
1226
+ p += 1;
1227
+ }
1228
+ else {
1229
+ const [k64, kn] = decodeVarintBigInt(data, p, bodyEnd);
1230
+ if (kn === 0 || k64 === 0n || k64 > 536870911n)
1231
+ return false;
1232
+ p += kn;
1233
+ kNum = Number(k64);
1234
+ }
1235
+ if (kNum === 0 || kNum > 536870911 || p >= bodyEnd)
1236
+ return false;
1237
+ let cLen = 0;
1238
+ const cb = data[p];
1239
+ if ((cb & 1) !== 0) {
1240
+ cLen = cb >>> 1;
1241
+ p += 1;
1242
+ }
1243
+ else if ((cb & 2) !== 0) {
1244
+ if (p + 2 > bodyEnd)
1245
+ return false;
1246
+ cLen = (cb | (data[p + 1] << 8)) >>> 2;
1247
+ p += 2;
1248
+ }
1249
+ else {
1250
+ const [cl64, cn] = decodeVarintBigInt(data, p, bodyEnd);
1251
+ if (cn === 0 || cl64 > BigInt(bodyEnd - (p + cn)))
1252
+ return false;
1253
+ p += cn;
1254
+ cLen = Number(cl64);
1255
+ }
1256
+ const cEnd = p + cLen;
1257
+ if (cEnd > bodyEnd || !validateSchemaMetaBytes(data, depth + 2, limit, p, cEnd)) {
1258
+ return false;
1259
+ }
1260
+ p = cEnd;
1261
+ }
1262
+ if (p !== bodyEnd)
1263
+ return false;
1264
+ pos = bodyEnd;
1265
+ break;
1266
+ }
1267
+ default: {
1268
+ if (fnum === 0)
1269
+ return false;
1270
+ const sub = n === data.length ? data : data.subarray(0, n);
1271
+ const nextPos = validateUnknownValueAt(sub, pos, wt, depth, limit);
1272
+ if (nextPos < 0)
1273
+ return false;
1274
+ pos = nextPos;
1275
+ break;
1276
+ }
1277
+ }
1278
+ }
1279
+ return true;
1280
+ }
1281
+ /**
1282
+ * Validates a `Field #0` (`omnibuf.v1.SchemaMeta`) entry starting at value offset `pos`.
1283
+ * Returns the end offset after `Field #0`, or `-1` if invalid.
1284
+ */
1285
+ export function validateField0At(packet, pos, wt, depth = 0, limit = MaxNestingDepth, endLimit = packet.length) {
1286
+ if (wt !== WireSubMsg || pos < 0 || pos >= endLimit)
1287
+ return -1;
1288
+ let bLen = 0;
1289
+ let bn = 0;
1290
+ const lb = packet[pos];
1291
+ if ((lb & 1) !== 0) {
1292
+ bLen = lb >>> 1;
1293
+ bn = 1;
1294
+ }
1295
+ else if ((lb & 2) !== 0) {
1296
+ if (pos + 2 > endLimit)
1297
+ return -1;
1298
+ bLen = (lb | (packet[pos + 1] << 8)) >>> 2;
1299
+ bn = 2;
1300
+ }
1301
+ else {
1302
+ const [bl64, nBytes] = decodeVarintBigInt(packet, pos, endLimit);
1303
+ if (nBytes === 0 || bl64 > BigInt(endLimit - (pos + nBytes)))
1304
+ return -1;
1305
+ bLen = Number(bl64);
1306
+ bn = nBytes;
1307
+ }
1308
+ const start = pos + bn;
1309
+ const end = start + bLen;
1310
+ if (end > endLimit)
1311
+ return -1;
1312
+ if (!validateSchemaMetaBytes(packet, depth + 1, limit, start, end))
1313
+ return -1;
1314
+ return end;
1315
+ }
914
1316
  const NOT_FOUND = {
915
1317
  valSlice: new Uint8Array(0),
916
1318
  valPos: 0,
@@ -922,7 +1324,7 @@ const NOT_FOUND = {
922
1324
  * using TZCNT length prefixes (without parsing inside preceding strings, sub-messages, or arrays).
923
1325
  * Scans all field headers in the message and returns the last matching occurrence ("last write wins").
924
1326
  */
925
- export function locateField(packet, targetField) {
1327
+ export function locateField(packet, targetField, expMask = 0xffff) {
926
1328
  let pos = 0;
927
1329
  const n = packet.length;
928
1330
  let lastPos = -1;
@@ -953,10 +1355,19 @@ export function locateField(packet, targetField) {
953
1355
  wt = Number(tag & 0x0fn);
954
1356
  pos += tn;
955
1357
  }
956
- if (fnum === 0 && wt !== WireSubMsg) {
957
- return NOT_FOUND;
1358
+ if (fnum === 0) {
1359
+ const f0End = validateField0At(packet, pos, wt, 0);
1360
+ if (f0End < 0) {
1361
+ return NOT_FOUND;
1362
+ }
1363
+ if (targetField === 0 && ((expMask >>> wt) & 1) !== 0) {
1364
+ lastPos = pos;
1365
+ lastWT = wt;
1366
+ }
1367
+ pos = f0End;
1368
+ continue;
958
1369
  }
959
- if (fnum === targetField) {
1370
+ if (fnum === targetField && ((expMask >>> wt) & 1) !== 0) {
960
1371
  lastPos = pos;
961
1372
  lastWT = wt;
962
1373
  }
@@ -1009,11 +1420,19 @@ export function nextContainerField(packet, pos, targetField, expWT, minLen) {
1009
1420
  wt = Number(tag & 0x0fn);
1010
1421
  pos += tn;
1011
1422
  }
1423
+ if (fnum === 0 && targetField !== 0) {
1424
+ const f0End = validateField0At(packet, pos, wt, 0);
1425
+ if (f0End < 0) {
1426
+ return { body: new Uint8Array(0), nextPos: 0, matched: false, valid: false };
1427
+ }
1428
+ pos = f0End;
1429
+ continue;
1430
+ }
1012
1431
  if (fnum === 0 && wt !== WireSubMsg) {
1013
1432
  return { body: new Uint8Array(0), nextPos: 0, matched: false, valid: false };
1014
1433
  }
1015
- if (fnum === targetField) {
1016
- if (wt !== expWT || pos >= n) {
1434
+ if (fnum === targetField && wt === expWT) {
1435
+ if (pos >= n) {
1017
1436
  return { body: new Uint8Array(0), nextPos: 0, matched: false, valid: false };
1018
1437
  }
1019
1438
  let lenNum = 0;
@@ -1050,12 +1469,11 @@ export function nextContainerField(packet, pos, targetField, expWT, minLen) {
1050
1469
  valid: true,
1051
1470
  };
1052
1471
  }
1053
- try {
1054
- pos = skipValue(packet, pos, wt);
1055
- }
1056
- catch {
1472
+ const nextPos = skipValidatedValue(packet, pos, wt);
1473
+ if (nextPos < 0) {
1057
1474
  return { body: new Uint8Array(0), nextPos: 0, matched: false, valid: false };
1058
1475
  }
1476
+ pos = nextPos;
1059
1477
  }
1060
1478
  return { body: new Uint8Array(0), nextPos: n, matched: false, valid: true };
1061
1479
  }